// @(#)root/asimage:$Id: TASImage.cxx,v 1.54 2006/03/13 15:18:56 rdm E
// Author: Fons Rademakers, Reiner Rohlfs, Valeriy Onuchin   28/11/2001

/*************************************************************************
 * Copyright (C) 1995-2001, Rene Brun, Fons Rademakers and Reiner Rohlfs *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

/**************************************************************************
 * Some parts of this source are based on libAfterImage 2.00.00
 *          (http://www.afterstep.org/)
 *
 * Copyright (c) 2002 Sasha Vasko <sasha@aftercode.net>
 * Copyright (c) 1998, 1999 Ethan Fischer <allanon@crystaltokyo.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library 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 Library General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 **************************************************************************/


//______________________________________________________________________________
/* Begin_Html
<center><h2>Image class</h2></center>
TASImage is the concrete interface to the image processing library
libAfterImage.
<p>
It allows reading and writing of images in different formats, several image
manipulations (scaling, tiling, merging, etc.) and displaying in pads. The size
of the image on the screen does not depend on the original size of the image but
on the size of the pad. Therefore it is very easy to resize the image on the
screen by resizing the pad.
<p>
Besides reading an image from a file an image can be defined by a two
dimensional array of values. A palette defines the color of each value.
<p>
The image can be zoomed by defining a rectangle with the mouse. The color
palette can be modified with a GUI, just select StartPaletteEditor() from the
context menu.
<p>
Several examples showing how to use this class are available in the
ROOT tutorials: <tt>$ROOTSYS/tutorials/image/</tt>
End_Html */

#  include <ft2build.h>
#  include FT_FREETYPE_H
#  include FT_GLYPH_H
#include "TASImage.h"
#include "TASImagePlugin.h"
#include "TROOT.h"
#include "TMath.h"
#include "TSystem.h"
#include "TVirtualX.h"
#include "TVirtualPad.h"
#include "TArrayD.h"
#include "TVectorD.h"
#include "TVirtualPS.h"
#include "TGaxis.h"
#include "TColor.h"
#include "TObjArray.h"
#include "TArrayL.h"
#include "TPoint.h"
#include "TFrame.h"
#include "TTF.h"
#include "TRandom.h"
#include "Riostream.h"
#include "THashTable.h"
#include "TPluginManager.h"
#include "TEnv.h"
#include "TStyle.h"
#include "TText.h"
#include "RConfigure.h"
#include "TVirtualPadPainter.h"

#ifndef WIN32
#ifndef R__HAS_COCOA
#   include <X11/Xlib.h>
#endif
#else
#   include "Windows4root.h"
#endif
extern "C" {
#ifndef WIN32
#ifdef R__HAS_COCOA
#   define X_DISPLAY_MISSING 1
#endif
#   include <afterbase.h>
#else
#   include <win32/config.h>
#   include <win32/afterbase.h>
#   define X_DISPLAY_MISSING 1
#endif
#   include <afterimage.h>
#   include <bmp.h>
#   include <draw.h>
}

// auxilary functions for general polygon filling
#include "TASPolyUtils.c"


ASVisual *TASImage::fgVisual = 0;
Bool_t TASImage::fgInit = kFALSE;

static ASFontManager *gFontManager = 0;
static unsigned long kAllPlanes = ~0;
THashTable *TASImage::fgPlugList = new THashTable(50);

// default icon paths
static char *gIconPaths[7] = {0, 0, 0, 0, 0, 0, 0};

///////////////////////////// alphablending macros ///////////////////////////////

#if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3)) && !__INTEL_COMPILER
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif

#ifdef R__BYTESWAP
typedef struct {
   unsigned char b;
   unsigned char g;
   unsigned char r;
   unsigned char a;
} __argb32__;
#else
typedef struct {
   unsigned char a;
   unsigned char r;
   unsigned char g;
   unsigned char b;
} __argb32__;
#endif


//______________________________________________________________________________
#define _alphaBlend(bot, top) {\
   __argb32__ *t = (__argb32__*)(top);\
   __argb32__ *b = (__argb32__*)(bot);\
   int aa = 255-t->a;\
   if (!aa) {\
      *bot = *top;\
   } else { \
      b->a = ((b->a*aa)>>8) + t->a;\
      b->r = (b->r*aa + t->r*t->a)>>8;\
      b->g = (b->g*aa + t->g*t->a)>>8;\
      b->b = (b->b*aa + t->b*t->a)>>8;\
   }\
}\


ClassImp(TASImage)
ClassImp(TASImagePlugin)


//______________________________________________________________________________
void TASImage::DestroyImage()
{
   // Destroy image.

   if (fImage) {
      destroy_asimage(&fImage);
   }

   if (fIsGray && fGrayImage) {
      destroy_asimage(&fGrayImage);
   }

   fIsGray     = kFALSE;
   fGrayImage  = 0;
   fImage      = 0;
}


//______________________________________________________________________________
void TASImage::SetDefaults()
{
   // Set default parameters.

   fImage         = 0;
   fScaledImage   = 0;
   fMaxValue      = 1;
   fMinValue      = 0;
   fEditable      = kFALSE;
   fPaintMode     = 1;
   fZoomOffX      = 0;
   fZoomOffY      = 0;
   fZoomWidth     = 0;
   fZoomHeight    = 0;
   fZoomUpdate    = kZoomOps;

   fGrayImage     = 0;
   fIsGray        = kFALSE;
   fPaletteEnabled = kFALSE;

   if (!fgInit) {
      set_application_name((char*)(gProgName ? gProgName : "ROOT"));
      fgInit = kTRUE;
   }
}


//______________________________________________________________________________
TASImage::TASImage()
{
   // Default image constructor.

   SetDefaults();
}


//______________________________________________________________________________
TASImage::TASImage(UInt_t w, UInt_t h) : TImage(w, h)
{
   // Create an empty image.

   SetDefaults();
   fImage = create_asimage(w ? w : 20, h ? h : 20, 0);
   UnZoom();
}


//______________________________________________________________________________
TASImage::TASImage(const char *file, EImageFileTypes) : TImage(file)
{
   // Create an image object and read from specified file.
   // For more information see description of function ReadImage()
   // which is called by this constructor.

   SetDefaults();
   TString fname = file;
   gSystem->ExpandPathName(fname);
   ReadImage(fname.Data());
}


//______________________________________________________________________________
TASImage::TASImage(const char *name, const Double_t *imageData, UInt_t width,
                   UInt_t height, TImagePalette *palette) : TImage(name)
{
   // Create an image depending on the values of imageData.
   // For more information see function SetImage() which is called
   // by this constructor.

   SetDefaults();
   SetImage(imageData, width, height, palette);
}


//______________________________________________________________________________
TASImage::TASImage(const char *name, const TArrayD &imageData, UInt_t width,
                   TImagePalette *palette) : TImage(name)
{
   // Create an image depending on the values of imageData.
   // The size of the image is width X (imageData.fN / width).
   // For more information see function SetImage() which is called by
   // this constructor.

   SetDefaults();
   SetImage(imageData, width, palette);
}


//______________________________________________________________________________
TASImage::TASImage(const char *name, const TVectorD &imageData, UInt_t width,
                   TImagePalette *palette) : TImage(name)
{
   // Create an image depending on the values of imageData.
   // The size of the image is width X (imageData.fN / width).
   // For more information see function SetImage() which is called by
   // this constructor.

   SetDefaults();
   SetImage(imageData, width, palette);
}


//______________________________________________________________________________
TASImage::TASImage(const TASImage &img) : TImage(img)
{
   // Image copy constructor.

   SetDefaults();

   if (img.IsValid()) {
      fImage = clone_asimage(img.fImage, SCL_DO_ALL);
      fScaledImage   = fScaledImage ? (TASImage*)img.fScaledImage->Clone("") : 0;
      fGrayImage     = fGrayImage ? clone_asimage(img.fGrayImage, SCL_DO_ALL) : 0;

      if (img.fImage->alt.vector) {
         Int_t size = img.fImage->width * img.fImage->height * sizeof(double);
         fImage->alt.vector = (double*)malloc(size);
         memcpy(fImage->alt.vector, img.fImage->alt.vector, size);
      }

      fZoomUpdate = kNoZoom;
      fZoomOffX   = img.fZoomOffX;
      fZoomOffY   = img.fZoomOffY;
      fZoomWidth  = img.fZoomWidth;
      fZoomHeight = img.fZoomHeight;
      fEditable   = img.fEditable;
      fIsGray     = img.fIsGray;
   }
}


//______________________________________________________________________________
TASImage &TASImage::operator=(const TASImage &img)
{
   // Image assignment operator.

   SetDefaults();

   if (this != &img && img.IsValid()) {
      TImage::operator=(img);

      DestroyImage();
      delete fScaledImage;
      fImage = clone_asimage(img.fImage, SCL_DO_ALL);
      fScaledImage = fScaledImage ? (TASImage*)img.fScaledImage->Clone("") : 0;
      fGrayImage = fGrayImage ? clone_asimage(img.fGrayImage, SCL_DO_ALL) : 0;

      if (img.fImage->alt.vector) {
         Int_t size = img.fImage->width * img.fImage->height * sizeof(double);
         fImage->alt.vector = (double*)malloc(size);
         memcpy(fImage->alt.vector, img.fImage->alt.vector, size);
      }

      fScaledImage = img.fScaledImage ? (TASImage*)img.fScaledImage->Clone("") : 0;
      fZoomUpdate = kNoZoom;
      fZoomOffX   = img.fZoomOffX;
      fZoomOffY   = img.fZoomOffY;
      fZoomWidth  = img.fZoomWidth;
      fZoomHeight = img.fZoomHeight;
      fEditable   = img.fEditable;
      fIsGray     = img.fIsGray;
      fPaintMode  = 1;
   }

   return *this;
}


//______________________________________________________________________________
TASImage::~TASImage()
{
   // Image destructor, clean up image and visual.

   DestroyImage();
   delete fScaledImage;
   fScaledImage = 0;
}


//______________________________________________________________________________
static void init_icon_paths()
{
   // Set icons paths.

   const char *icons = "/icons";
#ifdef R__WIN32
      icons = "\\icons";
#endif

   TString homeIcons = gSystem->HomeDirectory();
   homeIcons += icons;

   TString rootIcons = gSystem->Getenv("ROOTSYS");
   rootIcons += icons;

   TString guiIcons = gEnv->GetValue("Gui.IconPath", "");

   gIconPaths[0] = StrDup(".");
   gIconPaths[1] = StrDup(homeIcons.Data());
   gIconPaths[2] = StrDup(rootIcons.Data());
   gIconPaths[3] = StrDup(guiIcons.Data());

#ifdef ROOTICONPATH
   gIconPaths[4] = StrDup(ROOTICONPATH);
#endif

#ifdef EXTRAICONPATH
   gIconPaths[5] = StrDup(EXTRAICONPATH);
#endif

   gIconPaths[6] = 0;
}


//______________________________________________________________________________
const char *TASImage::TypeFromMagicNumber(const char *file)
{
   // Guess the file type from the first byte of file.

   UChar_t magic;
   FILE *fp = fopen(file, "rb");
   const char *ret = "";

   if (!fp) return 0;

   if (!fread(&magic, 1, 1, fp)) {
      fclose(fp);
      return 0;
   }

   switch (magic) {
      case 0x00:
      {
         if (!fread(&magic, 1, 1, fp)) {
            fclose(fp);
            return 0;
         }
         if (!fread(&magic, 1, 1, fp)) {
            fclose(fp);
            return 0;
         }

         ret = (magic == 1) ? "ico" : "cur";
         break;
      }
      case 0x25:
      {
         if (!fread(&magic, 1, 1, fp)) {
            fclose(fp);
            return 0;
         }

         if (magic == 0x21) ret = "ps";
         else if (magic == 0x50) ret = "pdf";
         break;
      }
      case 0x42:
         ret = "bmp";
         break;
      case 0x47:
         ret = "gif";
         break;
      case 0x54:
         ret = "tga";
         break;
      case 0x49:
         ret = "tiff";
         break;
      case 0x89:
         ret = "png";
         break;
      case 0xff:
         ret = "jpg";
         break;
      default:
         ret = "";
   }

   fclose(fp);
   return ret;
}


//______________________________________________________________________________
void TASImage::ReadImage(const char *filename, EImageFileTypes /*type*/)
{
   // Read specified image file.
   // The file type is determined by the file extension (the type argument is
   // ignored). It will attempt to append .gz and then .Z to the filename and
   // find such a file. If the filename ends with extension consisting of digits
   // only, it will attempt to find the file with this extension stripped
   // off. On success this extension will be used to load subimage from
   // the file with that number. Subimage is supported for GIF files
   // (ICO, BMP, CUR, TIFF, XCF to be supported in future).
   //  For example,
   //    i1 = TImage::Open("anim.gif.0"); // read the first subimage
   //    i4 = TImage::Open("anim.gif.3"); // read the forth subimage
   //
   // It is also possible to put XPM raw string (see also SetImageBuffer) as
   // the first input parameter ("filename"), such string  is returned by
   // GetImageBuffer method.

   if (!InitVisual()) {
      Warning("Scale", "Visual not initiated");
      return;
   }

   Bool_t xpm = filename && (filename[0] == '/' &&
                filename[1] == '*') && filename[2] == ' ';

   if (xpm) {  // XPM strings in-memory array
      SetImageBuffer((char**)&filename, TImage::kXpm);
      fName = "XPM_image";
      return;
   }

   if (!gIconPaths[0]) {
      init_icon_paths();
   }
   // suppress the "root : looking for image ..." messages
   set_output_threshold(0);

   static ASImageImportParams iparams;
   iparams.flags = 0;
   iparams.width = 0;
   iparams.height = 0;
   iparams.filter = SCL_DO_ALL;
   iparams.gamma = SCREEN_GAMMA;
   iparams.gamma_table = NULL;
   iparams.compression = GetImageCompression();
   iparams.format = ASA_ASImage;
   iparams.search_path = gIconPaths;
   iparams.subimage = 0;
   iparams.return_animation_delay = -1;

   TString ext;
   const char *dot;
   if (filename) dot = strrchr(filename, '.');
   else          dot = 0;
   ASImage *image = 0;
   TString fname = filename;

   if (!dot) {
      if (filename) ext = TypeFromMagicNumber(filename);
      else ext = dot + 1;
   } else {
      ext = dot + 1;
   }

   if (!ext.IsNull() && ext.IsDigit()) { // read subimage
      iparams.subimage = ext.Atoi();
      fname = fname(0, fname.Length() - ext.Length() - 1);
      ext = strrchr(fname.Data(), '.') + 1;
   }

   image = file2ASImage_extra(fname.Data(), &iparams);

   if (image) { // it's OK
      goto end;
   } else {  // try to read it via plugin
      if (ext.IsNull()) {
         return;
      }
      ext.ToLower();
      ext.Strip();
      UInt_t w = 0;
      UInt_t h = 0;
      unsigned char *bitmap = 0;

      TImagePlugin *plug = (TImagePlugin*)fgPlugList->FindObject(ext.Data());

      if (!plug) {
         TPluginHandler *handler = gROOT->GetPluginManager()->FindHandler("TImagePlugin", ext);
         if (!handler || ((handler->LoadPlugin() == -1))) {
            return;
         }
         plug = (TImagePlugin*)handler->ExecPlugin(1, ext.Data());

         if (!plug) {
            return;
         }

         fgPlugList->Add(plug);
      }

      if (plug) {
         if (plug->InheritsFrom(TASImagePlugin::Class())) {
            image = ((TASImagePlugin*)plug)->File2ASImage(fname.Data());
            if (image) goto end;
         }
         bitmap = plug->ReadFile(fname.Data(), w, h);
         if (bitmap) {
            image = bitmap2asimage(bitmap, w, h, 0, 0);
         }
         if (!image) {
            return;
         }
      }
   }

end:
   fName.Form("%s.", gSystem->BaseName(fname.Data()));

   DestroyImage();
   delete fScaledImage;
   fScaledImage = 0;

   fImage      = image;
   fZoomUpdate = kNoZoom;
   fEditable   = kFALSE;
   fZoomOffX   = 0;
   fZoomOffY   = 0;
   fZoomWidth  = fImage->width;
   fZoomHeight = fImage->height;
   fPaintMode  = 1;
}


//______________________________________________________________________________
void TASImage::WriteImage(const char *file, EImageFileTypes type)
{
   // Write image to specified file.
   // If there is no file extension or if the file extension is unknown, the
   // type argument will be used to determine the file type. The quality and
   // compression is derived from the TAttImage values.
   // It's possible to write image into an animated GIF file by specifying file
   // name as "myfile.gif+" or "myfile.gif+NN", where NN is the delay of displaying
   // subimages during animation in 10ms seconds units. NN is not restricted
   // to two digits. If NN is ommitted the delay between subimages is zero.
   // For an animation that stops after last subimage is reached, one has to
   // write the last image as .gif+ (zero delay of last image) or .gif+NN
   // (NN*10ms delay of last image).
   // For repeated animation (looping), the last subimage must be specified as:
   // (a) "myfile.gif++NN++" if you want an infinite looping gif with NN*10ms
   // delay of the last image.
   // (b) "myfile.gif++" for an infinite loop with zero delay of last image.
   // (c) "myfile.gif+NN++RR" if you want a finite looping gif with NN*10ms
   // delay of the last image and the animation to be stopped after RR
   // repeats. RR is not restricted to two digits.
   // A deprecated version for saving the last subimage of a looping gif animation is:
   // (d) "myfile.gif++NN" for a finite loop where NN is number of repetitions
   // and NN*10ms the delay of last image. (No separate control of repeats and delay).
   // Note: If the file "myfile.gif" already exists, the new frames are appended at
   // the end of the file. To avoid this, delete it first with gSystem->Unlink(myfile.gif);
   //
   // The following macro creates animated gif from jpeg images with names
   //    imageNN.jpg, where 1<= NN <= 10
   //    The delays are set to 10*10ms.
   // {
   //    TImage *img = 0;
   //    gSystem->Unlink("anim.gif");  // delete existing file
   //
   //    for (int i = 1; i <= 10; i++) {
   //       delete img; // delete previous image
   //
   //       // Read image data. Image can be in any format, e.g. png, gif, etc.
   //       img = TImage::Open(Form("image%d.jpg", i));
   //
   //       if (i < 10) {
   //          img->WriteImage("anim.gif+10"); // 10 centiseconds delay
   //       } else { // the last image written.  "++" stands for infinit animation.
   //          img->WriteImage("anim.gif++10++"); // 10 centiseconds delay of last image
   //       }
   //    }
   // }

   if (!IsValid()) {
      Error("WriteImage", "no image loaded");
      return;
   }

   if (!file || !*file) {
      Error("WriteImage", "no file name specified");
      return;
   }

   const char *s;
   if ((s = strrchr(file, '.'))) {
      s++;
      EImageFileTypes t = GetFileType(s);
      if (t == kUnknown) {
         Error("WriteImage", "cannot determine a valid file type");
         return;
      }
      if (t != kUnknown)
         type = t;
   }

   if (type == kUnknown) {
      Error("WriteImage", "not a valid file type was specified");
      return;
   }

   UInt_t mytype;
   MapFileTypes(type, mytype);
   ASImageFileTypes atype = (ASImageFileTypes)mytype;

   UInt_t aquality;
   EImageQuality quality = GetImageQuality();
   MapQuality(quality, aquality);

   static TString fname;
   fname = file;
   static ASImageExportParams parms;
   ASImage *im = fScaledImage ? fScaledImage->fImage : fImage;

   switch (type) {
   case kXpm:
      parms.xpm.type = atype;
      parms.xpm.flags = EXPORT_ALPHA;
      parms.xpm.dither = 4;
      parms.xpm.opaque_threshold = 127;
      parms.xpm.max_colors = 512;
      break;
   case kBmp:
      ASImage2bmp(im, fname.Data(), 0);
      return;
   case kXcf:
      ASImage2xcf(im, fname.Data(), 0);
      return;
   case kPng:
      parms.png.type = atype;
      parms.png.flags = EXPORT_ALPHA;
      parms.png.compression = !GetImageCompression() ? -1 : int(GetImageCompression());
      break;
   case kJpeg:
      parms.jpeg.type = atype;
      parms.jpeg.flags = 0;
      parms.jpeg.quality = aquality;
      break;
   case kGif:
      parms.gif.type = atype;
      parms.gif.flags = EXPORT_ALPHA;
      parms.gif.dither = 0;
      parms.gif.opaque_threshold = 0;
      break;
   case kAnimGif:
   {
      parms.gif.type = atype;
      parms.gif.flags = EXPORT_ALPHA | EXPORT_APPEND;
      parms.gif.dither = 0;
      parms.gif.opaque_threshold = 0;
      parms.gif.animate_repeats = 0;

      s += 4; // skip "gif+"
      int delay = 0;

      const TString sufix = s; // we denote as sufix as everything that is after .gif+
      const UInt_t sLength = sufix.Length();

      if (sufix=="+") {
         // .gif++ implies that this is the last image of the animation
         // and that the gif will loop forever (infinite animation)
         // and that the delay of last image is 0ms (backward compatibility reasons)
         delay = 0;
         parms.gif.flags |= EXPORT_ANIMATION_REPEATS;// activate repetition
         parms.gif.animate_repeats = 0;// 0 is code for looping forever (if EXPORT_ANIMATION_REPEATS is also set)
      } else if(sufix=="") {
         // .gif+ implies that this is a subimage of the animation with zero delay
         // or the last image of an animation that will not repeat.
         // Last image delay is zero because atoi("")=0.
         delay = atoi(s);
         //Nothing else needed here
      } else if(!sufix.Contains("+")) {
         // .gif+NN implies that this is a subimage of the animation
         // with NN*10ms delay (latency) until the next one.
         // You can also use this option on the last image if you do not want the gif to replay
         delay = atoi(s);
         //Nothing else needed here
      } else if(sLength>1 && sufix.BeginsWith("+") && sufix.CountChar('+')==1) {
         // .gif++NN implies that this is the last image of the animation
         // and that it will loop NN number of times (finite animation)
         // and that the delay of last image is NN*10ms (backward compatibility reasons).
         delay = atoi(s);// atoi is smart enough to ignore the "+" sign before.
         parms.gif.flags |= EXPORT_ANIMATION_REPEATS;// activate repetition
         parms.gif.animate_repeats = atoi(s);// loops only NN times, then it stops. atoi discards + sign.
      } else if(sLength>3 && sufix.BeginsWith("+") && sufix.EndsWith("++") && !TString(sufix(1,sLength-3)).Contains("+")) {
         // .gif++NN++ implies that this is the last image of the animation
         // and that the gif will loop forever (infinite animation)
         // and that the delay of last image is NN*10ms.
         // In contrast, .gif++ is an infinite loop but with 0 delay, whereas the option
         // .gif++NN is a loop repeated NN times (not infinite) with NN*10ms delay
         // between last and first loop images.
         delay = atoi(s);// atoi discards the three plus signs
         parms.gif.flags |= EXPORT_ANIMATION_REPEATS;// activate repetition
         parms.gif.animate_repeats = 0;// 0 is code for looping forever (if EXPORT_ANIMATION_REPEATS is also set)
      } else if(sLength>3 && sufix.CountChar('+')==2 && TString(sufix(1,sLength-2)).Contains("++")) {
         // .gif+NN++RR implies that this is the last image animation
         // and that the gif will loop RR number of times (finite animation)
         // and that the delay of last image is NN*10ms.
         const TString sDelay = sufix(0,sufix.First('+'));
         const TString sRepeats = sufix(sufix.First('+')+2,sLength-(sufix.First('+')+2));
         delay = atoi(sDelay);
         parms.gif.flags |= EXPORT_ANIMATION_REPEATS;// activate repetition
         parms.gif.animate_repeats = atoi(sRepeats);// loops NN times.
      } else {
         Error("WriteImage", "gif sufix %s not yet supported", s);
         return;
      }

      parms.gif.animate_delay = delay;

      int i1 = fname.Index("gif+");
      if (i1 != kNPOS) {
         fname = fname(0, i1 + 3);
      }
      else {
         Error("WriteImage", "unexpected gif extension structure %s", fname.Data());
         return;
      }
      break;
   }
   case kTiff:
      parms.tiff.type = atype;
      parms.tiff.flags = EXPORT_ALPHA;
      parms.tiff.rows_per_strip = 0;
      parms.tiff.compression_type = aquality <= 50 ? TIFF_COMPRESSION_JPEG :
                                                     TIFF_COMPRESSION_NONE;
      parms.tiff.jpeg_quality = 100;
      parms.tiff.opaque_threshold = 0;
      break;
   default:
      Error("WriteImage", "file type %s not yet supported", s);
      return;
   }

   if (!ASImage2file(im, 0, fname.Data(), atype, &parms)) {
      Error("WriteImage", "error writing file %s", file);
   }
}


//______________________________________________________________________________
TImage::EImageFileTypes TASImage::GetFileType(const char *ext)
{
   // Return file type depending on specified extension.
   // Protected method.

   TString s(ext);
   s.Strip();
   s.ToLower();

   if (s == "xpm")
      return kXpm;
   if (s == "png")
      return kPng;
   if (s == "jpg" || s == "jpeg")
      return kJpeg;
   if (s == "xcf")
      return kXcf;
   if (s == "ppm")
      return kPpm;
   if (s == "pnm")
      return kPnm;
   if (s == "bmp")
      return kBmp;
   if (s == "ico")
      return kIco;
   if (s == "cur")
      return kCur;
   if (s == "gif")
      return kGif;
   if (s.Contains("gif+"))
      return kAnimGif;
   if (s == "tiff")
      return kTiff;
   if (s == "xbm")
      return kXbm;
   if (s == "tga")
      return kTga;
   if (s == "xml")
      return kXml;

   return kUnknown;
}


//______________________________________________________________________________
void TASImage::MapFileTypes(EImageFileTypes &type, UInt_t &astype, Bool_t toas)
{
   // Map file type to/from AfterImage types.
   // Protected method.

   if (toas) {
      switch (type) {
         case kXpm:
            astype = ASIT_Xpm; break;
         case kZCompressedXpm:
            astype = ASIT_ZCompressedXpm; break;
         case kGZCompressedXpm:
            astype = ASIT_GZCompressedXpm; break;
         case kPng:
            astype = ASIT_Png; break;
         case kJpeg:
            astype = ASIT_Jpeg; break;
         case kXcf:
            astype = ASIT_Xcf; break;
         case kPpm:
            astype = ASIT_Ppm; break;
         case kPnm:
            astype = ASIT_Pnm; break;
         case kBmp:
            astype = ASIT_Bmp; break;
         case kIco:
            astype = ASIT_Ico; break;
         case kCur:
            astype = ASIT_Cur; break;
         case kGif:
            astype = ASIT_Gif; break;
         case kAnimGif:
            astype = ASIT_Gif; break;
         case kTiff:
            astype = ASIT_Tiff; break;
         case kXbm:
            astype = ASIT_Xbm; break;
         case kTga:
            astype = ASIT_Targa; break;
         case kXml:
            astype = ASIT_XMLScript; break;
         default:
            astype = ASIT_Unknown;
      }
   } else {
      switch (astype) {
         case ASIT_Xpm:
            type = kXpm; break;
         case ASIT_ZCompressedXpm:
            type = kZCompressedXpm; break;
         case ASIT_GZCompressedXpm:
            type = kGZCompressedXpm; break;
         case ASIT_Png:
            type = kPng; break;
         case ASIT_Jpeg:
            type = kJpeg; break;
         case ASIT_Xcf:
            type = kXcf; break;
         case ASIT_Ppm:
            type = kPpm; break;
         case ASIT_Pnm:
            type = kPnm; break;
         case ASIT_Bmp:
            type = kBmp; break;
         case ASIT_Ico:
            type = kIco; break;
         case ASIT_Cur:
            type = kCur; break;
         case ASIT_Gif:
            type = kGif; break;
         case ASIT_Tiff:
            type = kTiff; break;
         case ASIT_Xbm:
            type = kXbm; break;
         case ASIT_XMLScript:
            type = kXml; break;
         case ASIT_Targa:
            type = kTga; break;
         default:
            type = kUnknown;
      }
   }
}


//______________________________________________________________________________
void TASImage::MapQuality(EImageQuality &quality, UInt_t &asquality, Bool_t toas)
{
   // Map quality to/from AfterImage quality.
   // Protected method.

   if (toas) {
      switch (quality) {
         case kImgPoor:
            asquality = 25; break;
         case kImgFast:
            asquality = 75; break;
         case kImgGood:
            asquality = 50; break;
         case kImgBest:
            asquality = 100; break;
         default:
            asquality = 0;
      }
   } else {
      quality = kImgDefault;
      if (asquality > 0  && asquality <= 25)
         quality = kImgPoor;
      if (asquality > 26 && asquality <= 50)
         quality = kImgFast;
      if (asquality > 51 && asquality <= 75)
         quality = kImgGood;
      if (asquality > 76 && asquality <= 100)
         quality = kImgBest;
   }
}


//______________________________________________________________________________
void TASImage::SetImage(const Double_t *imageData, UInt_t width, UInt_t height,
                        TImagePalette *palette)
{
   // Deletes the old image and creates a new image depending on the values
   // of imageData. The size of the image is width X height.
   // The color of each pixel depends on the imageData of the corresponding
   // pixel. The palette is used to convert an image value into its color.
   // If palette is not defined (palette = 0) a default palette is used.
   // Any previously defined zooming is reset.

   TAttImage::SetPalette(palette);

   if (!InitVisual()) {
      Warning("SetImage", "Visual not initiated");
      return;
   }

   DestroyImage();
   delete fScaledImage;
   fScaledImage = 0;

   // get min and max value of image
   fMinValue = fMaxValue = *imageData;
   for (Int_t pixel = 1; pixel < Int_t(width * height); pixel++) {
      if (fMinValue > *(imageData + pixel)) fMinValue = *(imageData + pixel);
      if (fMaxValue < *(imageData + pixel)) fMaxValue = *(imageData + pixel);
   }

   // copy ROOT palette to asImage palette
   const TImagePalette &pal = GetPalette();

   ASVectorPalette asPalette;

   asPalette.npoints = pal.fNumPoints;
   Int_t col;
   for (col = 0; col < 4; col++)
      asPalette.channels[col] = new UShort_t[asPalette.npoints];

   memcpy(asPalette.channels[0], pal.fColorBlue,  pal.fNumPoints * sizeof(UShort_t));
   memcpy(asPalette.channels[1], pal.fColorGreen, pal.fNumPoints * sizeof(UShort_t));
   memcpy(asPalette.channels[2], pal.fColorRed,   pal.fNumPoints * sizeof(UShort_t));
   memcpy(asPalette.channels[3], pal.fColorAlpha, pal.fNumPoints * sizeof(UShort_t));

   asPalette.points = new Double_t[asPalette.npoints];
   for (Int_t point = 0; point < Int_t(asPalette.npoints); point++)
      asPalette.points[point] = fMinValue + (fMaxValue - fMinValue) * pal.fPoints[point];

   fImage = create_asimage_from_vector(fgVisual, (Double_t*)imageData, width,
                                       height, &asPalette, ASA_ASImage,
                                       GetImageCompression(), GetImageQuality());

   delete [] asPalette.points;
   for (col = 0; col < 4; col++)
      delete [] asPalette.channels[col];

   fZoomUpdate = 0;
   fZoomOffX   = 0;
   fZoomOffY   = 0;
   fZoomWidth  = width;
   fZoomHeight = height;
   fPaletteEnabled = kTRUE;
}


//______________________________________________________________________________
void TASImage::SetImage(const TArrayD &imageData, UInt_t width, TImagePalette *palette)
{
   // Delete the old image and creates a new image depending on the values
   // of imageData. The size of the image is width X (imageData.fN / width).
   // The color of each pixel depends on the imageData of the corresponding
   // pixel. The palette is used to convert an image value into its color.
   // If palette is not defined (palette = 0) a default palette is used.
   // Any previously defined zooming is reset.

   SetImage(imageData.GetArray(), width, imageData.GetSize() / width, palette);
}


//______________________________________________________________________________
void TASImage::SetImage(const TVectorD &imageData, UInt_t width, TImagePalette *palette)
{
   // Delete the old image and creates a new image depending on the values
   // of imageData. The size of the image is width X (imageData.fN / width).
   // The color of each pixel depends on the imageData of the corresponding
   // pixel. The palette is used to convert an image value into its color.
   // If palette is not defined (palette = 0) a default palette is used.
   // Any previously defined zooming is reset.

   SetImage(imageData.GetMatrixArray(), width,
            imageData.GetNoElements() / width, palette);
}


//______________________________________________________________________________
void TASImage::FromPad(TVirtualPad *pad, Int_t x, Int_t y, UInt_t w, UInt_t h)
{
   // Create an image from the given pad, afterwards this image can be
   // saved in any of the supported image formats.

   if (!pad) {
      Error("FromPad", "pad cannot be 0");
      return;
   }

   if (!InitVisual()) {
      Warning("FromPad", "Visual not initiated");
      return;
   }

   SetName(pad->GetName());

   DestroyImage();
   delete fScaledImage;
   fScaledImage = 0;

   if (gROOT->IsBatch()) { // in batch mode
      TVirtualPS *psave = gVirtualPS;
      gVirtualPS = (TVirtualPS*)gROOT->ProcessLineFast("new TImageDump()");
      gVirtualPS->Open(pad->GetName(), 114); // in memory
      gVirtualPS->SetBit(BIT(11)); //kPrintingPS

      TASImage *itmp = (TASImage*)gVirtualPS->GetStream();

      if (itmp && itmp->fImage) {
         itmp->BeginPaint();
      }

      TVirtualPad *sav = gPad;
      gPad = pad;
      pad->Paint();
      gPad = sav;

      if (itmp && itmp->fImage && (itmp != this)) {
         fImage = clone_asimage(itmp->fImage, SCL_DO_ALL);
         if (itmp->fImage->alt.argb32) {
            UInt_t sz = itmp->fImage->width*itmp->fImage->height;
            fImage->alt.argb32 = (ARGB32*)safemalloc(sz*sizeof(ARGB32));
            memcpy(fImage->alt.argb32, itmp->fImage->alt.argb32, sz*4);
         }
      }
      delete gVirtualPS;
      gVirtualPS = psave;
      return;
   }

   if (w == 0) {
      w = TMath::Abs(pad->UtoPixel(1.));
   }

   if (h == 0) {
      h = pad->VtoPixel(0.);
   }
   // syncronization
   gVirtualX->Update(1);
   if (!gThreadXAR) {
      gSystem->ProcessEvents();
      gSystem->Sleep(10);
      gSystem->ProcessEvents();
   }

   TVirtualPad *canvas = (TVirtualPad*)pad->GetCanvas();
   Int_t wid = (pad == canvas) ? pad->GetCanvasID() : pad->GetPixmapID();
   gVirtualX->SelectWindow(wid);

   Window_t wd = (Window_t)gVirtualX->GetCurrentWindow();
   if (!wd) return;

   static int x11 = -1;
   if (x11 < 0) x11 = gVirtualX->InheritsFrom("TGX11");

   if (x11) { //use built-in optimized version
      fImage = pixmap2asimage(fgVisual, wd, x, y, w, h, kAllPlanes, 0, 0);
   } else {
      unsigned char *bits = gVirtualX->GetColorBits(wd, 0, 0, w, h);

      if (!bits) { // error
         return;
      }
      fImage = bitmap2asimage(bits, w, h, 0, 0);
      delete [] bits;
   }
}


//______________________________________________________________________________
void TASImage::Draw(Option_t *option)
{
   // Draw image.
   // Support the following drawing options:
   // "T[x,y[,tint]]" - tile image (use specified offset and tint),
   //                   e.g. "T100,100,#556655"
   //                   with this option the zooming is not possible
   //                   and disabled
   // "N"             - display in new canvas (of original image size)
   // "X"             - image is drawn expanded to pad size
   // "Z"             - image is vectorized and image palette is drawn
   //
   // The default is to display the image in the current gPad.

   if (!fImage) {
      Error("Draw", "no image set");
      return;
   }

   TString opt = option;
   opt.ToLower();
   if (opt.Contains("n") || !gPad || !gPad->IsEditable()) {
      Int_t w = -64;
      Int_t h = 64;
      w = (fImage->width > 64) ? (Int_t)fImage->width : w;
      h = (fImage->height > 64) ? (Int_t)fImage->height : h;

      Float_t cx = 1./gStyle->GetScreenFactor();
      w = Int_t(w*cx) + 4;
      h = Int_t(h*cx) + 28;
      TString rname = GetName();
      rname.ReplaceAll(".", "");
      rname += Form("\", \"%s (%d x %d)", rname.Data(), fImage->width, fImage->height);
      rname = "new TCanvas(\"" + rname + Form("\", %d, %d);", w, h);
      gROOT->ProcessLineFast(rname.Data());
   }

   if (!opt.Contains("x")) {
      Double_t left = gPad->GetLeftMargin();
      Double_t right = gPad->GetRightMargin();
      Double_t top = gPad->GetTopMargin();
      Double_t bottom = gPad->GetBottomMargin();

      gPad->Range(-left / (1.0 - left - right),
                  -bottom / (1.0 - top - bottom),
                  1 + right / (1.0 - left - right),
                  1 + top / ( 1.0 - top - bottom));
      gPad->RangeAxis(0, 0, 1, 1);
   }

   TFrame *frame = gPad->GetFrame();
   if (frame) {
      frame->SetBorderMode(0);
      frame->SetFillColor(gPad->GetFillColor());
      frame->SetLineColor(gPad->GetFillColor());
      frame->Draw();
   }

   TObject::Draw(option);
}


//______________________________________________________________________________
void TASImage::Image2Drawable(ASImage *im, Drawable_t wid, Int_t x, Int_t y,
                              Int_t xsrc, Int_t ysrc, UInt_t wsrc, UInt_t hsrc,
                              Option_t *opt)
{
   // Draw asimage on drawable.

   if (!im) return;

   wsrc = wsrc ? wsrc : im->width;
   hsrc = hsrc ? hsrc : im->height;

   static int x11 = -1;
   if (x11 < 0) x11 = gVirtualX->InheritsFrom("TGX11");

   Pixmap_t mask = kNone;

   if (x11) {
      UInt_t hh = hsrc;
      UInt_t ow = wsrc%8;
      UInt_t ww = wsrc - ow + (ow ? 8 : 0);

      UInt_t bit = 0;
      int i = 0;
      UInt_t yy = 0;
      UInt_t xx = 0;

      char *bits = new char[ww*hh]; //an array of bits

      ASImageDecoder *imdec = start_image_decoding(fgVisual, im, SCL_DO_ALPHA,
                                                   xsrc, ysrc, ww, 0, 0);
      if (imdec) {
         for (yy = 0; yy < hh; yy++) {
            imdec->decode_image_scanline(imdec);
            CARD32 *a = imdec->buffer.alpha;

            for (xx = 0; xx < ww; xx++) {
               if (a[xx]) {
                  SETBIT(bits[i], bit);
               } else {
                  CLRBIT(bits[i], bit);
               }
               bit++;
               if (bit == 8) {
                  bit = 0;
                  i++;
               }
            }
         }
      }

      stop_image_decoding(&imdec);

      mask = gVirtualX->CreateBitmap(gVirtualX->GetDefaultRootWindow(),
                                          (const char *)bits, ww, hh);
      delete [] bits;
   }

   GCValues_t gv;
   static GContext_t gc = 0;

   gv.fMask = kGCClipMask | kGCClipXOrigin | kGCClipYOrigin;
   gv.fClipMask = mask;
   gv.fClipXOrigin = x;
   gv.fClipYOrigin = y;

   if (!gc) {
      gc = gVirtualX->CreateGC(gVirtualX->GetDefaultRootWindow(), &gv);
   } else {
      gVirtualX->ChangeGC(gc, &gv);
   }

   if (x11 && (!gPad || gPad->GetGLDevice() == -1)) { //use built-in optimized version
      asimage2drawable(fgVisual, wid, im, (GC)gc, xsrc, ysrc, x, y, wsrc, hsrc, 1);
   } else {
      ASImage *img = 0;
      unsigned char *bits = (unsigned char *)im->alt.argb32;
      if (!bits) {
         img = tile_asimage(fgVisual, im, xsrc, ysrc, wsrc, hsrc,
                            0, ASA_ARGB32, 0, ASIMAGE_QUALITY_DEFAULT);
         if (img)
            bits = (unsigned char *)img->alt.argb32;
      }

      if (bits) {
         TString option(opt);
         option.ToLower();

         if (gPad && gPad->GetGLDevice() != -1) {
            if (TVirtualPadPainter *painter = gPad->GetPainter())
               painter->DrawPixels(bits, wsrc, hsrc, x, y, !option.Contains("opaque"));
         } else {
            Pixmap_t pic = gVirtualX->CreatePixmapFromData(bits, wsrc, hsrc);
            if (pic) {
               if (!option.Contains("opaque")) {
                  SETBIT(wsrc,31);
                  SETBIT(hsrc,31);
               }
               gVirtualX->CopyArea(pic, wid, gc, 0, 0, wsrc, hsrc, x, y);
               gVirtualX->DeletePixmap(pic);
            }
         }
      }

      if (img) {
         destroy_asimage(&img);
      }
   }

   // free mask pixmap
   if (gv.fClipMask != kNone) gVirtualX->DeletePixmap(gv.fClipMask);

   gv.fMask = kGCClipMask;
   gv.fClipMask = kNone;
   if (gc) gVirtualX->ChangeGC(gc, &gv);
}


//______________________________________________________________________________
void TASImage::PaintImage(Drawable_t wid, Int_t x, Int_t y, Int_t xsrc, Int_t ysrc,
                          UInt_t wsrc, UInt_t hsrc, Option_t *opt)
{
   // Draw image on the drawable wid (pixmap, window) at x,y position.
   //
   // wid        : Drawable (pixmap or window) on which image is drawn.
   // x,y        : Window coordinates where image is drawn.
   // xsrc, ysrc : X and Y coordinates of an image area to be drawn.
   // wsrc, hsrc : Widh and height image area to be drawn.

   Image2Drawable(fScaledImage ? fScaledImage->fImage : fImage, wid, x, y,
                  xsrc, ysrc, wsrc, hsrc, opt);
}


//______________________________________________________________________________
void TASImage::Paint(Option_t *option)
{
   // Paint image.
   // Support the following drawing options:
   // "T[x,y[,tint]]" - tile image (use specified offset and tint),
   //                   e.g. "T100,100,#556655"
   //                   with this option the zooming is not possible
   //                   and disabled
   // "N"             - display in new canvas (of original image size)
   // "X"             - image is drawn expanded to pad size
   // "Z"             - image is vectorized and image palette is drawn
   //
   // The default is to display the image in the current gPad.

   if (!fImage) {
      Error("Paint", "no image set");
      return;
   }

   if (!InitVisual()) {
      Warning("Paint", "Visual not initiated");
      return;
   }

   Int_t   tile_x = 0, tile_y = 0;
   CARD32  tile_tint = 0;
   Bool_t  tile = kFALSE;
   Bool_t  expand = kFALSE;

   TString opt = option;
   opt.ToLower();

   if (opt.Contains("t")) {
      char stint[64];
      if (sscanf(opt.Data() + opt.Index("t"), "t%d,%d,%s", &tile_x, &tile_y,
                 stint) <= 3) {
         tile = kTRUE;
         if (parse_argb_color(stint, (CARD32*)&tile_tint) == stint)
            tile_tint = 0;
      } else {
         Error("Paint", "tile option error");
      }
   } else if (opt.Contains("x")) {
      expand = kTRUE;
      fConstRatio = kFALSE;
   } else if (opt.Contains("z")) {
      fPaletteEnabled = kTRUE;

      if (!fImage->alt.vector) {
         Vectorize(256);
      }
   }

   ASImage *image = fImage;

   // Get geometry of pad
   Int_t to_w = gPad->UtoPixel(1.);
   Int_t to_h = gPad->VtoPixel(0.);

   // remove the size by the margin of the pad
   if (!expand) {
      to_h  = (Int_t)(to_h * (1.0 - gPad->GetBottomMargin() - gPad->GetTopMargin() ) + 0.5);
      to_w  = (Int_t)(to_w * (1.0 - gPad->GetLeftMargin() - gPad->GetRightMargin() ) + 0.5);
   }

   if ((to_w < 25 || to_h < 25) && !expand) {
      Error("Paint", "pad too small to display an image");
      return;
   }

   if (GetConstRatio()) {
      if ((Double_t)to_w / (Double_t)fZoomWidth <
          (Double_t)to_h / (Double_t)fZoomHeight)
         to_h = Int_t(Double_t(fZoomHeight) * to_w / fZoomWidth);
      else
         to_w = Int_t(Double_t(fZoomWidth) * to_h / fZoomHeight);
   }
   // upper left corner and size of the palette in pixels
   Int_t pal_Ax = to_w + gPad->UtoAbsPixel(gPad->GetLeftMargin()) +
                 (gPad->UtoAbsPixel(gPad->GetRightMargin()) / 10);
   Int_t pal_Ay = gPad->YtoAbsPixel(1.0);
   Int_t pal_x = to_w + gPad->UtoPixel(gPad->GetLeftMargin()) +
                 (gPad->UtoPixel(gPad->GetRightMargin()) / 10);
   Int_t pal_y = gPad->YtoPixel(1.0);
   Int_t pal_w = gPad->UtoPixel(gPad->GetRightMargin()) / 3;
   Int_t pal_h = to_h;

   ASImage  *grad_im = 0;

   if (fImage->alt.vector && fPaletteEnabled) {
      // draw the palette
      ASGradient grad;
      const TImagePalette &pal = GetPalette();

      grad.npoints = pal.fNumPoints;
      grad.type    = GRADIENT_Top2Bottom;
      grad.color   = new ARGB32[grad.npoints];
      grad.offset  = new double[grad.npoints];

      for (Int_t pt = 0; pt < grad.npoints; pt++) {
         Int_t oldPt = grad.npoints - pt -1;
         grad.offset[pt] = 1 - pal.fPoints[oldPt];
         grad.color[pt] = (((ARGB32)(pal.fColorBlue[oldPt]  & 0xff00)) >>  8) |
                          (((ARGB32)(pal.fColorGreen[oldPt] & 0xff00))      ) |
                          (((ARGB32)(pal.fColorRed[oldPt]   & 0xff00)) <<  8) |
                          (((ARGB32)(pal.fColorAlpha[oldPt] & 0xff00)) << 16);
      }

      grad_im = make_gradient(fgVisual, &grad , UInt_t(pal_w),
                              pal_h, SCL_DO_COLOR,
                              ASA_ARGB32, GetImageCompression(), GetImageQuality());

      delete [] grad.color;
      delete [] grad.offset;
   }

   if (tile) {
      delete fScaledImage;
      fScaledImage = (TASImage*)TImage::Create();
      if (!fScaledImage) return;
      fScaledImage->fImage = tile_asimage(fgVisual, fImage, tile_x, tile_y,
                                          to_w, to_h, tile_tint, ASA_ASImage,
                                          GetImageCompression(), GetImageQuality());
      image = fScaledImage->fImage;

   } else if (fZoomUpdate == kZoomOps) {
      image = fImage;

   } else {
      // Scale and zoom image if needed
      if (Int_t(fImage->width) != to_w || Int_t(fImage->height) != to_h ||
          fImage->width != fZoomWidth || fImage->height != fZoomHeight) {

         if (fScaledImage && (Int_t(fScaledImage->GetWidth()) != to_w ||
                Int_t(fScaledImage->GetHeight()) != to_h ||
                fZoomUpdate)) {

            delete fScaledImage;
            fScaledImage = 0;
         }

         if (!fScaledImage) {
            fScaledImage = (TASImage*)TImage::Create();
            if (!fScaledImage) return;

            if (fZoomWidth && fZoomHeight &&
                ((fImage->width != fZoomWidth) || (fImage->height != fZoomHeight))) {
               // zoom and scale image
               ASImage *tmpImage = 0;

               tmpImage = tile_asimage(fgVisual, fImage, fZoomOffX,
                                          fImage->height - fZoomHeight - fZoomOffY,
                                          fZoomWidth, fZoomHeight, 0, ASA_ASImage,
                                          GetImageCompression(), GetImageQuality());

               if (tmpImage) {
                  fScaledImage->fImage = scale_asimage(fgVisual, tmpImage, to_w, to_h,
                                                       ASA_ASImage, GetImageCompression(),
                                                      GetImageQuality());
                  destroy_asimage(&tmpImage);
               }
            } else {
               // scale image, no zooming
               fScaledImage->fImage = scale_asimage(fgVisual, fImage, to_w, to_h,
                                                    ASA_ASImage, GetImageCompression(),
                                                    GetImageQuality());
            }
         }
         image = fScaledImage->fImage;
      }
   }
   fZoomUpdate = 0;

   if (!image) {
      Error("Paint", "image could not be rendered to display");
      return;
   }

   int tox = expand  ? 0 : int(gPad->UtoPixel(1.) * gPad->GetLeftMargin());
   int toy = expand  ? 0 : int(gPad->VtoPixel(0.) * gPad->GetTopMargin());

   if (!gROOT->IsBatch()) {
      Window_t wid = (Window_t)gVirtualX->GetWindowID(gPad->GetPixmapID());
      Image2Drawable(fScaledImage ? fScaledImage->fImage : fImage, wid, tox, toy);

      if (grad_im && fPaletteEnabled) {
         // draw color bar
         Image2Drawable(grad_im, wid, pal_x, pal_y);

         // values of palette
         TGaxis axis;
         Int_t ndiv = 510;
         double min = fMinValue;
         double max = fMaxValue;
         axis.SetLineColor(0);       // draw white ticks
         Double_t pal_Xpos = gPad->AbsPixeltoX(pal_Ax + pal_w);
         axis.PaintAxis(pal_Xpos, gPad->PixeltoY(pal_Ay + pal_h - 1),
                        pal_Xpos, gPad->PixeltoY(pal_Ay),
                        min, max, ndiv, "+LU");
         min = fMinValue;
         max = fMaxValue;
         axis.SetLineColor(1);       // draw black ticks
         axis.PaintAxis(pal_Xpos, gPad->AbsPixeltoY(pal_Ay + pal_h),
                        pal_Xpos, gPad->AbsPixeltoY(pal_Ay + 1),
                        min, max, ndiv, "+L");
      }
   }

   // loop over pxmap and draw image to PostScript
   if (gVirtualPS) {
      if (gVirtualPS->InheritsFrom("TImageDump")) { // PostScript is asimage
         TImage *dump = (TImage *)gVirtualPS->GetStream();
         if (!dump) return;
         dump->Merge(fScaledImage ? fScaledImage : this, "alphablend",
                     gPad->XtoAbsPixel(0), gPad->YtoAbsPixel(1));

         if (grad_im) {
            TASImage tgrad;
            tgrad.fImage = grad_im;
            dump->Merge(&tgrad, "alphablend", pal_Ax, pal_Ay);

            // values of palette
            TGaxis axis;
            Int_t ndiv = 510;
            double min = fMinValue;
            double max = fMaxValue;
            axis.SetLineColor(1);       // draw black ticks
            Double_t pal_Xpos = gPad->AbsPixeltoX(pal_Ax + pal_w);
            axis.PaintAxis(pal_Xpos, gPad->AbsPixeltoY(pal_Ay + pal_h),
                           pal_Xpos, gPad->AbsPixeltoY(pal_Ay + 1),
                           min, max, ndiv, "+L");
         }
         return;
      } else if (gVirtualPS->InheritsFrom("TPDF")) {
         Warning("Paint", "PDF not implemeted yet");
         return;
      } else if (gVirtualPS->InheritsFrom("TSVG")) {
         Warning("Paint", "SVG not implemeted yet");
         return;
      }

      // get special color cell to be reused during image printing
      TObjArray *colors = (TObjArray*) gROOT->GetListOfColors();
      TColor *color = 0;
      // Look for color by name
      if ((color = (TColor*)colors->FindObject("Image_PS")) == 0)
         color = new TColor(colors->GetEntries(), 1., 1., 1., "Image_PS");

      gVirtualPS->SetFillColor(color->GetNumber());
      gVirtualPS->SetFillStyle(1001);

      Double_t dx = gPad->GetX2()-gPad->GetX1();
      Double_t dy = gPad->GetY2()-gPad->GetY1();
      Double_t x1,x2,y1,y2;

      if (expand) {
         x1 = gPad->GetX1();
         x2 = x1+dx/image->width;
         y1 = gPad->GetY2();
         y2 = y1+dy/image->height;
      } else {
         x1 = gPad->GetX1()+dx*gPad->GetLeftMargin();
         x2 = x1+(dx*(1-gPad->GetRightMargin()-gPad->GetLeftMargin()))/image->width;
         y1 = gPad->GetY2()-dy*gPad->GetTopMargin();
         y2 = y1+(dy*(1-gPad->GetTopMargin()-gPad->GetBottomMargin()))/image->height;
      }

      gVirtualPS->CellArrayBegin(image->width, image->height, x1, x2, y1, y2);

      ASImageDecoder *imdec = start_image_decoding(fgVisual, image, SCL_DO_ALL,
                                                   0, 0, image->width, image->height, 0);
      if (!imdec) return;
      for (Int_t yt = 0; yt < (Int_t)image->height; yt++) {
         imdec->decode_image_scanline(imdec);
         for (Int_t xt = 0; xt < (Int_t)image->width; xt++)
            gVirtualPS->CellArrayFill(imdec->buffer.red[xt],
                                      imdec->buffer.green[xt],
                                      imdec->buffer.blue[xt]);
      }
      stop_image_decoding(&imdec);
      gVirtualPS->CellArrayEnd();

      // print the color bar
      if (grad_im) {
         Double_t xconv = (gPad->AbsPixeltoX(pal_Ax + pal_w) - gPad->AbsPixeltoX(pal_Ax)) / grad_im->width;
         Double_t yconv = (gPad->AbsPixeltoY(pal_Ay - pal_h) - gPad->AbsPixeltoY(pal_Ay)) / grad_im->height;
         x1 = gPad->AbsPixeltoX(pal_Ax);
         x2 = x1 + xconv;
         y2 = gPad->AbsPixeltoY(pal_Ay);
         y1 = y2 - yconv;
         gVirtualPS->CellArrayBegin(grad_im->width, grad_im->height,
                                    x1, x2, y1, y2);

         imdec = start_image_decoding(fgVisual, grad_im, SCL_DO_ALL,
                                      0, 0, grad_im->width, grad_im->height, 0);
         if (imdec) {
            for (Int_t yt = 0; yt < (Int_t)grad_im->height; yt++) {
               imdec->decode_image_scanline(imdec);
               for (Int_t xt = 0; xt < (Int_t)grad_im->width; xt++)
                  gVirtualPS->CellArrayFill(imdec->buffer.red[xt],
                                            imdec->buffer.green[xt],
                                            imdec->buffer.blue[xt]);
            }
         }
         stop_image_decoding(&imdec);
         gVirtualPS->CellArrayEnd();

         // values of palette
         TGaxis axis;
         Int_t ndiv = 510;
         double min = fMinValue;
         double max = fMaxValue;
         axis.SetLineColor(1);       // draw black ticks
         Double_t pal_Xpos = gPad->AbsPixeltoX(pal_Ax + pal_w);
         axis.PaintAxis(pal_Xpos, gPad->AbsPixeltoY(pal_Ay + pal_h),
                        pal_Xpos, gPad->AbsPixeltoY(pal_Ay + 1),
                        min, max, ndiv, "+L");

      }
   }

   if (grad_im) {
      destroy_asimage(&grad_im);
   }
}


//______________________________________________________________________________
Int_t TASImage::DistancetoPrimitive(Int_t px, Int_t py)
{
   // Is the mouse in the image ?

   Int_t pxl, pyl, pxt, pyt;

   Int_t px1 = gPad->XtoAbsPixel(0);
   Int_t py1 = gPad->YtoAbsPixel(0);
   Int_t px2 = gPad->XtoAbsPixel(1);
   Int_t py2 = gPad->YtoAbsPixel(1);

   if (px1 < px2) {pxl = px1; pxt = px2;}
   else           {pxl = px2; pxt = px1;}
   if (py1 < py2) {pyl = py1; pyt = py2;}
   else           {pyl = py2; pyt = py1;}

   if ((px > pxl && px < pxt) && (py > pyl && py < pyt))
      return 0;

   return 999999;
}


//______________________________________________________________________________
void TASImage::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
   // Execute mouse events.
   static TBox *ZoomBox;

   if (!gPad) return;

   if (IsEditable()) {
      gPad->ExecuteEvent(event, px, py);
      return;
   }

   gPad->SetCursor(kCross);

   static Int_t px1old, py1old, px2old, py2old;
   static Int_t px1, py1, px2, py2, pxl, pyl, pxt, pyt;

   if (!IsValid()) return;

   if (event == kButton1Motion || event == kButton1Down  ||
       event == kButton1Up) {

      // convert to image pixel on screen
      Int_t imgX = px - gPad->XtoAbsPixel(0);
      Int_t imgY = py - gPad->YtoAbsPixel(1);

      if (imgX < 0)  px = px - imgX;
      if (imgY < 0)  py = py - imgY;

      ASImage *image = fImage;
      if (fScaledImage) image = fScaledImage->fImage;

      if (imgX >= (int)image->width)  px = px - imgX + image->width - 1;
      if (imgY >= (int)image->height) py = py - imgY + image->height - 1;

      switch (event) {

         case kButton1Down:
            px1 = gPad->XtoAbsPixel(gPad->GetX1());
            py1 = gPad->YtoAbsPixel(gPad->GetY1());
            px2 = gPad->XtoAbsPixel(gPad->GetX2());
            py2 = gPad->YtoAbsPixel(gPad->GetY2());
            px1old = px; py1old = py;
            break;

         case kButton1Motion:
            px2old = px;
            px2old = TMath::Max(px2old, px1);
            px2old = TMath::Min(px2old, px2);
            py2old = py;
            py2old = TMath::Max(py2old, py2);
            py2old = TMath::Min(py2old, py1);
            pxl = TMath::Min(px1old, px2old);
            pxt = TMath::Max(px1old, px2old);
            pyl = TMath::Max(py1old, py2old);
            pyt = TMath::Min(py1old, py2old);

            if (ZoomBox) {
               ZoomBox->SetX1(gPad->AbsPixeltoX(pxl));
               ZoomBox->SetY1(gPad->AbsPixeltoY(pyl));
               ZoomBox->SetX2(gPad->AbsPixeltoX(pxt));
               ZoomBox->SetY2(gPad->AbsPixeltoY(pyt));
            }
            else {
               ZoomBox = new TBox(pxl, pyl, pxt, pyt);
               ZoomBox->SetFillStyle(0);
               ZoomBox->Draw("l*");
            }
            gPad->Modified(kTRUE);
            gPad->Update();
            break;

         case kButton1Up:
            // do nothing if zoom area is too small
            if ( TMath::Abs(pxl - pxt) < 5 || TMath::Abs(pyl - pyt) < 5)
               return;

            Double_t xfact = (fScaledImage) ? (Double_t)fScaledImage->fImage->width  / fZoomWidth  : 1;
            Double_t yfact = (fScaledImage) ? (Double_t)fScaledImage->fImage->height / fZoomHeight : 1;

            Int_t imgX1 = px1old - gPad->XtoAbsPixel(0);
            Int_t imgY1 = py1old - gPad->YtoAbsPixel(1);
            Int_t imgX2 = px  - gPad->XtoAbsPixel(0);
            Int_t imgY2 = py  - gPad->YtoAbsPixel(1);

            imgY1 = image->height - 1 - imgY1;
            imgY2 = image->height - 1 - imgY2;
            imgX1 = (Int_t)(imgX1 / xfact) + fZoomOffX;
            imgY1 = (Int_t)(imgY1 / yfact) + fZoomOffY;
            imgX2 = (Int_t)(imgX2 / xfact) + fZoomOffX;
            imgY2 = (Int_t)(imgY2 / yfact) + fZoomOffY;

            Zoom((imgX1 < imgX2) ? imgX1 : imgX2, (imgY1 < imgY2) ? imgY1 : imgY2,
                 TMath::Abs(imgX1 - imgX2) + 1, TMath::Abs(imgY1 - imgY2) + 1);

            if (ZoomBox) {
               ZoomBox->Delete();
               ZoomBox = 0;
            }
            gPad->Modified(kTRUE);
            gPad->Update();
            break;
      }
   }
}


//______________________________________________________________________________
char *TASImage::GetObjectInfo(Int_t px, Int_t py) const
{
   // Get image pixel coordinates and the pixel value at the mouse pointer.

   static char info[64];
   info[0] = 0;

   if (!IsValid()) return info;

   // convert to image pixel on screen
   px -= gPad->XtoAbsPixel(0);
   py -= gPad->YtoAbsPixel(1);

   // no info if mouse is outside of image
   if (px < 0 || py < 0)  return info;

   ASImage *image = fImage;
   if (fScaledImage) image = fScaledImage->fImage;
   if (px >= (int)image->width || py >= (int)image->height)
      return info;

   py = image->height - 1 - py;
   // convert to original image size and take zooming into account
   if (fScaledImage) {
      px = (Int_t)(px / (Double_t)fScaledImage->fImage->width  * fZoomWidth ) + fZoomOffX;
      py = (Int_t)(py / (Double_t)fScaledImage->fImage->height * fZoomHeight) + fZoomOffY;
   }

   if (fImage->alt.vector) {
      snprintf(info,64,"x: %d  y: %d   %.5g",
              px, py, fImage->alt.vector[px + py * fImage->width]);
   } else {
      snprintf(info,64,"x: %d  y: %d", px, py);
   }

   return info;
}


//______________________________________________________________________________
void TASImage::SetPalette(const TImagePalette *palette)
{
   // Set a new palette to an image.
   // Only images that were created with the SetImage() functions can be
   // modified with this function. The previously used palette is destroyed.

   TAttImage::SetPalette(palette);

   if (!InitVisual()) {
      Warning("SetPalette", "Visual not initiated");
      return;
   }

   if (!IsValid()) {
      Warning("SetPalette", "Image not valid");
      return;
   }

   if (fImage->alt.vector == 0)
      return;

   // copy ROOT palette to asImage palette
   const TImagePalette &pal = GetPalette();

   ASVectorPalette asPalette;
   asPalette.npoints = pal.fNumPoints;
   asPalette.channels[0] = new CARD16 [asPalette.npoints];
   asPalette.channels[1] = new CARD16 [asPalette.npoints];
   asPalette.channels[2] = new CARD16 [asPalette.npoints];
   asPalette.channels[3] = new CARD16 [asPalette.npoints];
   memcpy(asPalette.channels[0], pal.fColorBlue,  pal.fNumPoints * sizeof(UShort_t));
   memcpy(asPalette.channels[1], pal.fColorGreen, pal.fNumPoints * sizeof(UShort_t));
   memcpy(asPalette.channels[2], pal.fColorRed,   pal.fNumPoints * sizeof(UShort_t));
   memcpy(asPalette.channels[3], pal.fColorAlpha, pal.fNumPoints * sizeof(UShort_t));

   asPalette.points = new double[asPalette.npoints];
   for (Int_t point = 0; point < Int_t(asPalette.npoints); point++)
      asPalette.points[point] = fMinValue + (fMaxValue - fMinValue) * pal.fPoints[point];

   // use the new palette in this image
   colorize_asimage_vector(fgVisual, fImage, &asPalette, ASA_ASImage, GetImageQuality());

   delete [] asPalette.points;
   for (Int_t col = 0; col < 4; col++)
      delete [] asPalette.channels[col];


   delete fScaledImage;
   fScaledImage = 0;
}


//______________________________________________________________________________
void TASImage::Scale(UInt_t toWidth, UInt_t toHeight)
{
   // Scale the original image.
   // The size of the image on the screen does not change because it is defined
   // by the size of the pad.
   // This function can be used to change the size of an image before writing
   // it into a file. The colors of the new pixels are interpolated.
   // An image created with the SetImage() functions cannot be modified with
   // the function SetPalette() any more after a call of this function!

   if (!IsValid()) {
      Warning("Scale", "Image not initiated");
      return;
   }

   if (!InitVisual()) {
      Warning("Scale", "Visual not initiated");
      return;
   }

   if (toWidth < 1)
       toWidth = 1;
   if (toHeight < 1 )
      toHeight = 1;
   if (toWidth > 30000)
      toWidth = 30000;
   if (toHeight > 30000)
      toHeight = 30000;

   ASImage *img = scale_asimage(fgVisual, fImage, toWidth, toHeight,
                                ASA_ASImage, GetImageCompression(),
                                GetImageQuality());
   DestroyImage();
   fImage = img;
   UnZoom();
   fZoomUpdate = kZoomOps;
}


//______________________________________________________________________________
void TASImage::Slice(UInt_t xStart, UInt_t xEnd, UInt_t yStart,  UInt_t yEnd,
                     UInt_t toWidth, UInt_t toHeight)
{
   // Another method of enlarging images where corners remain unchanged,
   // but middle part gets tiled.

   if (!IsValid()) {
      Warning("Scale", "Image not initiated");
      return;
   }

   if (!InitVisual()) {
      Warning("Scale", "Visual not initiated");
      return;
   }

   if (toWidth < 1)
       toWidth = 1;
   if (toHeight < 1 )
      toHeight = 1;
   if (toWidth > 30000)
      toWidth = 30000;
   if (toHeight > 30000)
      toHeight = 30000;

   ASImage *img = slice_asimage(fgVisual, fImage, xStart, xEnd,
                                yStart, yEnd, toWidth, toHeight,
                                ASA_ASImage, GetImageCompression(),
                                GetImageQuality());

   DestroyImage();
   fImage = img;
   UnZoom();
   fZoomUpdate = kZoomOps;
}


//______________________________________________________________________________
void TASImage::Tile(UInt_t toWidth, UInt_t toHeight)
{
   // Tile the original image.

   if (!IsValid()) {
      Warning("Tile", "Image not initiated");
      return;
   }

   if (!InitVisual()) {
      Warning("Tile", "Visual not initiated");
      return;
   }

   if (toWidth < 1)
       toWidth = 1;
   if (toHeight < 1 )
      toHeight = 1;
   if (toWidth > 30000)
      toWidth = 30000;
   if (toHeight > 30000)
      toHeight = 30000;

   ASImage *img = tile_asimage(fgVisual, fImage, 0, 0, toWidth, toHeight, 0,
                                ASA_ASImage, GetImageCompression(), GetImageQuality());
   DestroyImage();
   fImage = img;
   UnZoom();
   fZoomUpdate = kZoomOps;
}


//______________________________________________________________________________
void TASImage::Zoom(UInt_t offX, UInt_t offY, UInt_t width, UInt_t height)
{
   // The area of an image displayed in a pad is defined by this function.
   // Note: the size on the screen is defined by the size of the pad.
   // The original image is not modified by this function.
   // If width or height is larger than the original image they are reduced to
   // the width and height of the image.
   // If the off values are too large (off + width > image width) than the off
   // values are decreased. For example: offX = image width - width
   // Note: the parameters are always relative to the original image not to the
   // size of an already zoomed image.

   if (!IsValid()) {
      Warning("Zoom", "Image not valid");
      return;
   }
   fZoomUpdate = kZoom;

   fZoomWidth  = (width == 0) ? 1 : ((width > fImage->width) ? fImage->width : width);
   fZoomHeight = (height == 0) ? 1 : ((height > fImage->height) ? fImage->height : height);
   fZoomOffX   = offX;
   if (fZoomOffX + fZoomWidth > fImage->width)
      fZoomOffX = fImage->width - fZoomWidth;
   fZoomOffY   = offY;
   if (fZoomOffY + fZoomHeight > fImage->height)
      fZoomOffY = fImage->height - fZoomHeight;
}


//______________________________________________________________________________
void TASImage::UnZoom()
{
   // Un-zoom the image to original size.
   // UnZoom() - performs undo for Zoom,Crop,Scale actions

   if (!IsValid()) {
      Warning("UnZoom", "Image not valid");
      return;
   }
   fZoomUpdate = kZoom;
   fZoomOffX   = 0;
   fZoomOffY   = 0;
   fZoomWidth  = fImage->width;
   fZoomHeight = fImage->height;

   delete fScaledImage;
   fScaledImage = 0;
}


//______________________________________________________________________________
void TASImage::Flip(Int_t flip)
{
   // Flip image in place.
   // Flip is either 90, 180, 270, 180 is default.
   // This function manipulates the original image and destroys the
   // scaled and zoomed image which will be recreated at the next call of
   // the Draw function. If the image is zoomed the zoom - coordinates are
   // now relative to the new image.
   // This function cannot be used for images which were created with the
   // SetImage() functions, because the original pixel values would be
   // destroyed.

   if (!IsValid()) {
      Warning("Flip", "Image not valid");
      return;
   }
   if (!InitVisual()) {
      Warning("Flip", "Visual not initiated");
      return;
   }

   if (fImage->alt.vector) {
      Warning("Flip", "flip does not work for data images");
      return;
   }

   Int_t rflip = flip/90;

   UInt_t w = fImage->width;
   UInt_t h = fImage->height;

   if (rflip & 1) {
      w = fImage->height;
      h = fImage->width;
   }

   ASImage *img = flip_asimage(fgVisual, fImage, 0, 0, w, h, rflip,
                               ASA_ASImage, GetImageCompression(),
                               GetImageQuality());
   DestroyImage();
   fImage = img;
   UnZoom();
}


//______________________________________________________________________________
void TASImage::Mirror(Bool_t vert)
{
   // Mirror image in place.
   // If vert is true mirror in vertical axis, horizontal otherwise.
   // Vertical is default.
   // This function manipulates the original image and destroys the
   // scaled and zoomed image which will be recreated at the next call of
   // the Draw function. If the image is zoomed the zoom - coordinates are
   // now relative to the new image.
   // This function cannot be used for images which were created with the
   // SetImage() functions, because the original pixel values would be
   // destroyed.

   if (!IsValid()) {
      Warning("Mirror", "Image not valid");
      return;
   }

   if (!InitVisual()) {
      Warning("Mirrow", "Visual not initiated");
      return;
   }

   if (fImage->alt.vector) {
      Warning("Mirror", "mirror does not work for data images");
      return;
   }

   ASImage *img = mirror_asimage(fgVisual, fImage, 0, 0,
                                 fImage->width, fImage->height, vert,
                                 ASA_ASImage, GetImageCompression(),
                                 GetImageQuality());
   DestroyImage();
   fImage = img;
   UnZoom();
}


//______________________________________________________________________________
UInt_t TASImage::GetWidth() const
{
   // Return width of original image not of the displayed image.
   // (Number of image pixels)

   return fImage ? fImage->width : 0;
}


//______________________________________________________________________________
UInt_t TASImage::GetHeight() const
{
   // Return height of original image not of the displayed image.
   // (Number of image pixels)

   return fImage ? fImage->height : 0;
}


//______________________________________________________________________________
UInt_t TASImage::GetScaledWidth() const
{
   // Return width of the displayed image not of the original image.
   // (Number of screen pixels)

   return fScaledImage ? fScaledImage->fImage->width : GetWidth();
}


//______________________________________________________________________________
UInt_t TASImage::GetScaledHeight() const
{
   // Return height of the displayed image not of the original image.
   // (Number of screen pixels)

   return fScaledImage ? fScaledImage->fImage->height : GetHeight();
}


//______________________________________________________________________________
void TASImage::GetZoomPosition(UInt_t &x, UInt_t &y, UInt_t &w, UInt_t &h) const
{
   // Return the zoom parameters.
   // This is useful when the zoom has been done interactively using the mouse.

   x = fZoomOffX;
   y = fZoomOffY;
   w = fZoomWidth;
   h = fZoomHeight;
}


//______________________________________________________________________________
Bool_t TASImage::InitVisual()
{
   // Static function to initialize the ASVisual.

   Display *disp;

   Bool_t inbatch = fgVisual && (fgVisual->dpy == (void*)1); // was in batch
   Bool_t noX = gROOT->IsBatch() || gVirtualX->InheritsFrom("TGWin32");

   // was in batch, but switched to gui
   if (inbatch && !noX) {
      destroy_asvisual(fgVisual, kFALSE);
      fgVisual = 0;
   }

   if (fgVisual && fgVisual->dpy) { // already initialized
      return kTRUE;
   }

   // batch or win32 mode
   if (!fgVisual && noX) {
      disp = 0;
      fgVisual = create_asvisual(0, 0, 0, 0);
      fgVisual->dpy = (Display*)1; //fake (not used)
      return kTRUE;
   }

#ifndef WIN32
#ifdef R__HAS_COCOA
   fgVisual = create_asvisual(0, 0, 0, 0);
   fgVisual->dpy = (Display*)1; //fake (not used)
#else
   disp = (Display*) gVirtualX->GetDisplay();
   Int_t screen  = gVirtualX->GetScreen();
   Int_t depth   = gVirtualX->GetDepth();
   Visual *vis   = (Visual*) gVirtualX->GetVisual();
   Colormap cmap = (Colormap) gVirtualX->GetColormap();

   if (vis == 0 || cmap == 0) {
      fgVisual = create_asvisual(0, 0, 0, 0);
   } else {
      fgVisual = create_asvisual_for_id(disp, screen, depth,
                                        XVisualIDFromVisual(vis), cmap, 0);
   }
#endif
#else
   fgVisual = create_asvisual(0, 0, 0, 0);
   fgVisual->dpy = (Display*)1; //fake (not used)
#endif

   return kTRUE;
}


//______________________________________________________________________________
void TASImage::StartPaletteEditor()
{
   // Start palette editor.

   if (!IsValid()) {
      Warning("StartPaletteEditor", "Image not valid");
      return;
   }
   if (fImage->alt.vector == 0) {
      Warning("StartPaletteEditor", "palette can be modified only for data images");
      return;
   }

   // Opens a GUI to edit the color palette
   TAttImage::StartPaletteEditor();
}


//______________________________________________________________________________
Pixmap_t TASImage::GetPixmap()
{
   // Returns image pixmap.
   // The pixmap must deleted by user.

   if (!InitVisual()) {
      Warning("GetPixmap", "Visual not initiated");
      return 0;
   }

   Pixmap_t ret;

   ASImage *img = fScaledImage ? fScaledImage->fImage : fImage;

   static int x11 = -1;
   if (x11 < 0) x11 = gVirtualX->InheritsFrom("TGX11");

   if (x11) {   // use builtin version
      ret = (Pixmap_t)asimage2pixmap(fgVisual, gVirtualX->GetDefaultRootWindow(),
                                       img, 0, kTRUE);
   } else {
      if (!fImage->alt.argb32) {
         BeginPaint();
      }
      ret = gVirtualX->CreatePixmapFromData((unsigned char*)fImage->alt.argb32,
                                             fImage->width, fImage->height);
   }

   return ret;
}


//______________________________________________________________________________
Pixmap_t TASImage::GetMask()
{
   // Returns image mask pixmap (alpha channel).
   // The pixmap must deleted by user.

   Pixmap_t pxmap = 0;

   if (!InitVisual()) {
      Warning("GetMask", "Visual not initiated");
      return pxmap;
   }

   ASImage *img = fScaledImage ? fScaledImage->fImage : fImage;

   if (!img) {
      Warning("GetMask", "No image");
      return pxmap;
   }

   UInt_t hh = img->height;
   UInt_t ow = img->width%8;
   UInt_t ww = img->width - ow + (ow ? 8 : 0);

   UInt_t bit = 0;
   int i = 0;
   UInt_t y = 0;
   UInt_t x = 0;

   char *bits = new char[ww*hh]; //an array of bits

   ASImageDecoder *imdec = start_image_decoding(fgVisual, img, SCL_DO_ALPHA,
                                                0, 0, ww, 0, 0);
   if (!imdec) {
      delete [] bits;
      return 0;
   }

   for (y = 0; y < hh; y++) {
      imdec->decode_image_scanline(imdec);
      CARD32 *a = imdec->buffer.alpha;

      for (x = 0; x < ww; x++) {
         if (a[x]) {
            SETBIT(bits[i], bit);
         } else {
            CLRBIT(bits[i], bit);
         }
         bit++;
         if (bit == 8) {
            bit = 0;
            i++;
         }
      }
   }

   stop_image_decoding(&imdec);
   pxmap = gVirtualX->CreateBitmap(gVirtualX->GetDefaultRootWindow(), (const char *)bits,
                                   ww, hh);
   delete [] bits;
   return pxmap;
}


//______________________________________________________________________________
void TASImage::SetImage(Pixmap_t pxm, Pixmap_t mask)
{
   // Create image from pixmap.

   if (!InitVisual()) {
      Warning("SetImage", "Visual not initiated");
      return;
   }

   DestroyImage();
   delete fScaledImage;
   fScaledImage = 0;

   Int_t xy;
   UInt_t w, h;
   gVirtualX->GetWindowSize(pxm, xy, xy, w, h);

   if (fName.IsNull()) fName.Form("img_%dx%d",w, h);

   static int x11 = -1;
   if (x11 < 0) x11 = gVirtualX->InheritsFrom("TGX11");

   if (x11) { //use built-in optimized version
      fImage = picture2asimage(fgVisual, pxm, mask, 0, 0, w, h, kAllPlanes, 1, 0);
   } else {
      unsigned char *bits = gVirtualX->GetColorBits(pxm, 0, 0, w, h);
      if (!bits) {   // error
         return;
      }

      // no mask
      if (!mask) {
         fImage = bitmap2asimage(bits, w, h, 0, 0);
         delete [] bits;
         return;
      }
      unsigned char *mask_bits = gVirtualX->GetColorBits(mask, 0, 0, w, h);
      fImage = bitmap2asimage(bits, w, h, 0, mask_bits);
      delete [] mask_bits;
      delete [] bits;
   }
}


//______________________________________________________________________________
TArrayL *TASImage::GetPixels(Int_t x, Int_t y, UInt_t width, UInt_t height)
{
   // Return 2D array of machine dependent pixel values.

   if (!fImage) {
      Warning("GetPixels", "Wrong Image");
      return 0;
   }

   ASImage *img =  fScaledImage ? fScaledImage->fImage : fImage;
   ASImageDecoder *imdec;

   width = !width  ? img->width : width;
   height = !height ? img->height : height;

   if (x < 0) {
      width -= x;
      x = 0 ;
   }
   if (y < 0) {
      height -= y;
      y = 0;
   }

   if ((x >= (int)img->width) || (y >= (int)img->height)) {
      return 0;
   }

   if ((int)(x + width) > (int)img->width) {
      width = img->width - x;
   }

   if ((int)(y + height) > (int)img->height) {
      height = img->height - y;
   }

   if ((imdec = start_image_decoding(0, fImage, SCL_DO_ALL, 0, y,
                                     img->width, height, 0)) == 0) {
      Warning("GetPixels", "Failed to create image decoder");
      return 0;
   }

   TArrayL *ret = new TArrayL(width * height);
   Int_t r = 0;
   Int_t g = 0;
   Int_t b = 0;
   Long_t p = 0;

   for (UInt_t k = 0; k < height; k++) {
      imdec->decode_image_scanline(imdec);

      for (UInt_t i = 0; i < width; ++i)  {
         if ((r == (Int_t)imdec->buffer.red[i]) &&
             (g == (Int_t)imdec->buffer.green[i]) &&
             (b == (Int_t)imdec->buffer.blue[i])) {
         } else {
            r = (Int_t)imdec->buffer.red[i];
            g = (Int_t)imdec->buffer.green[i];
            b = (Int_t)imdec->buffer.blue[i];
            p = (Long_t)TColor::RGB2Pixel(r, g, b);
         }
         ret->AddAt(p, k*width + i);
      }
   }

   stop_image_decoding(&imdec);
   return ret;
}


//______________________________________________________________________________
Double_t *TASImage::GetVecArray()
{
   // Return a pointer to internal array[width x height] of double values [0,1].
   // This array is directly accessible. That allows to manipulate/change the
   // image.

   if (!fImage) {
      Warning("GetVecArray", "Bad Image");
      return 0;
   }
   if (fImage->alt.vector) {
      return fImage->alt.vector;
   }
   // vectorize
   return 0;
}


//______________________________________________________________________________
TArrayD *TASImage::GetArray(UInt_t w, UInt_t h, TImagePalette *palette)
{
   // In case of vectorized image return an associated array of doubles
   // otherwise this method creates and returns a 2D array of doubles corresponding to palette.
   // If palette is ZERO a color converted to double value [0, 1] according to formula
   //   Double_t((r << 16) + (g << 8) + b)/0xFFFFFF
   // The returned array must be deleted after usage.

   if (!fImage) {
      Warning("GetArray", "Bad Image");
      return 0;
   }

   TArrayD *ret;

   if (fImage->alt.vector) {
      ret = new TArrayD(fImage->width*fImage->height, fImage->alt.vector);
      return ret;
   }

   ASImageDecoder *imdec;

   w = w ? w : fImage->width;
   h = h ? h : fImage->height;

   if ((fImage->width != w) || (fImage->height != h)) {
      Scale(w, h);
   }

   ASImage *img = fScaledImage ? fScaledImage->fImage : fImage;

   if ((imdec = start_image_decoding(0, img, SCL_DO_ALL, 0, 0,
                                     img->width, 0, 0)) == 0) {
      Warning("GetArray", "Failed to create image decoder");
      return 0;
   }

   ret = new TArrayD(w * h);
   CARD32 r = 0;
   CARD32 g = 0;
   CARD32 b = 0;
   Int_t p = 0;
   Double_t v = 0;

   for (UInt_t k = 0; k < h; k++) {
      imdec->decode_image_scanline(imdec);

      for (UInt_t i = 0; i < w; ++i)  {
         if ((r == imdec->buffer.red[i]) &&
             (g == imdec->buffer.green[i]) &&
             (b == imdec->buffer.blue[i])) {
         } else {
            r = imdec->buffer.red[i];
            g = imdec->buffer.green[i];
            b = imdec->buffer.blue[i];
            if (palette) p = palette->FindColor(r, g, b);
         }
         v = palette ? palette->fPoints[p] : Double_t((r << 16) + (g << 8) + b)/0xFFFFFF;
         ret->AddAt(v, (h-k-1)*w + i);
      }
   }

   stop_image_decoding(&imdec);
   return ret;
}


//______________________________________________________________________________
void TASImage::DrawText(Int_t x, Int_t y, const char *text, Int_t size,
                        const char *color, const char *font_name,
                        EText3DType type, const char *fore_file, Float_t angle)
{
   // Draw text of size (in pixels for TrueType fonts)
   // at position (x, y) with color  specified by hex string.
   //   font_name - TrueType font's filename or X font spec or alias.
   //   3D style of text is one of the following:
   //     0 - plain 2D text, 1 - embossed, 2 - sunken, 3 - shade above,
   //     4 - shade below, 5 - embossed thick, 6 - sunken thick.
   //     7 - ouline above, 8 - ouline below, 9 - full ouline.
   //  fore_file specifies foreground texture of text.

   UInt_t width=0, height=0;
   ARGB32 text_color = ARGB32_Black;
   ASImage *fore_im = 0;
   ASImage *text_im = 0;
   Bool_t ttfont = kFALSE;

   if (!InitVisual()) {
      Warning("DrawText", "Visual not initiated");
      return;
   }

   TString fn = font_name;
   fn.Strip();
   char *tmpstr = 0;

   if (fn.EndsWith(".pfa") || fn.EndsWith(".PFA") || fn.EndsWith(".pfb") || fn.EndsWith(".PFB") || fn.EndsWith(".ttf") || fn.EndsWith(".TTF") || fn.EndsWith(".otf") || fn.EndsWith(".OTF")) {
      tmpstr = gSystem->ExpandPathName(fn.Data());
      fn = tmpstr;
      ttfont = kTRUE;
   }
   delete [] tmpstr;

   if (color) {
      parse_argb_color(color, &text_color);
   }

   if (fImage && fImage->alt.argb32 && ttfont) {
      DrawTextTTF(x, y, text, size, text_color, fn.Data(), angle);
      return;
   }

   if (!gFontManager) {
      gFontManager = create_font_manager(fgVisual->dpy, 0, 0);
   }

   if (!gFontManager) {
      Warning("DrawText", "cannot create Font Manager");
      return;
   }

   ASFont *font = get_asfont(gFontManager, fn.Data(), 0, size, ASF_GuessWho);

   if (!font) {
      font = get_asfont(gFontManager, "fixed", 0, size, ASF_GuessWho);
      if (!font) {
         Warning("DrawText", "cannot find a font %s", font_name);
         return;
      }
   }

   get_text_size(text, font, (ASText3DType)type, &width, &height);

   if (!fImage) {
      fImage = create_asimage(width, height, 0);
      fill_asimage(fgVisual, fImage, 0, 0, width, height, 0xFFFFFFFF);
   }

   text_im = draw_text(text, font, (ASText3DType)type, 0);

   ASImage *rimg = fImage;

   if (fore_file) {
      ASImage *tmp = file2ASImage(fore_file, 0xFFFFFFFF, SCREEN_GAMMA, 0, 0);
      if (tmp) {
         if ((tmp->width != width) || (tmp->height != height)) {
            fore_im = tile_asimage(fgVisual, tmp, 0, 0, width, height, 0,
                                   ASA_ASImage, GetImageCompression(), GetImageQuality());
         }
         destroy_asimage(&tmp);
      } else {
         fore_im = tmp;
      }
   }

   if (fore_im) {
      move_asimage_channel(fore_im, IC_ALPHA, text_im, IC_ALPHA);
      destroy_asimage(&text_im);
   } else {
      fore_im = text_im ;
   }

   release_font(font);

   if (fore_im) {
      ASImage *rendered_im;
      ASImageLayer layers[2];

      init_image_layers(&(layers[0]), 2);
      fore_im->back_color = text_color;
      layers[0].im = rimg;
      layers[0].dst_x = 0;
      layers[0].dst_y = 0;
      layers[0].clip_width = rimg->width;
      layers[0].clip_height = rimg->height;
      layers[0].bevel = 0;
      layers[1].im = fore_im;
      layers[1].dst_x = x;
      layers[1].dst_y = y;
      layers[1].clip_width = fore_im->width;
      layers[1].clip_height = fore_im->height;

      rendered_im = merge_layers(fgVisual, &(layers[0]), 2, rimg->width, rimg->height,
                                 ASA_ASImage, GetImageCompression(), GetImageQuality());

      destroy_asimage(&fore_im);
      DestroyImage();
      fImage = rendered_im;
      UnZoom();
   }
}


//______________________________________________________________________________
void TASImage::Merge(const TImage *im, const char *op, Int_t x, Int_t y)
{
   // Merge two images.
   //
   // op is string which specifies overlay operation. Supported operations are:
   //    add            - color addition with saturation
   //    alphablend     - alpha-blending
   //    allanon        - color values averaging
   //    colorize       - hue and saturate bottom image same as top image
   //    darken         - use lowest color value from both images
   //    diff           - use absolute value of the color difference between two images
   //    dissipate      - randomly alpha-blend images
   //    hue            - hue bottom image same as top image
   //    lighten        - use highest color value from both images
   //    overlay        - some weird image overlaying(see GIMP)
   //    saturate       - saturate bottom image same as top image
   //    screen         - another weird image overlaying(see GIMP)
   //    sub            - color substraction with saturation
   //    tint           - tinting image with image
   //    value          - value bottom image same as top image

   if (!im) return;

   if (!InitVisual()) {
      Warning("Merge", "Visual not initiated");
      return;
   }

   ASImage *rendered_im;
   ASImageLayer layers[2];

   init_image_layers(&(layers[0]), 2);
   layers[0].im = fImage;
   layers[0].dst_x = 0;
   layers[0].dst_y = 0;
   layers[0].clip_width = fImage->width;
   layers[0].clip_height = fImage->height;
   layers[0].bevel = 0;
   layers[1].im = ((TASImage*)im)->fImage;
   layers[1].dst_x = x;
   layers[1].dst_y = y;
   layers[1].clip_width  = im->GetWidth();
   layers[1].clip_height = im->GetHeight();
   layers[1].merge_scanlines = blend_scanlines_name2func(op ? op : "add");

   rendered_im = merge_layers(fgVisual, &(layers[0]), 2, fImage->width, fImage->height,
                              ASA_ASImage, GetImageCompression(), GetImageQuality());

   DestroyImage();
   fImage = rendered_im;
   UnZoom();
}


//______________________________________________________________________________
void TASImage::Blur(Double_t hr, Double_t vr)
{
   // Perform Gaussian blurr of the image (usefull for drop shadows).
   //    hr         - horizontal radius of the blurr
   //    vr         - vertical radius of the blurr

   if (!InitVisual()) {
      Warning("Blur", "Visual not initiated");
      return;
   }

   if (!fImage) {
      fImage = create_asimage(100, 100, 0);

      if (!fImage) {
         Warning("Blur", "Failed to create image");
         return;
      }

      fill_asimage(fgVisual, fImage, 0, 0, fImage->width, fImage->height, ARGB32_White);
   }

   ASImage *rendered_im = blur_asimage_gauss(fgVisual, fImage, hr > 0 ? hr : 3,
                                             vr > 0 ? vr : 3, SCL_DO_ALL,
                                             ASA_ASImage, GetImageCompression(), GetImageQuality());
   DestroyImage();
   fImage = rendered_im;
   UnZoom();
}


//______________________________________________________________________________
TObject *TASImage::Clone(const char *newname) const
{
   // Clone image.

   if (!InitVisual() || !fImage) {
      Warning("Clone", "Image not initiated");
      return 0;
   }

   TASImage *im = (TASImage*)TImage::Create();

   if (!im) {
      Warning("Clone", "Failed to create image");
      return 0;
   }

   im->SetName(newname);

   im->fImage = clone_asimage(fImage, SCL_DO_ALL);
   im->fMaxValue = fMaxValue;
   im->fMinValue = fMinValue;
   im->fZoomOffX = fZoomOffX;
   im->fZoomOffY = fZoomOffY;
   im->fZoomWidth = fZoomWidth;
   im->fZoomHeight = fZoomHeight;
   im->fZoomUpdate = fZoomUpdate;
   im->fScaledImage = fScaledImage ? (TASImage*)fScaledImage->Clone("") : 0;

   if (fImage->alt.argb32) {
      UInt_t sz = fImage->width * fImage->height;
      im->fImage->alt.argb32 = (ARGB32*)safemalloc(sz*sizeof(ARGB32));
      memcpy(im->fImage->alt.argb32, fImage->alt.argb32, sz * sizeof(ARGB32));
   }

   return im;
}


//______________________________________________________________________________
Double_t *TASImage::Vectorize(UInt_t max_colors, UInt_t dither, Int_t opaque_threshold)
{
   // Reduce colordepth of an image and fills vector of "scientific data"
   // [0...1]
   //
   // Colors are reduced by allocating colorcells to most used colors first,
   // and then approximating other colors with those allocated.
   // max_colors       - maximum size of the colormap.
   // dither           - number of bits to strip off the color data ( 0...7 )
   // opaque_threshold - alpha channel threshold at which pixel should be
   //                    treated as opaque

   if (!InitVisual()) {
      Warning("Vectorize", "Visual not initiated");
      return 0;
   }

   if (!fImage) {
      fImage = create_asimage(100, 100, 0);

      if (!fImage) {
         Warning("Vectorize", "Failed to create image");
         return 0;
      }

      fill_asimage(fgVisual, fImage, 0, 0, fImage->width, fImage->height, ARGB32_White);
   }

   ASColormap cmap;
   int *res;
   UInt_t r=0, g=0, b=0;

   dither = dither > 7 ? 7 : dither;

   res = colormap_asimage(fImage, &cmap, max_colors, dither, opaque_threshold);

   Double_t *vec = new Double_t[fImage->height*fImage->width];
   UInt_t v;
   Double_t tmp;
   fMinValue = 2;
   fMaxValue = -1;

   for (UInt_t y = 0; y < fImage->height; y++) {
      for (UInt_t x = 0; x < fImage->width; x++) {
         int i = y*fImage->width + x;
         if (res) {
            g = INDEX_SHIFT_GREEN(cmap.entries[res[i]].green);
            b = INDEX_SHIFT_BLUE(cmap.entries[res[i]].blue);
            r = INDEX_SHIFT_RED(cmap.entries[res[i]].red);
         }
         v = MAKE_INDEXED_COLOR24(r,g,b);
         v = (v>>12)&0x0FFF;
         tmp = Double_t(v)/0x0FFF;
         vec[(fImage->height - y - 1)*fImage->width + x] = tmp;
         if (fMinValue > tmp) fMinValue = tmp;
         if (fMaxValue < tmp) fMaxValue = tmp;
      }
   }
   TImagePalette *pal = new TImagePalette(cmap.count);

   for (UInt_t j = 0; j < cmap.count; j++) {
      g = INDEX_SHIFT_GREEN(cmap.entries[j].green);
      b = INDEX_SHIFT_BLUE(cmap.entries[j].blue);
      r = INDEX_SHIFT_RED(cmap.entries[j].red);
      v = MAKE_INDEXED_COLOR24(r,g,b);

      v = (v>>12) & 0x0FFF;
      pal->fPoints[j] = Double_t(v)/0x0FFF;

      pal->fColorRed[j] = cmap.entries[j].red << 8;
      pal->fColorGreen[j] = cmap.entries[j].green << 8;
      pal->fColorBlue[j] = cmap.entries[j].blue << 8;
      pal->fColorAlpha[j] = 0xFF00;
   }

   destroy_colormap(&cmap, kTRUE);

   fPalette = *pal;
   fImage->alt.vector = vec;
   UnZoom();
   if (res) delete res;
   return (Double_t*)fImage->alt.vector;
}


//______________________________________________________________________________
void TASImage::HSV(UInt_t hue, UInt_t radius, Int_t H, Int_t S, Int_t V,
                   Int_t x, Int_t y, UInt_t width, UInt_t height)
{
   // This function will tile original image to specified size with offsets
   // requested, and then it will go though it and adjust hue, saturation and
   // value of those pixels that have specific hue, set by affected_hue/
   // affected_radius parameters. When affected_radius is greater then 180
   // entire image will be adjusted. Note that since grayscale colors have
   // no hue - the will not get adjusted. Only saturation and value will be
   // adjusted in gray pixels.
   // Hue is measured as an angle on a 360 degree circle, The following is
   // relationship of hue values to regular color names :
   // red      - 0
   // yellow   - 60
   // green    - 120
   // cyan     - 180
   // blue     - 240
   // magenta  - 300
   // red      - 360
   //
   // All the hue values in parameters will be adjusted to fall withing 0-360 range.

   // hue - hue in degrees in range 0-360. This allows to limit
   //       impact of color adjustment to affect only limited range of hues.
   //
   // radius - value in degrees to be used in order to
   //          calculate the range of affected hues. Range is determined by
   //          substracting and adding this value from/to affected_hue.
   //
   // H -   value by which to change hues in affected range.
   // S -   value by which to change saturation of the pixels in affected hue range.
   // V -   value by which to change Value(brightness) of pixels in affected hue range.
   //
   // x,y - position on infinite surface tiled with original image, of the
   //       left-top corner of the area to be used for new image.
   //
   // width, height - size of the area of the original image to be used for new image.
   //                 Default is current width, height of the image.

   if (!InitVisual()) {
      Warning("HSV", "Visual not initiated");
      return;
   }

   if (!fImage) {
      fImage = create_asimage(width ? width : 20, height ? height : 20, 0);

      if (!fImage) {
         Warning("HSV", "Failed to create image");
         return;
      }

      x = 0;
      y = 0;
      fill_asimage(fgVisual, fImage, 0, 0, fImage->width, fImage->height, ARGB32_White);
   }

   width = !width ? fImage->width : width;
   height = !height ? fImage->height : height;

   ASImage *rendered_im = 0;

   if (H || S || V) {
      rendered_im = adjust_asimage_hsv(fgVisual, fImage, x, y, width, height,
                                       hue, radius, H, S, V, ASA_ASImage, 100,
                                       ASIMAGE_QUALITY_TOP);
   }
   if (!rendered_im) {
      Warning("HSV", "Failed to create rendered image");
      return;
   }

   DestroyImage();
   fImage = rendered_im;
   UnZoom();
}


//______________________________________________________________________________
void TASImage::Gradient(UInt_t angle, const char *colors, const char *offsets,
                        Int_t x, Int_t y, UInt_t width, UInt_t height)
{
   // Render multipoint gradient inside rectangle of size (width, height)
   // at position (x,y) within the existing image.
   //
   // angle    Given in degrees.  Default is 0.  This is the
   //          direction of the gradient.  Currently the only supported
   //          values are 0, 45, 90, 135, 180, 225, 270, 315.  0 means left
   //          to right, 90 means top to bottom, etc.
   //
   // colors   Whitespace-separated list of colors.  At least two
   //          colors are required.  Each color in this list will be visited
   //          in turn, at the intervals given by the offsets attribute.
   //
   // offsets  Whitespace-separated list of floating point values
   //          ranging from 0.0 to 1.0.  The colors from the colors attribute
   //          are given these offsets, and the final gradient is rendered
   //          from the combination of the two.  If both colors and offsets
   //          are given but the number of colors and offsets do not match,
   //          the minimum of the two will be used, and the other will be
   //          truncated to match.  If offsets are not given, a smooth
   //          stepping from 0.0 to 1.0 will be used.

   if (!InitVisual()) {
      Warning("Gradient", "Visual not initiated");
      return;
   }

   ASImage *rendered_im = 0;
   ASGradient gradient;

   int reverse = 0, npoints1 = 0, npoints2 = 0;
   char *p;
   char *pb;
   char ch;
   TString str = colors;
   TString col;

   if ((angle > 2 * 180 * 15 / 16) || (angle < 2 * 180 * 1 / 16)) {
      gradient.type = GRADIENT_Left2Right;
   } else if (angle < 2 * 180 * 3 / 16) {
      gradient.type = GRADIENT_TopLeft2BottomRight;
   } else if (angle < 2 * 180 * 5 / 16) {
      gradient.type = GRADIENT_Top2Bottom;
   } else if (angle < 2 * 180 * 7 / 16) {
      gradient.type = GRADIENT_BottomLeft2TopRight; reverse = 1;
   } else if (angle < 2 * 180 * 9 / 16) {
      gradient.type = GRADIENT_Left2Right; reverse = 1;
   } else if (angle < 2 * 180 * 11 / 16) {
      gradient.type = GRADIENT_TopLeft2BottomRight; reverse = 1;
   } else if (angle < 2 * 180 * 13 / 16) {
      gradient.type = GRADIENT_Top2Bottom; reverse = 1;
   } else {
      gradient.type = GRADIENT_BottomLeft2TopRight;
   }

   for (p = (char*)colors; isspace((int)*p); p++) { }

   for (npoints1 = 0; *p; npoints1++) {
      if (*p) {
         for ( ; *p && !isspace((int)*p); p++) { }
      }
      for ( ; isspace((int)*p); p++) { }
   }
   if (offsets) {
      for (p = (char*)offsets; isspace((int)*p); p++) { }

      for (npoints2 = 0; *p; npoints2++) {
         if (*p) {
            for ( ; *p && !isspace((int)*p); p++) { }
         }
         for ( ; isspace((int)*p); p++) { }
      }
   }
   if (npoints1 > 1) {
      int i;
      if (offsets && (npoints1 > npoints2)) npoints1 = npoints2;

      if (!width) {
         width = fImage ? fImage->width : 20;
      }
      if (!height) {
         height = fImage ? fImage->height : 20;
      }

      gradient.color = new ARGB32[npoints1];
      gradient.offset = new double[npoints1];

      for (p = (char*)colors; isspace((int)*p); p++) { }

      for (npoints1 = 0; *p; ) {
         pb = p;

         if (*p) {
            for ( ; *p && !isspace((int)*p); p++) { }
         }
         for ( ; isspace((int)*p); p++) { }

         col = str(pb - colors, p - pb);

         if (parse_argb_color(col.Data(), gradient.color + npoints1) != col) {
            npoints1++;
         } else {
            Warning("Gradient", "Failed to parse color [%s] - defaulting to black", pb);
         }
      }

      if (offsets) {
         for (p = (char*)offsets; isspace((int)*p); p++) { }

         for (npoints2 = 0; *p; ) {
            pb = p;

            if (*p) {
               for ( ; *p && !isspace((int)*p); p++) { }
            }
            ch = *p; *p = '\0';
            gradient.offset[npoints2] = strtod(pb, &pb);

            if (pb == p) npoints2++;
            *p = ch;
            for ( ; isspace((int)*p); p++) { }
         }
      } else {
         for (npoints2 = 0; npoints2 < npoints1; npoints2++) {
            gradient.offset[npoints2] = (double)npoints2 / (npoints1 - 1);
         }
      }
      gradient.npoints = npoints1;

      if (npoints2 && (gradient.npoints > npoints2)) {
         gradient.npoints = npoints2;
      }
      if (reverse) {
         for (i = 0; i < gradient.npoints/2; i++) {
            int i2 = gradient.npoints - 1 - i;
            ARGB32 c = gradient.color[i];
            double o = gradient.offset[i];
            gradient.color[i] = gradient.color[i2];
            gradient.color[i2] = c;
            gradient.offset[i] = gradient.offset[i2];
            gradient.offset[i2] = o;
         }
         for (i = 0; i < gradient.npoints; i++) {
            gradient.offset[i] = 1.0 - gradient.offset[i];
         }
      }
      rendered_im = make_gradient(fgVisual, &gradient, width, height, SCL_DO_ALL,
                                  ASA_ASImage, GetImageCompression(), GetImageQuality());

      delete [] gradient.color;
      delete [] gradient.offset;
   }

   if (!rendered_im) {  // error
      Warning("Gradient", "Failed to create gradient image");
      return;
   }

   if (!fImage) {
      fImage = rendered_im;
      return;
   }

   ASImageLayer layers[2];

   init_image_layers(&(layers[0]), 2);
   layers[0].im = fImage;
   layers[0].dst_x = 0;
   layers[0].dst_y = 0;
   layers[0].clip_width = fImage->width;
   layers[0].clip_height = fImage->height;
   layers[0].bevel = 0;
   layers[1].im = rendered_im;
   layers[1].dst_x = x;
   layers[1].dst_y = y;
   layers[1].clip_width = width;
   layers[1].clip_height = height;
   layers[1].merge_scanlines = alphablend_scanlines;

   ASImage *merge_im = merge_layers(fgVisual, &(layers[0]), 2, fImage->width, fImage->height,
                                    ASA_ASImage, GetImageCompression(), GetImageQuality());
   if (!merge_im) {
      Warning("Gradient", "Failed to create merged image");
      return;
   }

   destroy_asimage(&rendered_im);
   DestroyImage();
   fImage = merge_im;
   UnZoom();
}


//______________________________________________________________________________
static CARD8 MakeComponentHilite(int cmp)
{
   // Make component hilite.
   // (used internally)

   if (cmp < 51) {
      cmp = 51;
   }
   cmp = (cmp * 12) / 10;

   return (cmp > 255) ? 255 : cmp;
}


//______________________________________________________________________________
static ARGB32 GetHilite(ARGB32 background)
{
   // Calculate highlite color.
   // (used internally)

   return ((MakeComponentHilite((background>>24) & 0x000000FF) << 24) & 0xFF000000) |
           ((MakeComponentHilite((background & 0x00FF0000) >> 16) << 16) & 0x00FF0000) |
           ((MakeComponentHilite((background & 0x0000FF00) >> 8) << 8) & 0x0000FF00) |
           ((MakeComponentHilite((background & 0x000000FF))) & 0x000000FF);
}


//______________________________________________________________________________
static ARGB32 GetShadow(ARGB32 background)
{
   // Calculate shadow color.
   // (used internally)

   return (background >> 1) & 0x7F7F7F7F;
}


//______________________________________________________________________________
static ARGB32 GetAverage(ARGB32 foreground, ARGB32 background)
{
   // Get average.
   // (used internally)

   CARD16   a, r, g, b;

   a = ARGB32_ALPHA8(foreground) + ARGB32_ALPHA8(background);
   a = (a<<3)/10;
   r = ARGB32_RED8(foreground) + ARGB32_RED8(background);
   r = (r<<3)/10;
   g = ARGB32_GREEN8(foreground) + ARGB32_GREEN8(background);
   g = (g<<3)/10;
   b = ARGB32_BLUE8(foreground) + ARGB32_BLUE8(background);
   b = (b<<3)/10;

   return MAKE_ARGB32(a, r, g, b);
}


//______________________________________________________________________________
void TASImage::Bevel(Int_t x, Int_t y, UInt_t width, UInt_t height,
                     const char *hi_color, const char *lo_color, UShort_t thick,
                     Bool_t reverse)
{
   // Bevel is used to create 3D effect while drawing buttons, or any other
   // image that needs to be framed. Bevel is drawn using 2 primary colors:
   // one for top and left sides - hi color, and another for bottom and
   // right sides - low color. Bevel can be drawn over exisiting image or
   // as newly created,  as it is shown in code below:
   //
   //  TImage *img = TImage::Create();
   //  img->Bevel(0, 0, 400, 300, "#dddddd", "#000000", 3);

   if (!InitVisual()) {
      Warning("Bevel", "Visual not initiated");
      return;
   }

   ASImageBevel bevel;
   bevel.type = 0;

   ARGB32 hi=ARGB32_White, lo=ARGB32_White;
   parse_argb_color(hi_color, &hi);
   parse_argb_color(lo_color, &lo);

   if (reverse) {
      bevel.lo_color = hi;
      bevel.lolo_color = GetHilite(hi);
      bevel.hi_color = lo;
      bevel.hihi_color = GetShadow(lo);
   } else {
      bevel.hi_color = hi;
      bevel.hihi_color = GetHilite(hi);
      bevel.lo_color = lo;
      bevel.lolo_color = GetShadow(lo);
   }
   bevel.hilo_color = GetAverage(hi, lo);

   int extra_hilite = 2;
   bevel.left_outline = bevel.top_outline = bevel.right_outline = bevel.bottom_outline = thick;
   bevel.left_inline = bevel.top_inline = bevel.right_inline = bevel.bottom_inline = extra_hilite + 1;

   if (bevel.top_outline > 1) {
      bevel.top_inline += bevel.top_outline - 1;
   }

   if (bevel.left_outline > 1) {
      bevel.left_inline += bevel.left_outline - 1;
   }

   if (bevel.right_outline > 1) {
      bevel.right_inline += bevel.right_outline - 1;
   }

   if (bevel.bottom_outline > 1) {
      bevel.bottom_inline += bevel.bottom_outline - 1;
   }

   ASImage *merge_im;
   ARGB32 fill = ((hi>>24) != 0xff) || ((lo>>24) != 0xff) ? bevel.hilo_color : (bevel.hilo_color | 0xff000000);

   if (!fImage) {
      fImage = create_asimage(width ? width : 20, height ? height : 20, 0);

      if (!fImage) {
         Warning("Bevel", "Failed to create image");
         return;
      }

      x = 0;
      y = 0;
      fill_asimage(fgVisual, fImage, 0, 0, fImage->width, fImage->height, fill);
   }

   width = !width ? fImage->width : width;
   height = !height ? fImage->height : height;

   ASImageLayer layers[2];
   init_image_layers(&(layers[0]), 2);

   layers[0].im = fImage;
   layers[0].dst_x = 0;
   layers[0].dst_y = 0;
   layers[0].clip_width = fImage->width;
   layers[0].clip_height = fImage->height;
   layers[0].bevel = 0;

   UInt_t w = width - (bevel.left_outline + bevel.right_outline);
   UInt_t h = height - (bevel.top_outline + bevel.bottom_outline);
   ASImage *bevel_im = create_asimage(w, h, 0);

   if (!bevel_im) {
      Warning("Bevel", "Failed to create bevel image");
      return;
   }

   layers[1].im = bevel_im;
   fill_asimage(fgVisual, bevel_im, 0, 0, w, h, fill);

   layers[1].dst_x = x;
   layers[1].dst_y = y;
   layers[1].clip_width = width;
   layers[1].clip_height = height;
   layers[1].bevel = &bevel;
   layers[1].merge_scanlines = alphablend_scanlines;

   merge_im = merge_layers(fgVisual, &(layers[0]), 2, fImage->width, fImage->height,
                           ASA_ASImage, GetImageCompression(), GetImageQuality());
   destroy_asimage(&bevel_im);

   if (!merge_im) {
      Warning("Bevel", "Failed to image");
      return;
   }

   DestroyImage();
   fImage = merge_im;
   UnZoom();
}


//______________________________________________________________________________
void TASImage::Pad(const char *col, UInt_t l, UInt_t r, UInt_t t, UInt_t b)
{
   // Enlarge image, padding it with specified color on each side in
   // accordance with requested geometry.

   Int_t x, y;
   UInt_t w, h;

   if (!InitVisual()) {
      Warning("Pad", "Visual not initiated");
      return;
   }

   if (!fImage) {
      fImage = create_asimage(100, 100, 0);

      if (!fImage) {
         Warning("Pad", "Failed to create image");
         return;
      }

      x = 0;
      y = 0;
      fill_asimage(fgVisual, fImage, 0, 0, fImage->width, fImage->height, ARGB32_White);
   }

   ARGB32 color = ARGB32_White;
   parse_argb_color(col, &color);

   x = l;
   y = t;
   w = l + fImage->width + r;
   h = t + fImage->height + b;

   ASImage *img = pad_asimage(fgVisual, fImage, x, y, w, h, color,
                              ASA_ASImage, GetImageCompression(), GetImageQuality());

   if (!img) {
      Warning("Pad", "Failed to create output image");
      return;
   }

   DestroyImage();
   fImage = img;
   UnZoom();
   fZoomUpdate = kZoomOps;
}


//______________________________________________________________________________
void TASImage::Crop(Int_t x, Int_t y, UInt_t width, UInt_t height)
{
   // Crop an image.

   if (!InitVisual()) {
      Warning("Crop", "Visual not initiated");
      return;
   }

   if (!fImage) {
      Warning("Crop", "No image");
      return;
   }

   x = x < 0 ? 0 : x;
   y = y < 0 ? 0 : y;

   width = x + width > fImage->width ? fImage->width - x : width;
   height = y + height > fImage->height ? fImage->height - y : height;

   if ((width == fImage->width) && (height == fImage->height)) {
      Warning("Crop", "input size larger than image");
      return;
   }
   ASImageDecoder *imdec = start_image_decoding(fgVisual, fImage, SCL_DO_ALL,
                                                x, y, width, height, 0);

   if (!imdec) {
      Warning("Crop", "Failed to start image decoding");
      return;
   }

   ASImage *img = create_asimage(width, height, 0);

   if (!img) {
      delete [] imdec;
      Warning("Crop", "Failed to create image");
      return;
   }

   ASImageOutput *imout = start_image_output(fgVisual, img, ASA_ASImage,
                                             GetImageCompression(), GetImageQuality());

   if (!imout) {
      Warning("Crop", "Failed to start image output");
      destroy_asimage(&img);
      if (imdec) delete [] imdec;
      return;
   }

#ifdef HAVE_MMX
   mmx_init();
#endif

   for (UInt_t i = 0; i < height; i++) {
      imdec->decode_image_scanline(imdec);
      imout->output_image_scanline(imout, &(imdec->buffer), 1);
   }

   stop_image_decoding(&imdec);
   stop_image_output(&imout);

#ifdef HAVE_MMX
   mmx_off();
#endif

   DestroyImage();
   fImage = img;
   UnZoom();
   fZoomUpdate = kZoomOps;
}


//______________________________________________________________________________
void TASImage::Append(const TImage *im, const char *option, const char *color )
{
   // Append image.
   //
   // option:
   //       "+" - appends to the right side
   //       "/" - appends to the bottom

   if (!im) return;

   if (!InitVisual()) {
      Warning("Append", "Visual not initiated");
      return;
   }

   if (!fImage) {
      fImage = ((TASImage*)im)->fImage;
      return;
   }

   TString opt = option;
   opt.Strip();

   UInt_t width = fImage->width;
   UInt_t height = fImage->height;

   if (opt == "+") {
      Pad(color, 0, im->GetWidth(), 0, 0);
      Merge(im, "alphablend", width, 0);
   } else if (opt == "/") {
      Pad(color, 0, 0, 0, im->GetHeight());
      Merge(im, "alphablend", 0, height);
   } else {
      return;
   }

   UnZoom();
}


//______________________________________________________________________________
void TASImage::BeginPaint(Bool_t mode)
{
   // BeginPaint initializes internal array[width x height] of ARGB32 pixel
   // values.
   // That provides quick access to image during paint operations.
   // To RLE compress image one needs to call EndPaint method when paintinig
   // is over.

   if (!InitVisual()) {
      Warning("BeginPaint", "Visual not initiated");
      return;
   }

   if (!fImage) {
      return;
   }

   fPaintMode = mode;

   if (!fPaintMode || fImage->alt.argb32) {
      return;
   }

   ASImage *img = tile_asimage(fgVisual, fImage, 0, 0, fImage->width, fImage->height,
                               0, ASA_ARGB32, 0, ASIMAGE_QUALITY_DEFAULT);

   if (!img) {
      Warning("BeginPaint", "Failed to create image");
      return;
   }

   DestroyImage();
   fImage = img;
}


//______________________________________________________________________________
void TASImage::EndPaint()
{
   // EndPaint does internal RLE compression of image data.

   if (!fImage) {
      Warning("EndPaint", "no image");
      return;
   }

   if (!fImage->alt.argb32) return;

   ASImage *img = tile_asimage(fgVisual, fImage, 0, 0, fImage->width, fImage->height,
                               0, ASA_ASImage, 0, ASIMAGE_QUALITY_DEFAULT);

   if (!img) {
      Warning("EndPaint", "Failed to create image");
      return;
   }

   fPaintMode = kFALSE;
   DestroyImage();
   fImage = img;
}


//______________________________________________________________________________
UInt_t *TASImage::GetArgbArray()
{
   // Return a pointer to internal array[width x height] of ARGB32 values
   // This array is directly accessible. That allows to manipulate/change the
   // image.

   if (!fImage) {
      Warning("GetArgbArray", "no image");
      return 0;
   }

   ASImage *img = fScaledImage ? fScaledImage->fImage : fImage;
   if (!img) return 0;

   if (!img->alt.argb32) {
      if (fScaledImage) {
         fScaledImage->BeginPaint();
         img = fScaledImage->fImage;
      } else {
         BeginPaint();
         img = fImage;
      }
   }

   return (UInt_t *)img->alt.argb32;
}


//______________________________________________________________________________
UInt_t *TASImage::GetRgbaArray()
{
   // Return a pointer to an array[width x height] of RGBA32 values.
   // This array is created from internal ARGB32 array,
   // must be deleted after usage.

   if (!fImage) {
      Warning("GetRgbaArray", "no image");
      return 0;
   }

   ASImage *img = fScaledImage ? fScaledImage->fImage : fImage;
   if (!img) return 0;

   if (!img->alt.argb32) {
      if (fScaledImage) {
         fScaledImage->BeginPaint();
         img = fScaledImage->fImage;
      } else {
         BeginPaint();
         img = fImage;
      }
   }

   UInt_t i, j;
   Int_t y = 0;
   Int_t idx = 0;
   UInt_t a, rgb, rgba, argb;
   y = 0;

   UInt_t *ret = new UInt_t[img->width*img->height];

   for (i = 0; i < img->height; i++) {
      for (j = 0; j < img->width; j++) {
         idx = y + j;
         argb = img->alt.argb32[idx];
         a = argb >> 24;
         rgb =  argb & 0x00ffffff;
         rgba = (rgb <<  8) + a;
         ret[idx] = rgba;
      }
      y += img->width;
   }

   return ret;
}


//______________________________________________________________________________
UInt_t *TASImage::GetScanline(UInt_t y)
{
   // Return a pointer to scanline.

   if (!fImage) {
      Warning("GetScanline", "no image");
      return 0;
   }

   ASImage *img = fScaledImage ? fScaledImage->fImage : fImage;
   CARD32 *ret = new CARD32[img->width];

   ASImageDecoder *imdec = start_image_decoding(fgVisual, img, SCL_DO_ALL,
                                                0, y, img->width, 1, 0);

   if (!imdec) {
      delete [] ret;
      Warning("GetScanline", "Failed to start image decoding");
      return 0;
   }

#ifdef HAVE_MMX
   mmx_init();
#endif

   imdec->decode_image_scanline(imdec);
   memcpy(imdec->buffer.buffer, ret, img->width*sizeof(CARD32));
   stop_image_decoding(&imdec);

#ifdef HAVE_MMX
   mmx_off();
#endif

   return (UInt_t*)ret;
}


//______________________________________________________________________________
//
// Vector graphics
// a couple of macros which can be "assembler accelerated"

#if defined(R__GNU) && defined(__i386__) && !defined(__sun)
#define _MEMSET_(dst, lng, val)   __asm__("movl  %0,%%eax \n"\
                                      "movl  %1,%%edi \n"              \
                                      "movl  %2,%%ecx \n"              \
                                      "cld \n"                         \
                                      "rep \n"                         \
                                      "stosl \n"                       \
                                      : /* no output registers */      \
                                      :"g" (val), "g" (dst), "g" (lng) \
                                      :"eax","edi","ecx"               \
                                     )

#else
 #define _MEMSET_(dst, lng, val) do {\
 for( UInt_t j=0; j < lng; j++) *((dst)+j) = val; } while (0)

#endif

#define FillSpansInternal(npt, ppt, widths, color) do {\
   UInt_t yy = ppt[0].fY*fImage->width;\
   for (UInt_t i = 0; i < npt; i++) {\
      _MEMSET_(&fImage->alt.argb32[yy + ppt[i].fX], widths[i], color);\
      yy += ((i+1 < npt) && (ppt[i].fY != ppt[i+1].fY) ? fImage->width : 0);\
   }\
} while (0)


//______________________________________________________________________________
void TASImage::FillRectangleInternal(UInt_t col, Int_t x, Int_t y, UInt_t width, UInt_t height)
{
   // Fill rectangle of size (width, height) at position (x,y)
   // within the existing image with specified color.

   ARGB32 color = (ARGB32)col;

   if (width  == 0) width = 1;
   if (height == 0) height = 1;

   if (x < 0) {
      width += x;
      x = 0;
   }
   if (y < 0) {
      height += y;
      y = 0;
   }

   Bool_t has_alpha = (color & 0xff000000) != 0xff000000;

   x = x > (int)fImage->width ? (Int_t)fImage->width : x;
   y = y > (int)fImage->height ? (Int_t)fImage->height : y;

   width = x + width > fImage->width ? fImage->width - x : width;
   height = y + height > fImage->height ? fImage->height - y : height;

   if (!fImage->alt.argb32) {
      fill_asimage(fgVisual, fImage, x, y, width, height, color);
   } else {
      int yyy = y*fImage->width;
      if (!has_alpha) { // use faster memset
         ARGB32 *p0 = fImage->alt.argb32 + yyy + x;
         ARGB32 *p = p0;
         for (UInt_t i = 0; i < height; i++) {
            _MEMSET_(p, width, color);
            p += fImage->width;
         }
      } else {
         for (UInt_t i = y; i < y + height; i++) {
            int j = x + width;
            while (j > x) {
               j--;
               _alphaBlend(&fImage->alt.argb32[yyy + j], &color);
            }
         }
         yyy += fImage->width;
      }
   }
}


//______________________________________________________________________________
void TASImage::FillRectangle(const char *col, Int_t x, Int_t y, UInt_t width, UInt_t height)
{
   // Fill rectangle of size (width, height) at position (x,y)
   // within the existing image with specified color.
   //
   // To create new image with Fill method the following code can be used:
   //
   //  TImage *img = TImage::Create();
   //  img->Fill("#FF00FF", 0, 0, 400, 300);

   if (!InitVisual()) {
      Warning("Fill", "Visual not initiated");
      return;
   }

   ARGB32 color = ARGB32_White;

   if (col) {
      parse_argb_color(col, &color);
   }

   if (!fImage) {
      fImage = create_asimage(width ? width : 20, height ? height : 20, 0);
      x = 0;
      y = 0;
   }

   FillRectangleInternal((UInt_t)color, x, y, width, height);
   UnZoom();
}


//______________________________________________________________________________
void TASImage::DrawVLine(UInt_t x, UInt_t y1, UInt_t y2, UInt_t col, UInt_t thick)
{
   // Draw a vertical line.

   ARGB32 color = (ARGB32)col;
   UInt_t half = 0;

   if (!thick)  thick = 1;

   if (thick > 1) {
      half = thick >> 1;
      if (x > half) {
         x =  x - half;
      } else {
         x = 0;
         thick += (x - half);
      }
   }

   y2 = y2 >= fImage->height ? fImage->height - 1 : y2;
   y1 = y1 >= fImage->height ? fImage->height - 1 : y1;
   x = x + thick >= fImage->width ? fImage->width - thick - 1 : x;

   int yy = y1*fImage->width;
   for (UInt_t y = y1; y <= y2; y++) {
      for (UInt_t w = 0; w < thick; w++) {
         if (x + w < fImage->width) {
            _alphaBlend(&fImage->alt.argb32[yy + (x + w)], &color);
         }
      }
      yy += fImage->width;
   }
}


//______________________________________________________________________________
void TASImage::DrawHLine(UInt_t y, UInt_t x1, UInt_t x2, UInt_t col, UInt_t thick)
{
   // Draw an horizontal line.

   ARGB32 color = (ARGB32)col;
   UInt_t half = 0;

   if (!thick)  thick = 1;

   if (thick > 1) {
      half = thick >> 1;
      if (y > half) {
         y =  y - half;
      } else {
         y = 0;
         thick += (y - half);
      }
   }

   y = y + thick >= fImage->height ? fImage->height - thick - 1 : y;
   x2 = x2 >= fImage->width ? fImage->width - 1 : x2;
   x1 = x1 >= fImage->width ? fImage->width - 1 : x1;

   int yy = y*fImage->width;
   for (UInt_t w = 0; w < thick; w++) {
      for (UInt_t x = x1; x <= x2; x++) {
         if (y + w < fImage->height) {
            _alphaBlend(&fImage->alt.argb32[yy + x], &color);
         }
      }
      yy += fImage->width;
   }
}


//______________________________________________________________________________
void TASImage::DrawLine(UInt_t x1,  UInt_t y1, UInt_t x2, UInt_t y2,
                        const char *col, UInt_t thick)
{
   // Draw a line.

   ARGB32 color = ARGB32_White;
   parse_argb_color(col, &color);
   DrawLineInternal(x1, y1, x2, y2, (UInt_t)color, thick);
}


//______________________________________________________________________________
void TASImage::DrawLineInternal(UInt_t x1, UInt_t y1, UInt_t x2, UInt_t y2,
                                UInt_t col, UInt_t thick)
{
   // Internal line drawing.

   int dx, dy, d;
   int i1, i2;
   int x, y, xend, yend;
   int xdir, ydir;
   int q;
   int idx;
   int yy;

   if (!InitVisual()) {
      Warning("DrawLine", "Visual not initiated");
      return;
   }

   if (!fImage) {
      Warning("DrawLine", "no image");
      return;
   }

   if (!fImage->alt.argb32) {
      BeginPaint();
   }

   if (!fImage->alt.argb32) {
      Warning("DrawLine", "Failed to get pixel array");
      return;
   }

   ARGB32 color = (ARGB32)col;

   dx = TMath::Abs(Int_t(x2) - Int_t(x1));
   dy = TMath::Abs(Int_t(y2) - Int_t(y1));

   if (!dx) {
      DrawVLine(x1, y2 > y1 ? y1 : y2,
                    y2 > y1 ? y2 : y1, color, thick);
      return;
   }

   if (!dy) {
      DrawHLine(y1, x2 > x1 ? x1 : x2,
                    x2 > x1 ? x2 : x1, color, thick);
      return;
   }

   if (thick > 1) {
      DrawWideLine(x1, y1, x2, y2, color, thick);
      return;
   }

   if (dy <= dx) {
      UInt_t ddy = dy << 1;
      i1 = ddy;
      i2 = i1 - (dx << 1);
      d = i1 - dx;

      if (x1 > x2) {
         x = x2;
         y = y2;
         ydir = -1;
         xend = x1;
      } else {
         x = x1;
         y = y1;
         ydir = 1;
         xend = x2;
      }

      yy = y*fImage->width;
      _alphaBlend(&fImage->alt.argb32[yy + x], &color);
      q = (y2 - y1) * ydir;

      if (q > 0) {
         while (x < xend) {
            idx = yy + x;
            _alphaBlend(&fImage->alt.argb32[idx], &color);
            x++;

            if (d >= 0) {
               yy += fImage->width;
               d += i2;
            } else {
               d += i1;
            }
         }
      } else {
         while (x < xend) {
            idx = yy + x;
            _alphaBlend(&fImage->alt.argb32[idx], &color);
            x++;

            if (d >= 0) {
               yy -= fImage->width;
               d += i2;
            } else {
               d += i1;
            }
         }
      }
   } else {
      UInt_t ddx = dx << 1;
      i1 = ddx;
      i2 = i1 - (dy << 1);
      d = i1 - dy;

      if (y1 > y2) {
         y = y2;
         x = x2;
         yend = y1;
         xdir = -1;
      } else {
         y = y1;
         x = x1;
         yend = y2;
         xdir = 1;
      }

      yy = y*fImage->width;
      _alphaBlend(&fImage->alt.argb32[yy + x], &color);
      q = (x2 - x1) * xdir;

      if (q > 0) {
         while (y < yend) {
            idx = yy + x;
            _alphaBlend(&fImage->alt.argb32[idx], &color);
            y++;
            yy += fImage->width;

            if (d >= 0) {
               x++;
               d += i2;
            } else {
               d += i1;
            }
         }
      } else {
         while (y < yend) {
            idx = yy + x;
            _alphaBlend(&fImage->alt.argb32[idx], &color);
            y++;
            yy += fImage->width;

            if (d >= 0) {
               x--;
               d += i2;
            } else {
               d += i1;
            }
         }
      }
   }
}


//______________________________________________________________________________
void TASImage::DrawRectangle(UInt_t x, UInt_t y, UInt_t w, UInt_t h,
                             const char *col, UInt_t thick)
{
   // Draw a rectangle.

   if (!InitVisual()) {
      Warning("DrawRectangle", "Visual not initiated");
      return;
   }

   if (!fImage) {
      w = w ? w : 20;
      h = h ? h : 20;
      x = 0;
      y = 0;
      fImage = create_asimage(w, h, 0);
      FillRectangle(col, 0, 0, w, h);
      return;
   }

   if (!fImage->alt.argb32) {
      BeginPaint();
   }

   if (!fImage->alt.argb32) {
      Warning("DrawRectangle", "Failed to get pixel array");
      return;
   }

   ARGB32 color = ARGB32_White;
   parse_argb_color(col, &color);

   DrawHLine(y, x, x + w, (UInt_t)color, thick);
   DrawVLine(x + w, y, y + h, (UInt_t)color, thick);
   DrawHLine(y + h, x, x + w, (UInt_t)color, thick);
   DrawVLine(x, y, y + h, (UInt_t)color, thick);
   UnZoom();
}


//______________________________________________________________________________
void TASImage::DrawBox(Int_t x1, Int_t y1, Int_t x2, Int_t y2, const char *col,
                       UInt_t thick, Int_t mode)
{
   // Draw a box.

   Int_t x = TMath::Min(x1, x2);
   Int_t y = TMath::Min(y1, y2);
   Int_t w = TMath::Abs(x2 - x1);
   Int_t h = TMath::Abs(y2 - y1);

   ARGB32 color = ARGB32_White;

   if (!fImage) {
      w = w ? x+w : x+20;
      h = h ? y+h : y+20;
      fImage = create_asimage(w, h, 0);
      FillRectangle(col, 0, 0, w, h);
      return;
   }

   if (x1 == x2) {
      parse_argb_color(col, &color);
      DrawVLine(x1, y1, y2, color, 1);
      return;
   }

   if (y1 == y2) {
      parse_argb_color(col, &color);
      DrawHLine(y1, x1, x2, color, 1);
      return;
   }


   switch (mode) {
      case TVirtualX::kHollow:
         DrawRectangle(x, y, w, h, col, thick);
         break;

      case TVirtualX::kFilled:
         FillRectangle(col, x, y, w, h);
         break;

      default:
         FillRectangle(col, x, y, w, h);
         break;
   }
}


//______________________________________________________________________________
void TASImage::DrawDashHLine(UInt_t y, UInt_t x1, UInt_t x2, UInt_t nDash,
                             const char *pDash, UInt_t col, UInt_t thick)
{
   // Draw a dashed horizontal line.

   UInt_t iDash = 0;    // index of current dash
   int i = 0;

   ARGB32 color = (ARGB32)col;

   UInt_t half = 0;

   if (thick > 1) {
      half = thick >> 1;
      if (y > half) {
         y =  y - half;
      } else {
         y = 0;
         thick += (y - half);
      }
   }
   thick = thick <= 0 ? 1 : thick;

   y = y + thick >= fImage->height ? fImage->height - thick - 1 : y;
   x2 = x2 >= fImage->width ? fImage->width - 1 : x2;
   x1 = x1 >= fImage->width ? fImage->width - 1 : x1;

   // switch x1, x2
   UInt_t tmp = x1;
   x1 = x2 < x1 ? x2 : x1;
   x2 = x2 < tmp ? tmp : x2;

   for (UInt_t x = x1; x <= x2; x++) {
      for (UInt_t w = 0; w < thick; w++) {
         if (y + w < fImage->height) {
            if ((iDash%2)==0) {
               _alphaBlend(&fImage->alt.argb32[(y + w)*fImage->width + x], &color);
            }
         }
      }
      i++;

      if (i >= pDash[iDash]) {
         iDash++;
         i = 0;
      }
      if (iDash >= nDash) {
         iDash = 0;
         i = 0;
      }
   }
}


//______________________________________________________________________________
void TASImage::DrawDashVLine(UInt_t x, UInt_t y1, UInt_t y2, UInt_t nDash,
                             const char *pDash, UInt_t col, UInt_t thick)
{
   // Draw a dashed vertical line.

   UInt_t iDash = 0;    // index of current dash
   int i = 0;

   ARGB32 color = (ARGB32)col;

   UInt_t half = 0;

   if (thick > 1) {
      half = thick >> 1;
      if (x > half) {
         x =  x - half;
      } else {
         x = 0;
         thick += (x - half);
      }
   }
   thick = thick <= 0 ? 1 : thick;

   y2 = y2 >= fImage->height ? fImage->height - 1 : y2;
   y1 = y1 >= fImage->height ? fImage->height - 1 : y1;

   // switch x1, x2
   UInt_t tmp = y1;
   y1 = y2 < y1 ? y2 : y1;
   y2 = y2 < tmp ? tmp : y2;

   x = x + thick >= fImage->width ? fImage->width - thick - 1 : x;

   int yy = y1*fImage->width;
   for (UInt_t y = y1; y <= y2; y++) {
      for (UInt_t w = 0; w < thick; w++) {
         if (x + w < fImage->width) {
            if ((iDash%2)==0) {
               _alphaBlend(&fImage->alt.argb32[yy + (x + w)], &color);
            }
         }
      }
      i++;

      if (i >= pDash[iDash]) {
         iDash++;
         i = 0;
      }
      if (iDash >= nDash) {
         iDash = 0;
         i = 0;
      }
      yy += fImage->width;
   }
}


//______________________________________________________________________________
void TASImage::DrawDashZLine(UInt_t x1, UInt_t y1, UInt_t x2, UInt_t y2,
                             UInt_t nDash, const char *tDash, UInt_t color)
{
   // Draw a dashed line with one pixel width.

   int dx, dy, d;
   int i, i1, i2;
   int x, y, xend, yend;
   int xdir, ydir;
   int q;
   UInt_t iDash = 0;    // index of current dash
   int yy;
   int idx;

   dx = TMath::Abs(Int_t(x2) - Int_t(x1));
   dy = TMath::Abs(Int_t(y2) - Int_t(y1));

   char *pDash = new char[nDash];

   if (dy <= dx) {
      double ac = TMath::Cos(TMath::ATan2(dy, dx));

      for (i = 0; i < (int)nDash; i++) {
         pDash[i] = TMath::Nint(tDash[i] * ac);
      }

      UInt_t ddy = dy << 1;
      i1 = ddy;
      i2 = i1 - (dx << 1);
      d = i1 - dx;
      i = 0;

      if (x1 > x2) {
         x = x2;
         y = y2;
         ydir = -1;
         xend = x1;
      } else {
         x = x1;
         y = y1;
         ydir = 1;
         xend = x2;
      }

      yy = y*fImage->width;
      _alphaBlend(&fImage->alt.argb32[y*fImage->width + x], &color);
      q = (y2 - y1) * ydir;

      if (q > 0) {
         while (x < xend) {
            idx = yy + x;
            if ((iDash%2) == 0) {
               _alphaBlend(&fImage->alt.argb32[idx], &color);
            }
            x++;
            if (d >= 0) {
               yy += fImage->width;
               d += i2;
            } else {
               d += i1;
            }

            i++;
            if (i >= pDash[iDash]) {
               iDash++;
               i = 0;
            }
            if (iDash >= nDash) {
               iDash = 0;
               i = 0;
            }
         }
      } else {
         while (x < xend) {
            idx = yy + x;
            if ((iDash%2) == 0) {
               _alphaBlend(&fImage->alt.argb32[idx], &color);
            }
            x++;
            if (d >= 0) {
               yy -= fImage->width;
               d += i2;
            } else {
               d += i1;
            }

            i++;
            if (i >= pDash[iDash]) {
               iDash++;
               i = 0;
            }
            if (iDash >= nDash) {
               iDash = 0;
               i = 0;
            }
         }
      }
   } else {
      double as = TMath::Sin(TMath::ATan2(dy, dx));

      for (i = 0; i < (int)nDash; i++) {
         pDash[i] = TMath::Nint(tDash[i] * as);
      }

      UInt_t ddx = dx << 1;
      i1 = ddx;
      i2 = i1 - (dy << 1);
      d = i1 - dy;
      i = 0;

      if (y1 > y2) {
         y = y2;
         x = x2;
         yend = y1;
         xdir = -1;
      } else {
         y = y1;
         x = x1;
         yend = y2;
         xdir = 1;
      }

      yy = y*fImage->width;
      _alphaBlend(&fImage->alt.argb32[y*fImage->width + x], &color);
      q = (x2 - x1) * xdir;

      if (q > 0) {
         while (y < yend) {
            idx = yy + x;
            if ((iDash%2) == 0) {
               _alphaBlend(&fImage->alt.argb32[idx], &color);
            }
            y++;
            yy += fImage->width;

            if (d >= 0) {
               x++;
               d += i2;
            } else {
               d += i1;
            }

            i++;
            if (i >= pDash[iDash]) {
               iDash++;
               i = 0;
            }
            if (iDash >= nDash) {
               iDash = 0;
               i = 0;
            }
         }
      } else {
         while (y < yend) {
            idx = yy + x;
            if ((iDash%2) == 0) {
               _alphaBlend(&fImage->alt.argb32[idx], &color);
            }
            y++;
            yy += fImage->width;

            if (d >= 0) {
               x--;
               d += i2;
            } else {
               d += i1;
            }

            i++;
            if (i >= pDash[iDash]) {
               iDash++;
               i = 0;
            }
            if (iDash >= nDash) {
               iDash = 0;
               i = 0;
            }
         }
      }
   }
   delete [] pDash;
}


//______________________________________________________________________________
void TASImage::DrawDashZTLine(UInt_t x1, UInt_t y1, UInt_t x2, UInt_t y2,
                             UInt_t nDash, const char *tDash, UInt_t color, UInt_t thick)
{
   // Draw a dashed line with thick pixel width.

   int dx, dy;
   int i;
   double x, y, xend=0, yend=0, x0, y0;
   int xdir, ydir;
   int q;
   UInt_t iDash = 0;    // index of current dash

   dx = TMath::Abs(Int_t(x2) - Int_t(x1));
   dy = TMath::Abs(Int_t(y2) - Int_t(y1));

   double *xDash = new double[nDash];
   double *yDash = new double[nDash];
   double a = TMath::ATan2(dy, dx);
   double ac = TMath::Cos(a);
   double as = TMath::Sin(a);

   for (i = 0; i < (int)nDash; i++) {
      xDash[i] = tDash[i] * ac;
      yDash[i] = tDash[i] * as;

      // dirty trick (must be fixed)
      if ((i%2) == 0) {
         xDash[i] = xDash[i]/2;
         yDash[i] = yDash[i]/2;
      } else {
         xDash[i] = xDash[i]*2;
         yDash[i] = yDash[i]*2;
      }
   }

   if (dy <= dx) {
      if (x1 > x2) {
         x = x2;
         y = y2;
         ydir = -1;
         xend = x1;
      } else {
         x = x1;
         y = y1;
         ydir = 1;
         xend = x2;
      }

      q = (y2 - y1) * ydir;
      x0 = x;
      y0 = y;
      iDash = 0;
      yend = y + q;

      if (q > 0) {
         while ((x < xend) && (y < yend)) {
            x += xDash[iDash];
            y += yDash[iDash];

            if ((iDash%2) == 0) {
              DrawWideLine(TMath::Nint(x0), TMath::Nint(y0),
                           TMath::Nint(x), TMath::Nint(y), color, thick);
            } else {
               x0 = x;
               y0 = y;
            }

            iDash++;

            if (iDash >= nDash) {
               iDash = 0;
            }
        }
      } else {
         while ((x < xend) && (y > yend)) {
            x += xDash[iDash];
            y -= yDash[iDash];

            if ((iDash%2) == 0) {
               DrawWideLine(TMath::Nint(x0), TMath::Nint(y0),
                            TMath::Nint(x), TMath::Nint(y), color, thick);
            } else {
               x0 = x;
               y0 = y;
            }

            iDash++;

            if (iDash >= nDash) {
               iDash = 0;
            }
         }
      }
   } else {

      if (y1 > y2) {
         y = y2;
         x = x2;
         yend = y1;
         xdir = -1;
      } else {
         y = y1;
         x = x1;
         yend = y2;
         xdir = 1;
      }

      q = (x2 - x1) * xdir;
      x0 = x;
      y0 = y;
      iDash = 0;
      xend = x + q;

      if (q > 0) {
         while ((x < xend) && (y < yend)) {
            x += xDash[iDash];
            y += yDash[iDash];

            if ((iDash%2) == 0) {
               DrawWideLine(TMath::Nint(x0), TMath::Nint(y0),
                            TMath::Nint(x), TMath::Nint(y), color, thick);
            } else {
               x0 = x;
               y0 = y;
            }

            iDash++;

            if (iDash >= nDash) {
               iDash = 0;
            }
         }
      } else {
         while ((x > xend) && (y < yend)) {
            x -= xDash[iDash];
            y += yDash[iDash];

            if ((iDash%2) == 0) {
               DrawWideLine(TMath::Nint(x0), TMath::Nint(y0),
                            TMath::Nint(x), TMath::Nint(y), color, thick);
            } else {
               x0 = x;
               y0 = y;
            }

            iDash++;

            if (iDash >= nDash) {
               iDash = 0;
            }
         }
      }
   }
   delete [] xDash;
   delete [] yDash;
}


//______________________________________________________________________________
void TASImage::DrawDashLine(UInt_t x1,  UInt_t y1, UInt_t x2, UInt_t y2, UInt_t nDash,
                            const char *pDash, const char *col, UInt_t thick)

{
   // Draw a dashed line.

   if (!InitVisual()) {
      Warning("DrawDashLine", "Visual not initiated");
      return;
   }

   if (!fImage) {
      Warning("DrawDashLine", "no image");
      return;
   }

   if (!fImage->alt.argb32) {
      BeginPaint();
   }

   if (!fImage->alt.argb32) {
      Warning("DrawDashLine", "Failed to get pixel array");
      return;
   }

   if ((nDash < 2) || !pDash || (nDash%2)) {
      Warning("DrawDashLine", "Wrong input parameters n=%d %ld", nDash, (Long_t)sizeof(pDash)-1);
      return;
   }

   ARGB32 color = ARGB32_White;
   parse_argb_color(col, &color);

   if (x1 == x2) {
      DrawDashVLine(x1, y1, y2, nDash, pDash, (UInt_t)color, thick);
   } else if (y1 == y2) {
      DrawDashHLine(y1, x1, x2, nDash, pDash, (UInt_t)color, thick);
   } else {
      if (thick < 2) DrawDashZLine(x1, y1, x2, y2, nDash, pDash, (UInt_t)color);
      else DrawDashZTLine(x1, y1, x2, y2, nDash, pDash, (UInt_t)color, thick);
   }
}


//______________________________________________________________________________
void TASImage::DrawPolyLine(UInt_t nn, TPoint *xy, const char *col, UInt_t thick,
                            TImage::ECoordMode mode)
{
   // Draw a polyline.

   ARGB32 color = ARGB32_White;
   parse_argb_color(col, &color);

   Int_t x0 = xy[0].GetX();
   Int_t y0 = xy[0].GetY();
   Int_t x = 0;
   Int_t y = 0;

   for (UInt_t i = 1; i < nn; i++) {
      x = (mode == kCoordModePrevious) ? x + xy[i].GetX() : xy[i].GetX();
      y = (mode == kCoordModePrevious) ? y + xy[i].GetY() : xy[i].GetY();

      DrawLineInternal(x0, y0, x, y, (UInt_t)color, thick);

      x0 = x;
      y0 = y;
   }
}


//______________________________________________________________________________
void TASImage::PutPixel(Int_t x, Int_t y, const char *col)
{
   // Draw a point at the specified position.

   if (!InitVisual()) {
      Warning("PutPixel", "Visual not initiated");
      return;
   }

   if (!fImage) {
      Warning("PutPixel", "no image");
      return;
   }

   if (!fImage->alt.argb32) {
      BeginPaint();
   }

   if (!fImage->alt.argb32) {
      Warning("PutPixel", "Failed to get pixel array");
      return;
   }

   ARGB32 color;
   parse_argb_color(col, &color);

   if ((x < 0) || (y < 0) || (x >= (int)fImage->width) || (y >= (int)fImage->height)) {
      Warning("PutPixel", "Out of range width=%d x=%d, height=%d y=%d",
               fImage->width, x, fImage->height, y);
      return;
   }
   _alphaBlend(&fImage->alt.argb32[y*fImage->width + x], &color);
}


//______________________________________________________________________________
void TASImage::PolyPoint(UInt_t npt, TPoint *ppt, const char *col, TImage::ECoordMode mode)
{
   // Draw a poly point.

   if (!InitVisual()) {
      Warning("PolyPoint", "Visual not initiated");
      return;
   }

   if (!fImage) {
      Warning("PolyPoint", "no image");
      return;
   }

   if (!fImage->alt.argb32) {
      BeginPaint();
   }

   if (!fImage->alt.argb32) {
      Warning("PolyPoint", "Failed to get pixel array");
      return;
   }

   if (!npt || !ppt) {
      Warning("PolyPoint", "No points specified");
      return;
   }

   TPoint *ipt = 0;
   UInt_t i = 0;
   ARGB32 color;
   parse_argb_color(col, &color);

   //make pointlist origin relative
   if (mode == kCoordModePrevious) {
      ipt = new TPoint[npt];

      for (i = 0; i < npt; i++) {
         ipt[i].fX += ppt[i].fX;
         ipt[i].fY += ppt[i].fY;
      }
   }
   int x, y;

   for (i = 0; i < npt; i++) {
      x = ipt ? ipt[i].fX : ppt[i].fX;
      y = ipt ? ipt[i].fY : ppt[i].fY;

      if ((x < 0) || (y < 0) || (x >= (int)fImage->width) || (y >= (int)fImage->height)) {
         continue;
      }
      _alphaBlend(&fImage->alt.argb32[y*fImage->width + x], &color);
   }

   if (ipt) {
      delete [] ipt;
   }
}


//______________________________________________________________________________
void TASImage::DrawSegments(UInt_t nseg, Segment_t *seg, const char *col, UInt_t thick)
{
   // Draw segments.

   if (!nseg || !seg) {
      Warning("DrawSegments", "Ivalid data nseg=%d seg=0x%lx", nseg, (Long_t)seg);
      return;
   }

   TPoint pt[2];

   for (UInt_t i = 0; i < nseg; i++) {
      pt[0].fX = seg->fX1;
      pt[1].fX = seg->fX2;
      pt[0].fY = seg->fY1;
      pt[1].fY = seg->fY2;

      DrawPolyLine(2, pt, col, thick, kCoordModeOrigin);
      seg++;
   }
}


//______________________________________________________________________________
void TASImage::FillSpans(UInt_t npt, TPoint *ppt, UInt_t *widths, const char *col,
                         const char *stipple, UInt_t w, UInt_t h)
{
   // Fill spans with specified color or/and stipple.

   if (!InitVisual()) {
      Warning("FillSpans", "Visual not initiated");
      return;
   }

   if (!fImage) {
      Warning("FillSpans", "no image");
      return;
   }

   if (!fImage->alt.argb32) {
      BeginPaint();
   }

   if (!fImage->alt.argb32) {
      Warning("FillSpans", "Failed to get pixel array");
      return;
   }

   if (!npt || !ppt || !widths || (stipple && (!w || !h))) {
      Warning("FillSpans", "Invalid input data npt=%d ppt=0x%lx col=%s widths=0x%lx stipple=0x%lx w=%d h=%d",
              npt, (Long_t)ppt, col, (Long_t)widths, (Long_t)stipple, w, h);
      return;
   }

   ARGB32 color;
   parse_argb_color(col, &color);
   Int_t idx = 0;
   UInt_t x = 0;
   UInt_t yy;

   for (UInt_t i = 0; i < npt; i++) {
      yy = ppt[i].fY*fImage->width;
      for (UInt_t j = 0; j < widths[i]; j++) {
         if ((ppt[i].fX >= (Int_t)fImage->width) || (ppt[i].fX < 0) ||
             (ppt[i].fY >= (Int_t)fImage->height) || (ppt[i].fY < 0)) continue;

         x = ppt[i].fX + j;
         idx = yy + x;

         if (!stipple) {
            _alphaBlend(&fImage->alt.argb32[idx], &color);
         } else {
            Int_t ii = (ppt[i].fY%h)*w + x%w;

            if (stipple[ii >> 3] & (1 << (ii%8))) {
               _alphaBlend(&fImage->alt.argb32[idx], &color);
            }
         }
      }
   }
}


//______________________________________________________________________________
void TASImage::FillSpans(UInt_t npt, TPoint *ppt, UInt_t *widths, TImage *tile)
{
   // Fill spans with tile image.

   if (!InitVisual()) {
      Warning("FillSpans", "Visual not initiated");
      return;
   }

   if (!fImage) {
      Warning("FillSpans", "no image");
      return;
   }

   if (!fImage->alt.argb32) {
      BeginPaint();
   }

   if (!fImage->alt.argb32) {
      Warning("FillSpans", "Failed to get pixel array");
      return;
   }

   if (!npt || !ppt || !widths || !tile) {
      Warning("FillSpans", "Invalid input data npt=%d ppt=0x%lx widths=0x%lx tile=0x%lx",
              npt, (Long_t)ppt, (Long_t)widths, (Long_t)tile);
      return;
   }

   Int_t idx = 0;
   Int_t ii = 0;
   UInt_t x = 0;
   UInt_t *arr = tile->GetArgbArray();
   if (!arr) return;
   UInt_t xx = 0;
   UInt_t yy = 0;
   UInt_t yyy = 0;

   for (UInt_t i = 0; i < npt; i++) {
      yyy = ppt[i].fY*fImage->width;

      for (UInt_t j = 0; j < widths[i]; j++) {
         if ((ppt[i].fX >= (Int_t)fImage->width) || (ppt[i].fX < 0) ||
             (ppt[i].fY >= (Int_t)fImage->height) || (ppt[i].fY < 0)) continue;
         x = ppt[i].fX + j;
         idx = yyy + x;
         xx = x%tile->GetWidth();
         yy = ppt[i].fY%tile->GetHeight();
         ii = yy*tile->GetWidth() + xx;
         _alphaBlend(&fImage->alt.argb32[idx], &arr[ii]);
      }
      yyy += fImage->width;;
   }
}


//______________________________________________________________________________
void TASImage::CropSpans(UInt_t npt, TPoint *ppt, UInt_t *widths)
{
   // Crop spans.

   if (!InitVisual()) {
      Warning("CropSpans", "Visual not initiated");
      return;
   }

   if (!fImage) {
      Warning("CropSpans", "no image");
      return;
   }

   if (!fImage->alt.argb32) {
      BeginPaint();
   }

   if (!fImage->alt.argb32) {
      Warning("CropSpans", "Failed to get pixel array");
      return;
   }

   if (!npt || !ppt || !widths) {
      Warning("CropSpans", "No points specified npt=%d ppt=0x%lx widths=0x%lx", npt, (Long_t)ppt, (Long_t)widths);
      return;
   }

   int y0 = ppt[0].fY;
   int y1 = ppt[npt-1].fY;
   UInt_t y = 0;
   UInt_t x = 0;
   UInt_t i = 0;
   UInt_t idx = 0;
   UInt_t sz = fImage->width*fImage->height;
   UInt_t yy = y*fImage->width;

   for (y = 0; (int)y < y0; y++) {
      for (x = 0; x < fImage->width; x++) {
         idx = yy + x;
         if (idx < sz) fImage->alt.argb32[idx] = 0;
      }
      yy += fImage->width;
   }

   for (i = 0; i < npt; i++) {
      for (x = 0; (int)x < ppt[i].fX; x++) {
         idx = ppt[i].fY*fImage->width + x;
         if (idx < sz) fImage->alt.argb32[idx] = 0;
      }
      for (x = ppt[i].fX + widths[i] + 1; x < fImage->width; x++) {
         idx = ppt[i].fY*fImage->width + x;
         if (idx < sz) fImage->alt.argb32[idx] = 0;
      }
   }

   yy = y1*fImage->width;
   for (y = y1; y < fImage->height; y++) {
      for (x = 0; x < fImage->width; x++) {
         idx = yy + x;
         if (idx < sz) fImage->alt.argb32[idx] = 0;
      }
      yy += fImage->width;
   }
}


//______________________________________________________________________________
void TASImage::CopyArea(TImage *dst, Int_t xsrc, Int_t ysrc, UInt_t w,  UInt_t h,
                        Int_t xdst, Int_t ydst, Int_t gfunc, EColorChan)
{
   // Copy source region to the destination image. Copy is done according
   // to specified function:
   //
   // enum EGraphicsFunction {
   //    kGXclear = 0,               // 0
   //    kGXand,                     // src AND dst
   //    kGXandReverse,              // src AND NOT dst
   //    kGXcopy,                    // src (default)
   //    kGXandInverted,             // NOT src AND dst
   //    kGXnoop,                    // dst
   //    kGXxor,                     // src XOR dst
   //    kGXor,                      // src OR dst
   //    kGXnor,                     // NOT src AND NOT dst
   //    kGXequiv,                   // NOT src XOR dst
   //    kGXinvert,                  // NOT dst
   //    kGXorReverse,               // src OR NOT dst
   //    kGXcopyInverted,            // NOT src
   //    kGXorInverted,              // NOT src OR dst
   //    kGXnand,                    // NOT src OR NOT dst
   //    kGXset                      // 1
   // };

   if (!InitVisual()) {
      Warning("CopyArea", "Visual not initiated");
      return;
   }

   if (!fImage) {
      Warning("CopyArea", "no image");
      return;
   }
   if (!dst) return;

   ASImage *out = ((TASImage*)dst)->GetImage();

   int x = 0;
   int y = 0;
   int idx = 0;
   int idx2 = 0;
   xsrc = xsrc < 0 ? 0 : xsrc;
   ysrc = ysrc < 0 ? 0 : ysrc;

   if ((xsrc >= (int)fImage->width) || (ysrc >= (int)fImage->height)) return;

   w = xsrc + w > fImage->width ? fImage->width - xsrc : w;
   h = ysrc + h > fImage->height ? fImage->height - ysrc : h;
   UInt_t yy = (ysrc + y)*fImage->width;

   if (!fImage->alt.argb32) {
      BeginPaint();
   }
   if (!out->alt.argb32) {
      dst->BeginPaint();
      out = ((TASImage*)dst)->GetImage();
   }

   if (fImage->alt.argb32 && out->alt.argb32) {
      for (y = 0; y < (int)h; y++) {
         for (x = 0; x < (int)w; x++) {
            idx = yy + x + xsrc;
            if ((x + xdst < 0) || (ydst + y < 0) ||
                (x + xdst >= (int)out->width) || (y + ydst >= (int)out->height) ) continue;

            idx2 = (ydst + y)*out->width + x + xdst;

            switch ((EGraphicsFunction)gfunc) {
               case kGXclear:
                  out->alt.argb32[idx2] = 0;
                  break;
               case kGXand:
                  out->alt.argb32[idx2] &= fImage->alt.argb32[idx];
                  break;
               case kGXandReverse:
                  out->alt.argb32[idx2] = fImage->alt.argb32[idx] & (~out->alt.argb32[idx2]);
                  break;
               case kGXandInverted:
                  out->alt.argb32[idx2] &= ~fImage->alt.argb32[idx];
                  break;
               case kGXnoop:
                  break;
               case kGXxor:
                  out->alt.argb32[idx2] ^= fImage->alt.argb32[idx];
                  break;
               case kGXor:
                  out->alt.argb32[idx2] |= fImage->alt.argb32[idx];
                  break;
               case kGXnor:
                  out->alt.argb32[idx2] = (~fImage->alt.argb32[idx]) & (~out->alt.argb32[idx2]);
                  break;
               case kGXequiv:
                  out->alt.argb32[idx2] ^= ~fImage->alt.argb32[idx];
                  break;
               case kGXinvert:
                  out->alt.argb32[idx2] = ~out->alt.argb32[idx2];
                  break;
               case kGXorReverse:
                  out->alt.argb32[idx2] = fImage->alt.argb32[idx] | (~out->alt.argb32[idx2]);
                  break;
               case kGXcopyInverted:
                  out->alt.argb32[idx2] = ~fImage->alt.argb32[idx];
                  break;
               case kGXorInverted:
                  out->alt.argb32[idx2] |= ~fImage->alt.argb32[idx];
                  break;
               case kGXnand:
                  out->alt.argb32[idx2] = (~fImage->alt.argb32[idx]) | (~out->alt.argb32[idx2]);
                  break;
               case kGXset:
                  out->alt.argb32[idx2] = 0xFFFFFFFF;
                  break;
               case kGXcopy:
               default:
                  out->alt.argb32[idx2] = fImage->alt.argb32[idx];
                  break;
            }
         }
         yy += fImage->width;
      }
   }
}


//______________________________________________________________________________
void TASImage::DrawCellArray(Int_t x1, Int_t y1, Int_t x2, Int_t y2, Int_t nx,
                             Int_t ny, UInt_t *ic)
{
   // Draw a cell array.
   // x1,y1        : left down corner
   // x2,y2        : right up corner
   // nx,ny        : array size
   // ic           : array of ARGB32 colors
   //
   // Draw a cell array. The drawing is done with the pixel presicion
   // if (X2-X1)/NX (or Y) is not a exact pixel number the position of
   // the top rigth corner may be wrong.

   int i, j, ix, iy, w, h;

   ARGB32 color = 0xFFFFFFFF;
   ARGB32 icol;

   w  = TMath::Max((x2-x1)/(nx),1);
   h  = TMath::Max((y1-y2)/(ny),1);
   ix = x1;

   for (i = 0; i < nx; i++) {
      iy = y1 - h;
      for (j = 0; j < ny; j++) {
         icol = (ARGB32)ic[i + (nx*j)];
         if (icol != color) {
            color = icol;
         }
         FillRectangleInternal((UInt_t)color, ix, iy, w, h);
         iy = iy - h;
      }
      ix = ix + w;
   }
}


//______________________________________________________________________________
UInt_t TASImage::AlphaBlend(UInt_t bot, UInt_t top)
{
   // Return alphablended value computed from bottom and top pixel values.

   UInt_t ret = bot;

   _alphaBlend(&ret, &top);
   return ret;
}


//______________________________________________________________________________
const ASVisual *TASImage::GetVisual()
{
   // Return visual.

   return fgVisual;
}


//______________________________________________________________________________
static int GetPolyYBounds(TPoint *pts, int n, int *by, int *ty)
{
   // Get poly bounds along Y.

   TPoint *ptMin;
   int ymin, ymax;
   TPoint *ptsStart = pts;

   ptMin = pts;
   ymin = ymax = (pts++)->fY;

   while (--n > 0) {
      if (pts->fY < ymin) {
         ptMin = pts;
         ymin = pts->fY;
      }
      if (pts->fY > ymax) {
         ymax = pts->fY;
      }
      pts++;
    }

    *by = ymin;
    *ty = ymax;
    return (ptMin - ptsStart);
}


//______________________________________________________________________________
Bool_t TASImage::GetPolygonSpans(UInt_t npt, TPoint *ppt, UInt_t *nspans,
                                 TPoint **outPoint, UInt_t **outWidth)
{
   // The code is based on Xserver/mi/mipolycon.c
   //    "Copyright 1987, 1998  The Open Group"

   int xl = 0;                   // x vals of leftedges
   int xr = 0;                   // x vals of right edges
   int dl = 0;                   // decision variables
   int dr = 0;                   // decision variables
   int ml = 0;                   // left edge slope
   int m1l = 0;                  // left edge slope+1
   int mr = 0, m1r = 0;          // right edge slope and slope+1
   int incr1l = 0, incr2l = 0;   // left edge error increments
   int incr1r = 0, incr2r = 0;   // right edge error increments
   int dy;                       // delta y
   int y;                        // current scanline
   int left, right;              // indices to first endpoints
   int i;                        // loop counter
   int nextleft, nextright;      // indices to second endpoints
   TPoint *ptsOut;               // output buffer
   UInt_t *width;                // output buffer
   TPoint *firstPoint=0;
   UInt_t *firstWidth=0;
   int imin;                     // index of smallest vertex (in y)
   int ymin;                     // y-extents of polygon
   int ymax;
   Bool_t  ret = kTRUE;

   *nspans = 0;

   if (!InitVisual()) {
      Warning("GetPolygonSpans", "Visual not initiated");
      return kFALSE;
   }

   if (!fImage) {
      Warning("GetPolygonSpans", "no image");
      return kFALSE;
   }

   if (!fImage->alt.argb32) {
      BeginPaint();
   }

   if (!fImage->alt.argb32) {
      Warning("GetPolygonSpans", "Failed to get pixel array");
      return kFALSE;
   }

   if ((npt < 3) || !ppt) {
      Warning("GetPolygonSpans", "No points specified npt=%d ppt=0x%lx", npt, (Long_t)ppt);
      return kFALSE;
   }

   //  find leftx, bottomy, rightx, topy, and the index
   //  of bottomy. Also translate the points.
   imin = GetPolyYBounds(ppt, npt, &ymin, &ymax);

   dy = ymax - ymin + 1;
   if ((npt < 3) || (dy < 0)) return kFALSE;

   ptsOut = firstPoint = new TPoint[dy];
   width = firstWidth = new UInt_t[dy];
   ret = kTRUE;

   nextleft = nextright = imin;
   y = ppt[nextleft].fY;

   //  loop through all edges of the polygon
   do {
      // add a left edge if we need to
      if (ppt[nextleft].fY == y) {
         left = nextleft;

         //  find the next edge, considering the end
         //  conditions of the array.
         nextleft++;
         if (nextleft >= (int)npt) {
            nextleft = 0;
         }

         // now compute all of the random information
         // needed to run the iterative algorithm.
         BRESINITPGON(ppt[nextleft].fY - ppt[left].fY,
                      ppt[left].fX, ppt[nextleft].fX,
                      xl, dl, ml, m1l, incr1l, incr2l);
      }

      // add a right edge if we need to
      if (ppt[nextright].fY == y) {
         right = nextright;

         // find the next edge, considering the end
         // conditions of the array.
         nextright--;
         if (nextright < 0) {
            nextright = npt-1;
         }

         //  now compute all of the random information
         //  needed to run the iterative algorithm.
         BRESINITPGON(ppt[nextright].fY - ppt[right].fY,
                      ppt[right].fX, ppt[nextright].fX,
                      xr, dr, mr, m1r, incr1r, incr2r);
      }

      // generate scans to fill while we still have
      //  a right edge as well as a left edge.
      i = TMath::Min(ppt[nextleft].fY, ppt[nextright].fY) - y;

      // in case of non-convex polygon
      if (i < 0) {
         delete [] firstWidth;
         delete [] firstPoint;
         return kTRUE;
      }

      while (i-- > 0)  {
         ptsOut->fY = y;

         // reverse the edges if necessary
         if (xl < xr) {
            *(width++) = xr - xl;
            (ptsOut++)->fX = xl;
         } else {
            *(width++) = xl - xr;
            (ptsOut++)->fX = xr;
         }
         y++;

         // increment down the edges
         BRESINCRPGON(dl, xl, ml, m1l, incr1l, incr2l);
         BRESINCRPGON(dr, xr, mr, m1r, incr1r, incr2r);
      }
   }  while (y != ymax);

   *nspans = UInt_t(ptsOut - firstPoint);
   *outPoint = firstPoint;
   *outWidth = firstWidth;

   return ret;
}


//______________________________________________________________________________
void TASImage::FillPolygon(UInt_t npt, TPoint *ppt, const char *col,
                           const char *stipple, UInt_t w, UInt_t h)
{
   // Fill a convex polygon with background color or bitmap.
   // For non convex polygon one must use DrawFillArea method

   UInt_t  nspans = 0;
   TPoint *firstPoint = 0;   // output buffer
   UInt_t *firstWidth = 0;   // output buffer

   Bool_t del = GetPolygonSpans(npt, ppt, &nspans, &firstPoint, &firstWidth);
   ARGB32 color = ARGB32_White;
   parse_argb_color(col, &color);

   if (nspans) {
      if (!stipple && ((color & 0xff000000)==0xff000000)) { //no stipple no alpha
         FillSpansInternal(nspans, firstPoint, firstWidth, color);
      } else {
         FillSpans(nspans, firstPoint, firstWidth, col, stipple, w, h);
      }

      if (del) {
         delete [] firstWidth;
         delete [] firstPoint;
      }
   } else {
      if (firstWidth) delete [] firstWidth;
      if (firstPoint) delete [] firstPoint;
   }
}


//______________________________________________________________________________
void TASImage::FillPolygon(UInt_t npt, TPoint *ppt, TImage *tile)
{
   // Fill a convex polygon with background image.
   // For non convex polygon one must use DrawFillArea method

   UInt_t  nspans = 0;
   TPoint *firstPoint = 0;   // output buffer
   UInt_t *firstWidth = 0;   // output buffer

   Bool_t del = GetPolygonSpans(npt, ppt, &nspans, &firstPoint, &firstWidth);

   if (nspans) {
      FillSpans(nspans, firstPoint, firstWidth, tile);

      if (del) {
         delete [] firstWidth;
         delete [] firstPoint;
      }
   } else {
      if (firstWidth) delete [] firstWidth;
      if (firstPoint) delete [] firstPoint;
   }
}


//______________________________________________________________________________
void TASImage::CropPolygon(UInt_t npt, TPoint *ppt)
{
   // Crop a convex polygon.

   UInt_t  nspans = 0;
   TPoint *firstPoint = 0;
   UInt_t *firstWidth = 0;

   Bool_t del = GetPolygonSpans(npt, ppt, &nspans, &firstPoint, &firstWidth);

   if (nspans) {
      CropSpans(nspans, firstPoint, firstWidth);

      if (del) {
         delete [] firstWidth;
         delete [] firstPoint;
      }
   } else {
         if (firstWidth) delete [] firstWidth;
         if (firstPoint) delete [] firstPoint;
   }
}

static const UInt_t NUMPTSTOBUFFER = 512;


//______________________________________________________________________________
void TASImage::DrawFillArea(UInt_t count, TPoint *ptsIn, const char *col,
                           const char *stipple, UInt_t w, UInt_t h)
{
   // Fill a polygon (any type convex, non-convex).

   if (!InitVisual()) {
      Warning("DrawFillArea", "Visual not initiated");
      return;
   }

   if (!fImage) {
      Warning("DrawFillArea", "no image");
      return;
   }

   if (!fImage->alt.argb32) {
      BeginPaint();
   }

   if (!fImage->alt.argb32) {
      Warning("DrawFillArea", "Failed to get pixel array");
      return;
   }

   if ((count < 3) || !ptsIn) {
      Warning("DrawFillArea", "No points specified npt=%d ppt=0x%lx", count, (Long_t)ptsIn);
      return;
   }

   if (count < 5) {
      FillPolygon(count, ptsIn, col, stipple, w, h);
      return;
   }

   ARGB32 color = ARGB32_White;
   parse_argb_color(col, &color);

   EdgeTableEntry *pAET;  // the Active Edge Table
   int y;                 // the current scanline
   UInt_t nPts = 0;          // number of pts in buffer

   ScanLineList *pSLL;   // Current ScanLineList
   TPoint *ptsOut;       // ptr to output buffers
   UInt_t *width;
   TPoint firstPoint[NUMPTSTOBUFFER];  // the output buffers
   UInt_t firstWidth[NUMPTSTOBUFFER];
   EdgeTableEntry *pPrevAET;       // previous AET entry
   EdgeTable ET;                   // Edge Table header node
   EdgeTableEntry AET;             // Active ET header node
   EdgeTableEntry *pETEs;          // Edge Table Entries buff
   ScanLineListBlock SLLBlock;     // header for ScanLineList
   Bool_t del = kTRUE;

   static const UInt_t gEdgeTableEntryCacheSize = 200;
   static EdgeTableEntry gEdgeTableEntryCache[gEdgeTableEntryCacheSize];

   if (count < gEdgeTableEntryCacheSize) {
      pETEs = (EdgeTableEntry*)&gEdgeTableEntryCache;
      del = kFALSE;
   } else {
      pETEs = new EdgeTableEntry[count];
      del = kTRUE;
   }

   ptsOut = firstPoint;
   width = firstWidth;
   CreateETandAET(count, ptsIn, &ET, &AET, pETEs, &SLLBlock);
   pSLL = ET.scanlines.next;

   for (y = ET.ymin; y < ET.ymax; y++) {
      if (pSLL && y == pSLL->scanline) {
         loadAET(&AET, pSLL->edgelist);
         pSLL = pSLL->next;
      }
      pPrevAET = &AET;
      pAET = AET.next;

      while (pAET) {
         ptsOut->fX = pAET->bres.minor_axis;
         ptsOut->fY = y;
         ptsOut++;
         nPts++;

         *width++ = pAET->next->bres.minor_axis - pAET->bres.minor_axis;

         if (nPts == NUMPTSTOBUFFER) {
            if (!stipple && ((color & 0xff000000)==0xff000000)) { //no stipple, no alpha
               FillSpansInternal(nPts, firstPoint, firstWidth, color);
            } else {
               FillSpans(nPts, firstPoint, firstWidth, col, stipple, w, h);
            }
            ptsOut = firstPoint;
            width = firstWidth;
            nPts = 0;
         }
         EVALUATEEDGEEVENODD(pAET, pPrevAET, y)
         EVALUATEEDGEEVENODD(pAET, pPrevAET, y)
      }
      InsertionSort(&AET);
   }

   if (nPts) {
      if (!stipple && ((color & 0xff000000)==0xff000000)) {  //no stipple, no alpha
         FillSpansInternal(nPts, firstPoint, firstWidth, color);
      } else {
         FillSpans(nPts, firstPoint, firstWidth, col, stipple, w, h);
      }
   }

   if (del) delete [] pETEs;
   FreeStorage(SLLBlock.next);
}


//______________________________________________________________________________
void TASImage::DrawFillArea(UInt_t count, TPoint *ptsIn, TImage *tile)
{
   // Fill a polygon (any type convex, non-convex).

   if (!InitVisual()) {
      Warning("DrawFillArea", "Visual not initiated");
      return;
   }

   if (!fImage) {
      Warning("DrawFillArea", "no image");
      return;
   }

   if (!fImage->alt.argb32) {
      BeginPaint();
   }

   if (!fImage->alt.argb32) {
      Warning("DrawFillArea", "Failed to get pixel array");
      return;
   }

   if ((count < 3) || !ptsIn) {
      Warning("DrawFillArea", "No points specified npt=%d ppt=0x%lx", count, (Long_t)ptsIn);
      return;
   }

   if (count < 5) {
      FillPolygon(count, ptsIn, tile);
      return;
   }

   EdgeTableEntry *pAET;   // the Active Edge Table
   int y;                  // the current scanline
   UInt_t nPts = 0;       // number of pts in buffer

   ScanLineList *pSLL;    // Current ScanLineList
   TPoint *ptsOut;        // ptr to output buffers
   UInt_t *width;
   TPoint firstPoint[NUMPTSTOBUFFER]; // the output buffers
   UInt_t firstWidth[NUMPTSTOBUFFER];
   EdgeTableEntry *pPrevAET;       // previous AET entry
   EdgeTable ET;                   // Edge Table header node
   EdgeTableEntry AET;             // Active ET header node
   EdgeTableEntry *pETEs;          // Edge Table Entries buff
   ScanLineListBlock SLLBlock;     // header for ScanLineList

   pETEs = new EdgeTableEntry[count];

   ptsOut = firstPoint;
   width = firstWidth;
   CreateETandAET(count, ptsIn, &ET, &AET, pETEs, &SLLBlock);
   pSLL = ET.scanlines.next;

   for (y = ET.ymin; y < ET.ymax; y++) {
      if (pSLL && y == pSLL->scanline) {
         loadAET(&AET, pSLL->edgelist);
         pSLL = pSLL->next;
      }
      pPrevAET = &AET;
      pAET = AET.next;

      while (pAET) {
         ptsOut->fX = pAET->bres.minor_axis;
         ptsOut->fY = y;
         ptsOut++;
         nPts++;

         *width++ = pAET->next->bres.minor_axis - pAET->bres.minor_axis;

         if (nPts == NUMPTSTOBUFFER) {
            FillSpans(nPts, firstPoint, firstWidth, tile);
            ptsOut = firstPoint;
            width = firstWidth;
            nPts = 0;
         }
         EVALUATEEDGEEVENODD(pAET, pPrevAET, y)
         EVALUATEEDGEEVENODD(pAET, pPrevAET, y)
      }
      InsertionSort(&AET);
   }
   FillSpans(nPts, firstPoint, firstWidth, tile);

   delete [] pETEs;
   FreeStorage(SLLBlock.next);
}


//______________________________________________________________________________
static ASDrawContext *create_draw_context_argb32(ASImage *im, ASDrawTool *brush)
{
   // Create draw context.

   ASDrawContext *ctx = new ASDrawContext;

   ctx->canvas_width = im->width;
   ctx->canvas_height = im->height;
   ctx->canvas = im->alt.argb32;
   ctx->scratch_canvas = 0;

   ctx->flags = ASDrawCTX_CanvasIsARGB;
   asim_set_custom_brush_colored( ctx, brush);
   return ctx;
}


//______________________________________________________________________________
static void destroy_asdraw_context32( ASDrawContext *ctx )
{
   // Destroy asdraw context32.

   if (ctx) {
      if (ctx->scratch_canvas) free(ctx->scratch_canvas);
      delete ctx;
   }
}

static const UInt_t kBrushCacheSize = 20;
static CARD32 gBrushCache[kBrushCacheSize*kBrushCacheSize];


//______________________________________________________________________________
void TASImage::DrawWideLine(UInt_t x1, UInt_t y1, UInt_t x2, UInt_t y2,
                            UInt_t color, UInt_t thick)
{
   // Draw wide line.

   Int_t sz = thick*thick;
   CARD32 *matrix;
   Bool_t use_cache = thick < kBrushCacheSize;

   if (use_cache) {
      matrix = gBrushCache;
   } else {
      matrix = new CARD32[sz];
   }

   for (int i = 0; i < sz; i++) {
      matrix[i] = (CARD32)color;
   };

   ASDrawTool brush;
   brush.matrix = matrix;
   brush.width = thick;
   brush.height = thick;
   brush.center_y = brush.center_x = thick/2;

   ASDrawContext *ctx = create_draw_context_argb32(fImage, &brush);
   asim_move_to(ctx, x1, y1);
   asim_line_to(ctx, x2, y2);

   if (!use_cache) {
      delete [] matrix;
   }
   destroy_asdraw_context32(ctx);
}


//______________________________________________________________________________
void TASImage::DrawGlyph(void *bitmap, UInt_t color, Int_t bx, Int_t by)
{
   // Draw glyph bitmap.

   static UInt_t col[5];
   Int_t x, y, yy, y0, xx;

   ULong_t r, g, b;
   int idx = 0;
   FT_Bitmap *source = (FT_Bitmap*)bitmap;
   UChar_t d = 0, *s = source->buffer;

   Int_t dots = Int_t(source->width * source->rows);
   r = g = b = 0;
   Int_t bxx, byy;

   yy = y0 = by > 0 ? by * fImage->width : 0;
   for (y = 0; y < (int) source->rows; y++) {
      byy = by + y;
      if ((byy >= (int)fImage->height) || (byy <0)) continue;

      for (x = 0; x < (int) source->width; x++) {
         bxx = bx + x;
         if ((bxx >= (int)fImage->width) || (bxx < 0)) continue;

         idx = bxx + yy;
         r += ((fImage->alt.argb32[idx] & 0xff0000) >> 16);
         g += ((fImage->alt.argb32[idx] & 0x00ff00) >> 8);
         b += (fImage->alt.argb32[idx] & 0x0000ff);
      }
      yy += fImage->width;
   }
   if (dots != 0) {
      r /= dots;
      g /= dots;
      b /= dots;
   }

   col[0] = (r << 16) + (g << 8) + b;
   col[4] = color;
   Int_t col4r = (col[4] & 0xff0000) >> 16;
   Int_t col4g = (col[4] & 0x00ff00) >> 8;
   Int_t col4b = (col[4] & 0x0000ff);

   // interpolate between fore and backgound colors
   for (x = 3; x > 0; x--) {
      xx = 4-x;
      Int_t colxr = (col4r*x + r*xx) >> 2;
      Int_t colxg = (col4g*x + g*xx) >> 2;
      Int_t colxb = (col4b*x + b*xx) >> 2;
      col[x] = (colxr << 16) + (colxg << 8) + colxb;
   }

   yy = y0;
   for (y = 0; y < (int) source->rows; y++) {
      byy = by + y;
      if ((byy >= (int)fImage->height) || (byy <0)) continue;

      for (x = 0; x < (int) source->width; x++) {
         bxx = bx + x;
         //if ((bxx >= (int)fImage->width) || (bxx < 0)) continue;

         d = *s++ & 0xff;
         d = ((d + 10) * 5) >> 8;
         if (d > 4) d = 4;

         if (d && (x < (int) source->width) && (bxx < (int)fImage->width) && (bxx >= 0)) {
            idx = bxx + yy;
            fImage->alt.argb32[idx] = (ARGB32)col[d];
         }
      }
      yy += fImage->width;
   }
}


//______________________________________________________________________________
void TASImage::DrawText(TText *text, Int_t x, Int_t y)
{
   // Draw text at the pixel position (x,y).

   if (!text)   return;
   if (!fImage) return;
   if (!gPad)   return;

   if (!InitVisual()) {
      Warning("DrawText", "Visual not initiated");
      return;
   }

   if (!fImage->alt.argb32) {
      BeginPaint();
   }

   if (!TTF::IsInitialized()) TTF::Init();

   // set text font
   TTF::SetTextFont(text->GetTextFont());

   Int_t wh = gPad->XtoPixel(gPad->GetX2());
   Int_t hh = gPad->YtoPixel(gPad->GetY1());

   // set text size
   Float_t ttfsize;
   if (wh < hh) {
      ttfsize = text->GetTextSize()*wh;
   } else {
      ttfsize = text->GetTextSize()*hh;
   }
   TTF::SetTextSize(ttfsize);

   // set text angle
   TTF::SetRotationMatrix(text->GetTextAngle());

   // set text
   const wchar_t *wcsTitle = reinterpret_cast<const wchar_t *>(text->GetWcsTitle());
   if (wcsTitle != NULL) {
      TTF::PrepareString(wcsTitle);
   } else {
      TTF::PrepareString(text->GetTitle());
   }
   TTF::LayoutGlyphs();

   // color
   TColor *col = gROOT->GetColor(text->GetTextColor());
   if (!col) { // no color, make it black
      col = gROOT->GetColor(1);
      if (!col) return;
   }
   ARGB32 color = ARGB32_White;
   parse_argb_color(col->AsHexString(), &color);

   // Align()
   Int_t align = 0;
   Int_t txalh = text->GetTextAlign()/10;
   Int_t txalv = text->GetTextAlign()%10;

   switch (txalh) {
      case 0 :
      case 1 :
         switch (txalv) {  //left
            case 1 :
               align = 7;   //bottom
               break;
            case 2 :
               align = 4;   //center
               break;
            case 3 :
               align = 1;   //top
               break;
         }
         break;
      case 2 :
         switch (txalv) { //center
            case 1 :
               align = 8;   //bottom
               break;
            case 2 :
               align = 5;   //center
               break;
            case 3 :
               align = 2;   //top
               break;
         }
         break;
      case 3 :
         switch (txalv) {  //right
            case 1 :
               align = 9;   //bottom
               break;
            case 2 :
               align = 6;   //center
               break;
            case 3 :
               align = 3;   //top
               break;
         }
         break;
   }

   FT_Vector ftal;

   // vertical alignment
   if (align == 1 || align == 2 || align == 3) {
      ftal.y = TTF::GetAscent();
   } else if (align == 4 || align == 5 || align == 6) {
      ftal.y = TTF::GetAscent()/2;
   } else {
      ftal.y = 0;
   }

   // horizontal alignment
   if (align == 3 || align == 6 || align == 9) {
      ftal.x = TTF::GetWidth();
   } else if (align == 2 || align == 5 || align == 8) {
      ftal.x = TTF::GetWidth()/2;
   } else {
      ftal.x = 0;
   }

   FT_Vector_Transform(&ftal, TTF::GetRotMatrix());
   ftal.x = (ftal.x >> 6);
   ftal.y = (ftal.y >> 6);

   TTGlyph *glyph = TTF::GetGlyphs();

   for (int n = 0; n < TTF::GetNumGlyphs(); n++, glyph++) {
      if (FT_Glyph_To_Bitmap(&glyph->fImage, ft_render_mode_normal, 0, 1 )) continue;

      FT_BitmapGlyph bitmap = (FT_BitmapGlyph)glyph->fImage;
      FT_Bitmap *source = &bitmap->bitmap;

      Int_t bx = x - ftal.x + bitmap->left;
      Int_t by = y + ftal.y - bitmap->top;

      DrawGlyph(source, color, bx, by);
   }
}


//______________________________________________________________________________
void TASImage::DrawTextTTF(Int_t x, Int_t y, const char *text, Int_t size,
                           UInt_t color, const char *font_name, Float_t angle)
{
   // Draw text using TrueType fonts.

   if (!TTF::IsInitialized()) TTF::Init();

   TTF::SetTextFont(font_name);
   TTF::SetTextSize(size);
   TTF::SetRotationMatrix(angle);
   TTF::PrepareString(text);
   TTF::LayoutGlyphs();

   TTGlyph *glyph = TTF::GetGlyphs();

   // compute the size and position  that will contain the text
   // Int_t Xoff = 0; if (TTF::GetBox().xMin < 0) Xoff = -TTF::GetBox().xMin;
   Int_t Yoff = 0; if (TTF::GetBox().yMin < 0) Yoff = -TTF::GetBox().yMin;
   Int_t h    = TTF::GetBox().yMax + Yoff;

   for (int n = 0; n < TTF::GetNumGlyphs(); n++, glyph++) {
      if (FT_Glyph_To_Bitmap(&glyph->fImage, ft_render_mode_normal, 0, 1 )) continue;

      FT_BitmapGlyph bitmap = (FT_BitmapGlyph)glyph->fImage;
      FT_Bitmap *source = &bitmap->bitmap;

      Int_t bx = x + bitmap->left;
      Int_t by = y + h - bitmap->top;
      DrawGlyph(source, color, bx, by);
   }
}


//______________________________________________________________________________
void TASImage::GetImageBuffer(char **buffer, int *size, EImageFileTypes type)
{
   // Return in-memory buffer compressed according image type.
   // Buffer must be deallocated after usage.
   // This method can be used for sending images over network.

   static ASImageExportParams params;
   Bool_t ret = kFALSE;
   int   isize = 0;
   char *ibuff = 0;
   ASImage *img = fScaledImage ? fScaledImage->fImage : fImage;

   if (!img) return;

   switch (type) {
      case TImage::kXpm:
         ret = ASImage2xpmRawBuff(img, (CARD8 **)buffer, size, 0);
         break;
      default:
         ret = ASImage2PNGBuff(img, (CARD8 **)buffer, size, &params);
   }

   if (!ret) {
      *size = isize;
      *buffer = ibuff;
   }
}


//______________________________________________________________________________
Bool_t TASImage::SetImageBuffer(char **buffer, EImageFileTypes type)
{
   // Create image from compressed buffer.
   // Supported formats:
   //
   //    PNG - by default
   //    XPM - two options exist:
   //      1.  xpm as a single string (raw buffer). Such string
   //          is returned by GetImageBuffer method.
   //
   //    For example:
   //       char *buf;
   //       int sz;
   //       im1->GetImageBuffer(&buf, &int, TImage::kXpm); /*raw buffer*/
   //       TImage *im2 = TImage::Create();
   //       im2->SetImageBuffer(&buf, TImage::kXpm);
   //
   //      2.  xpm as an array of strigs (preparsed)
   //
   //    For example:
   //       char *xpm[] = {
   //          "64 28 58 1",
   //          "  c #0A030C",
   //          ". c #1C171B"
   //             ...
   //    TImage *im = TImage::Create();
   //    im->SetImageBuffer(xpm, TImage::kXpm);

   DestroyImage();

   static ASImageImportParams params;
   params.flags = 0;
   params.width = 0;
   params.height = 0 ;
   params.filter = SCL_DO_ALL;
   params.gamma = 0;
   params.gamma_table = 0;
   params.compression = 0;
   params.format = ASA_ASImage;
   params.search_path = 0;
   params.subimage = 0;

   switch (type) {
      case TImage::kXpm:
      {
         char *ptr = buffer[0];
         while (isspace((int)*ptr)) ++ptr;
         if (atoi(ptr)) {  // preparsed and preloaded data
            fImage = xpm_data2ASImage((const char**)buffer, &params);
         } else {
            fImage = xpmRawBuff2ASImage((const char*)*buffer, &params);
         }
         break;
      }
      default:
         fImage = PNGBuff2ASimage((CARD8 *)*buffer, &params);
         break;
   }

   if (!fImage) {
      return kFALSE;
   }

   if (fName.IsNull()) {
      fName.Form("img_%dx%d.%d", fImage->width, fImage->height, gRandom->Integer(1000));
   }
   UnZoom();
   return kTRUE;
}


//______________________________________________________________________________
void TASImage::CreateThumbnail()
{
   // Create image thumbnail.

   int size;
   const int sz = 64;

   if (!fImage) {
      return;
   }

   if (!InitVisual()) {
      return;
   }

   static char *buf = 0;
   int w, h;
   ASImage *img = 0;

   if (fImage->width > fImage->height) {
      w = sz;
      h = (fImage->height*sz)/fImage->width;
   } else {
      h = sz;
      w = (fImage->width*sz)/fImage->height;
   }

   w = w < 8 ? 8 : w;
   h = h < 8 ? 8 : h;

   img = scale_asimage(fgVisual, fImage, w, h, ASA_ASImage,
                       GetImageCompression(), GetImageQuality());
   if (!img) {
      return;
   }

   // contrasing
   ASImage *rendered_im;
   ASImageLayer layers[2];
   init_image_layers(&(layers[0]), 2);
   layers[0].im = img;
   layers[0].dst_x = 0;
   layers[0].dst_y = 0;
   layers[0].clip_width = img->width;
   layers[0].clip_height = img->height;
   layers[0].bevel = 0;
   layers[1].im = img;
   layers[1].dst_x = 0;
   layers[1].dst_y = 0;
   layers[1].clip_width = img->width;
   layers[1].clip_height = img->height;
   layers[1].merge_scanlines = blend_scanlines_name2func("tint");
   rendered_im = merge_layers(fgVisual, &(layers[0]), 2, img->width, img->height,
                              ASA_ASImage, GetImageCompression(), GetImageQuality());
   destroy_asimage(&img);
   img = rendered_im;

   // pad image
   ASImage *padimg = 0;
   int d = 0;

   if (w == sz) {
      d = (sz - h) >> 1;
      padimg = pad_asimage(fgVisual, img, 0, d, sz, sz, 0x00ffffff,
                           ASA_ASImage, GetImageCompression(), GetImageQuality());
   } else {
      d = (sz - w) >> 1;
      padimg = pad_asimage(fgVisual, img, d, 0, sz, sz, 0x00ffffff,
                           ASA_ASImage, GetImageCompression(), GetImageQuality());
   }

   if (!padimg) {
      destroy_asimage(&img);
      return;
   }

   void *ptr = &buf;
   ASImage2xpmRawBuff(padimg, (CARD8 **)ptr, &size, 0);
   fTitle = buf;

   destroy_asimage(&padimg);
}


//______________________________________________________________________________
void TASImage::Streamer(TBuffer &b)
{
   // Streamer for ROOT I/O.

   Bool_t image_type = 0;
   char *buffer = 0;
   int size = 0;
   int w, h;
   UInt_t R__s, R__c;

   if (b.IsReading()) {
      Version_t version = b.ReadVersion(&R__s, &R__c);
      if (version == 0) { //dumb prototype for scheema evolution
         return;
      }

      if ( version == 1 ) {
         Int_t fileVersion = b.GetVersionOwner();
         if (fileVersion > 0 && fileVersion < 50000 ) {
            TImage::Streamer(b);
            b >> fMaxValue;
            b >> fMinValue;
            b >> fZoomOffX;
            b >> fZoomOffY;
            b >> fZoomWidth;
            b >> fZoomHeight;
            if ( fileVersion < 40200 ) {
               Bool_t zoomUpdate;
               b >> zoomUpdate;
               fZoomUpdate = zoomUpdate;
            } else {
               b >> fZoomUpdate;
               b >> fEditable;
               Bool_t paintMode;
               b >> paintMode;
               fPaintMode = paintMode;
            }
            b.CheckByteCount(R__s, R__c, TASImage::IsA());
            return;
         }
      }

      TNamed::Streamer(b);
      b >> image_type;

      if (image_type != 0) {     // read PNG compressed image
         b >> size;
         buffer = new char[size];
         b.ReadFastArray(buffer, size);
         SetImageBuffer(&buffer, TImage::kPng);
         delete [] buffer;
      } else {                   // read vector with palette
         TAttImage::Streamer(b);
         b >> w;
         b >> h;
         size = w*h;
         Double_t *vec = new Double_t[size];
         b.ReadFastArray(vec, size);
         SetImage(vec, w, h, &fPalette);
         delete [] vec;
      }
      b.CheckByteCount(R__s, R__c, TASImage::IsA());
   } else {
      if (!fImage) {
         return;
      }
      R__c = b.WriteVersion(TASImage::IsA(), kTRUE);

      if (fName.IsNull()) {
         fName.Form("img_%dx%d.%d", fImage->width, fImage->height, gRandom->Integer(1000));
      }
      TNamed::Streamer(b);

      image_type = fImage->alt.vector ? 0 : 1;
      b << image_type;

      if (image_type != 0) {     // write PNG compressed image
         GetImageBuffer(&buffer, &size, TImage::kPng);
         b << size;
         b.WriteFastArray(buffer, size);
         delete buffer;
      } else {                   // write vector  with palette
         TAttImage::Streamer(b);
         b << fImage->width;
         b << fImage->height;
         b.WriteFastArray(fImage->alt.vector, fImage->width*fImage->height);
      }
      b.SetByteCount(R__c, kTRUE);
   }
}


//______________________________________________________________________________
void TASImage::Browse(TBrowser *)
{
   // Browse image.

   if (fImage->alt.vector) {
      Draw("n");
   } else {
      Draw("nxxx");
   }
   CreateThumbnail();
}


//______________________________________________________________________________
const char *TASImage::GetTitle() const
{
   // Title is used to keep 32x32 xpm image's thumbnail.

   if (!gDirectory || !gDirectory->IsWritable()) {
      return 0;
   }

   TASImage *mutble = (TASImage *)this;

   if (fTitle.IsNull()) {
      mutble->SetTitle(fName.Data());
   }

   return fTitle.Data();
}


//______________________________________________________________________________
void TASImage::SetTitle(const char *title)
{
   // Set a title for an image.

   if (fTitle.IsNull()) {
      CreateThumbnail();
   }

   if (fTitle.IsNull()) {
      return;
   }

   int start = fTitle.Index("/*") + 3;
   int stop = fTitle.Index("*/") - 1;

   if ((start > 0) && (stop - start > 0)) {
      fTitle.Replace(start, stop - start, title);
   }
}


//______________________________________________________________________________
void TASImage::DrawCubeBezier(Int_t x1, Int_t y1, Int_t x2, Int_t y2,
                             Int_t x3, Int_t y3, const char *col, UInt_t thick)
{
   // Draw a cubic bezier line.

   Int_t sz = thick*thick;
   CARD32 *matrix;
   Bool_t use_cache = thick < kBrushCacheSize;

   ARGB32 color = ARGB32_White;
   parse_argb_color(col, &color);

   if (use_cache) {
      matrix = gBrushCache;
   } else {
      matrix = new CARD32[sz];
   }

   for (int i = 0; i < sz; i++) {
      matrix[i] = (CARD32)color;
   };

   ASDrawTool brush;
   brush.matrix = matrix;
   brush.width = thick;
   brush.height = thick;
   brush.center_y = brush.center_x = thick/2;

   ASDrawContext *ctx = 0;

   ctx = create_draw_context_argb32(fImage, &brush);
   asim_cube_bezier(ctx, x1, y1, x2, y2, x3, y3);

   if (!use_cache) {
      delete [] matrix;
   }
   destroy_asdraw_context32(ctx);
}


//______________________________________________________________________________
void TASImage::DrawStraightEllips(Int_t x, Int_t y, Int_t rx, Int_t ry,
                                  const char *col, Int_t thick)
{
   // Draw a straight ellipse.
   // If thick < 0 - draw filled ellipse.

   thick = !thick ? 1 : thick;
   Int_t sz = thick*thick;
   CARD32 *matrix;
   Bool_t use_cache = (thick > 0) && ((UInt_t)thick < kBrushCacheSize);

   ARGB32 color = ARGB32_White;
   parse_argb_color(col, &color);

   if (use_cache) {
      matrix = gBrushCache;
   } else {
      matrix = new CARD32[sz];
   }

   for (int i = 0; i < sz; i++) {
      matrix[i] = (CARD32)color;
   };

   ASDrawTool brush;
   brush.matrix = matrix;
   brush.width = thick > 0 ? thick : 1;
   brush.height = thick > 0 ? thick : 1;
   brush.center_y = brush.center_x = thick > 0 ? thick/2 : 0;

   ASDrawContext *ctx = create_draw_context_argb32(fImage, &brush);
   asim_straight_ellips(ctx, x, y, rx, ry, thick < 0);

   if (!use_cache) {
      delete [] matrix;
   }
   destroy_asdraw_context32(ctx);
}


//______________________________________________________________________________
void TASImage::DrawCircle(Int_t x, Int_t y, Int_t r, const char *col, Int_t thick)
{
   // Draw a circle.
   // If thick < 0 - draw filled circle

   thick = !thick ? 1 : thick;
   Int_t sz = thick*thick;
   CARD32 *matrix;
   Bool_t use_cache = (thick > 0) && ((UInt_t)thick < kBrushCacheSize);

   ARGB32 color = ARGB32_White;
   parse_argb_color(col, &color);

///matrix = new CARD32[sz];
   if (use_cache) {
      matrix = gBrushCache;
   } else {
      matrix = new CARD32[sz];
   }

   for (int i = 0; i < sz; i++) {
      matrix[i] = (CARD32)color;
   }

   ASDrawTool brush;
   brush.matrix = matrix;
   brush.height = brush.width = thick > 0 ? thick : 1;
   brush.center_y = brush.center_x = thick > 0 ? thick/2 : 0;

   ASDrawContext *ctx = create_draw_context_argb32(fImage, &brush);
   asim_circle(ctx, x,  y, r, thick < 0);

///free (matrix);
   if (!use_cache) {
      delete [] matrix;
   }
   destroy_asdraw_context32(ctx);
}


//______________________________________________________________________________
void TASImage::DrawEllips(Int_t x, Int_t y, Int_t rx, Int_t ry, Int_t angle,
                           const char *col, Int_t thick)
{
   // Draw an ellipse.
   // If thick < 0 - draw filled ellips

   thick = !thick ? 1 : thick;
   Int_t sz = thick*thick;
   CARD32 *matrix;
   Bool_t use_cache = (thick > 0) && ((UInt_t)thick < kBrushCacheSize);

   ARGB32 color = ARGB32_White;
   parse_argb_color(col, &color);

   if (use_cache) {
      matrix = gBrushCache;
   } else {
      matrix = new CARD32[sz];
   }

   for (int i = 0; i < sz; i++) {
      matrix[i] = (CARD32)color;
   };

   ASDrawTool brush;
   brush.matrix = matrix;
   brush.width = thick > 0 ? thick : 1;
   brush.height = thick > 0 ? thick : 1;
   brush.center_y = brush.center_x = thick > 0 ? thick/2 : 0;

   ASDrawContext *ctx = create_draw_context_argb32(fImage, &brush);
   asim_ellips(ctx, x, y, rx, ry, angle, thick < 0);

   if (!use_cache) {
      delete [] matrix;
   }
   destroy_asdraw_context32(ctx);
}


//______________________________________________________________________________
void TASImage::DrawEllips2(Int_t x, Int_t y, Int_t rx, Int_t ry, Int_t angle,
                           const char *col, Int_t thick)
{
   // Draw an ellipse.
   // If thick < 0 - draw filled ellipse.

   thick = !thick ? 1 : thick;
   Int_t sz = thick*thick;
   CARD32 *matrix;
   Bool_t use_cache = (thick > 0) && ((UInt_t)thick < kBrushCacheSize);

   ARGB32 color = ARGB32_White;
   parse_argb_color(col, &color);

   if (use_cache) {
      matrix = gBrushCache;
   } else {
      matrix = new CARD32[sz];
   }

   for (int i = 0; i < sz; i++) {
      matrix[i] = (CARD32)color;
   };

   ASDrawTool brush;
   brush.matrix = matrix;
   brush.width = thick > 0 ? thick : 1;
   brush.height = thick > 0 ? thick : 1;
   brush.center_y = brush.center_x = thick > 0 ? thick/2 : 0;

   ASDrawContext *ctx = create_draw_context_argb32(fImage, &brush);
   asim_ellips2(ctx, x, y, rx, ry, angle, thick < 0);

   if (!use_cache) {
      delete [] matrix;
   }
   destroy_asdraw_context32(ctx);
}


//______________________________________________________________________________
void TASImage::FloodFill(Int_t /*x*/, Int_t /*y*/, const char * /*col*/,
                         const char * /*minc*/, const char * /*maxc*/)
{
   // Flood fill.
}


//______________________________________________________________________________
void TASImage::Gray(Bool_t on)
{
   // Convert RGB image to Gray image and vice versa.

   if (fIsGray == on) {
      return;
   }

   if (!IsValid()) {
      Warning("Gray", "Image not initiated");
      return;
   }

   if (!InitVisual()) {
      Warning("Gray", "Visual not initiated");
      return;
   }

   if (!fGrayImage && !on) {
      return;
   }
   ASImage *sav = 0;
   delete fScaledImage;
   fScaledImage = 0;

   if (fGrayImage)  {
      sav = fImage;
      fImage = fGrayImage;
      fGrayImage = sav;
      fIsGray = on;
      return;
   }

   if (!on) return;

   UInt_t l, r, g, b, idx;
   int y = 0;
   UInt_t i, j;

   if (fImage->alt.argb32) {
      fGrayImage = tile_asimage(fgVisual, fImage, 0, 0, fImage->width, fImage->height,
                                0, ASA_ARGB32, 0, ASIMAGE_QUALITY_DEFAULT);

      for (i = 0; i < fImage->height; i++) {
         for (j = 0; j < fImage->width; j++) {
            idx = y + j;

            r = ((fImage->alt.argb32[idx] & 0xff0000) >> 16);
            g = ((fImage->alt.argb32[idx] & 0x00ff00) >> 8);
            b = (fImage->alt.argb32[idx] & 0x0000ff);
            l = (57*r + 181*g + 18*b)/256;
            fGrayImage->alt.argb32[idx] = (l << 16) + (l << 8) + l;
         }
         y += fImage->width;
      }
   } else {
      fGrayImage = create_asimage(fImage->width, fImage->height, 0);

      ASImageDecoder *imdec = start_image_decoding(fgVisual, fImage, SCL_DO_ALL,
                                                   0, 0, fImage->width, fImage->height, 0);

      if (!imdec) {
         return;
      }
#ifdef HAVE_MMX
   mmx_init();
#endif
      ASImageOutput *imout = start_image_output(fgVisual, fGrayImage, ASA_ASImage,
                                                GetImageCompression(), GetImageQuality());
      if (!imout) {
         Warning("ToGray", "Failed to start image output");
         delete fScaledImage;
         fScaledImage = 0;
         delete [] imdec;
         return;
      }

      CARD32 *aa = imdec->buffer.alpha;
      CARD32 *rr = imdec->buffer.red;
      CARD32 *gg = imdec->buffer.green;
      CARD32 *bb = imdec->buffer.blue;

      ASScanline result;
      prepare_scanline(fImage->width, 0, &result, fgVisual->BGR_mode);

      for (i = 0; i < fImage->height; i++) {
         imdec->decode_image_scanline(imdec);
         result.flags = imdec->buffer.flags;
         result.back_color = imdec->buffer.back_color;

         for (j = 0; j < fImage->width; j++) {
            l = (57*rr[j] + 181*gg[j]+ 18*bb[j])/256;
            result.alpha[j] = aa[j];
            result.red[j] = l;
            result.green[j] = l;
            result.blue[j] = l;
         }
         imout->output_image_scanline(imout, &result, 1);
      }

      stop_image_decoding(&imdec);
      stop_image_output(&imout);
#ifdef HAVE_MMX
   mmx_off();
#endif
   }

   sav = fImage;
   fImage = fGrayImage;
   fGrayImage = sav;
   fIsGray = kTRUE;
}


//______________________________________________________________________________
void TASImage::FromWindow(Drawable_t wid, Int_t x, Int_t y, UInt_t w, UInt_t h)
{
   // Create an image (screenshot) from specified window.

   Int_t xy;

   x = x < 0 ? 0 : x;
   y = y < 0 ? 0 : y;

   // syncronization
   gVirtualX->Update(1);
   if (!gThreadXAR) {
      gSystem->ProcessEvents();
      gSystem->Sleep(10);
      gSystem->ProcessEvents();
   }

   if (!w || !h) {
      gVirtualX->GetWindowSize(wid, xy, xy, w, h);
   }

   if ((x >= (Int_t)w) || (y >= (Int_t)h)) {
      return;
   }

   if (!InitVisual()) {
      Warning("FromWindow", "Visual not initiated");
      return;
   }

   DestroyImage();
   delete fScaledImage;
   fScaledImage = 0;

   static int x11 = -1;
   if (x11 < 0) x11 = gVirtualX->InheritsFrom("TGX11");

   if (x11) { //use built-in optimized version
      fImage = pixmap2asimage(fgVisual, wid, x, y, w, h, kAllPlanes, 0, 0);
   } else {
      unsigned char *bits = gVirtualX->GetColorBits(wid, 0, 0, w, h);

      if (!bits) { // error
         return;
      }
      fImage = bitmap2asimage(bits, w, h, 0, 0);
      delete [] bits;
   }
}


//______________________________________________________________________________
void TASImage::FromGLBuffer(UChar_t* buf, UInt_t w, UInt_t h)
{
   // Creates an image (screenshot) from a RGBA buffer.

   DestroyImage();
   delete fScaledImage;
   fScaledImage = 0;

   UChar_t* xx = new UChar_t[4*w];
   for (UInt_t i = 0; i < h/2; ++i) {
      memcpy(xx, buf + 4*w*i, 4*w);
      memcpy(buf + 4*w*i, buf + 4*w*(h-i-1), 4*w);
      memcpy(buf + 4*w*(h-i-1), xx, 4*w);
   }
   delete [] xx;

   fImage = bitmap2asimage(buf, w, h, 0, 0);
}


//______________________________________________________________________________
void TASImage::SetPaletteEnabled(Bool_t on)
{
   // Switch on/off the image palette.
   // That also invokes calling vectorization of image.

   if (!fImage) {
      return;
   }

   if (!fImage->alt.vector && on) {
      Vectorize();
   }
   fPaletteEnabled = on;

   if (on) {
      Double_t left = gPad->GetLeftMargin();
      Double_t right = gPad->GetRightMargin();
      Double_t top = gPad->GetTopMargin();
      Double_t bottom = gPad->GetBottomMargin();

      gPad->Range(-left / (1.0 - left - right),
                  -bottom / (1.0 - top - bottom),
                  1 + right / (1.0 - left - right),
                  1 + top / ( 1.0 - top - bottom));
      gPad->RangeAxis(0, 0, 1, 1);
   }

}


//______________________________________________________________________________
void TASImage::SavePrimitive(std::ostream &out, Option_t * /*= ""*/)
{
    // Save a primitive as a C++ statement(s) on output stream "out".

   char *buf = 0;
   int sz;

   UInt_t w = GetWidth();
   UInt_t h = GetHeight();

   if (w > 500) { // workarond CINT limitations
      w = 500;
      Double_t scale = 500./GetWidth();
      h = TMath::Nint(GetHeight()*scale);
      Scale(w, h);
   }

   GetImageBuffer(&buf, &sz, TImage::kXpm);

   TString name = GetName();
   name.ReplaceAll(".", "_");
   TString str = buf;
   static int ii = 0;
   ii++;

   str.ReplaceAll("static", "const");
   TString xpm = "xpm_";
   xpm += name;
   xpm += ii;
   str.ReplaceAll("asxpm", xpm.Data());
   out << std::endl << str << std::endl << std::endl;

   out << "   TImage *";
   out << xpm << "_img = TImage::Create();" << std::endl;
   out << "   " << xpm << "_img->SetImageBuffer( (char **)" << xpm << ", TImage::kXpm);" << std::endl;
   out << "   " << xpm << "_img->Draw();" << std::endl;
}


//______________________________________________________________________________
Bool_t TASImage::SetJpegDpi(const char *name, UInt_t set)
{
   // Set an image printing resolution in Dots Per Inch units.
   // name - the name of jpeg file.
   // set - dpi resolution.
   // Returns kFALSE in case of error.

   static char buf[32];
   FILE *fp = fopen(name, "rb+");

   if (!fp) {
      printf("file %s : failed to open\n", name);
      return kFALSE;
   }

   if (!fread(buf, 1, 20, fp)) {
      fclose(fp);
      return kFALSE;
   }

   char dpi1 = (set & 0xffff) >> 8;
   char dpi2 = set & 0xff;

   int i = 0;

   int dpi = 0; // start of dpi data
   for (i = 0; i < 20; i++) {
      if ((buf[i] == 0x4a) && (buf[i+1] == 0x46) &&  (buf[i+2] == 0x49) &&
          (buf[i+3] == 0x46) && (buf[i+4] == 0x00) ) {
         dpi = i + 7;
         break;
      }
   }

   if (i == 20 || dpi+4 >= 20) { // jpeg maker was not found
      fclose(fp);
      printf("file %s : wrong JPEG format\n", name);
      return kFALSE;
   }

   buf[dpi] = 1;   // format specified in  dots per inch

   // set x density in dpi units
   buf[dpi + 1] = dpi1;
   buf[dpi + 2] = dpi2;

   // set y density in dpi units
   buf[dpi + 3] = dpi1;
   buf[dpi + 4] = dpi2;

   rewind(fp);
   fwrite(buf, 1, 20, fp);
   fclose(fp);

   return kTRUE;
}
 TASImage.cxx:1
 TASImage.cxx:2
 TASImage.cxx:3
 TASImage.cxx:4
 TASImage.cxx:5
 TASImage.cxx:6
 TASImage.cxx:7
 TASImage.cxx:8
 TASImage.cxx:9
 TASImage.cxx:10
 TASImage.cxx:11
 TASImage.cxx:12
 TASImage.cxx:13
 TASImage.cxx:14
 TASImage.cxx:15
 TASImage.cxx:16
 TASImage.cxx:17
 TASImage.cxx:18
 TASImage.cxx:19
 TASImage.cxx:20
 TASImage.cxx:21
 TASImage.cxx:22
 TASImage.cxx:23
 TASImage.cxx:24
 TASImage.cxx:25
 TASImage.cxx:26
 TASImage.cxx:27
 TASImage.cxx:28
 TASImage.cxx:29
 TASImage.cxx:30
 TASImage.cxx:31
 TASImage.cxx:32
 TASImage.cxx:33
 TASImage.cxx:34
 TASImage.cxx:35
 TASImage.cxx:36
 TASImage.cxx:37
 TASImage.cxx:38
 TASImage.cxx:39
 TASImage.cxx:40
 TASImage.cxx:41
 TASImage.cxx:42
 TASImage.cxx:43
 TASImage.cxx:44
 TASImage.cxx:45
 TASImage.cxx:46
 TASImage.cxx:47
 TASImage.cxx:48
 TASImage.cxx:49
 TASImage.cxx:50
 TASImage.cxx:51
 TASImage.cxx:52
 TASImage.cxx:53
 TASImage.cxx:54
 TASImage.cxx:55
 TASImage.cxx:56
 TASImage.cxx:57
 TASImage.cxx:58
 TASImage.cxx:59
 TASImage.cxx:60
 TASImage.cxx:61
 TASImage.cxx:62
 TASImage.cxx:63
 TASImage.cxx:64
 TASImage.cxx:65
 TASImage.cxx:66
 TASImage.cxx:67
 TASImage.cxx:68
 TASImage.cxx:69
 TASImage.cxx:70
 TASImage.cxx:71
 TASImage.cxx:72
 TASImage.cxx:73
 TASImage.cxx:74
 TASImage.cxx:75
 TASImage.cxx:76
 TASImage.cxx:77
 TASImage.cxx:78
 TASImage.cxx:79
 TASImage.cxx:80
 TASImage.cxx:81
 TASImage.cxx:82
 TASImage.cxx:83
 TASImage.cxx:84
 TASImage.cxx:85
 TASImage.cxx:86
 TASImage.cxx:87
 TASImage.cxx:88
 TASImage.cxx:89
 TASImage.cxx:90
 TASImage.cxx:91
 TASImage.cxx:92
 TASImage.cxx:93
 TASImage.cxx:94
 TASImage.cxx:95
 TASImage.cxx:96
 TASImage.cxx:97
 TASImage.cxx:98
 TASImage.cxx:99
 TASImage.cxx:100
 TASImage.cxx:101
 TASImage.cxx:102
 TASImage.cxx:103
 TASImage.cxx:104
 TASImage.cxx:105
 TASImage.cxx:106
 TASImage.cxx:107
 TASImage.cxx:108
 TASImage.cxx:109
 TASImage.cxx:110
 TASImage.cxx:111
 TASImage.cxx:112
 TASImage.cxx:113
 TASImage.cxx:114
 TASImage.cxx:115
 TASImage.cxx:116
 TASImage.cxx:117
 TASImage.cxx:118
 TASImage.cxx:119
 TASImage.cxx:120
 TASImage.cxx:121
 TASImage.cxx:122
 TASImage.cxx:123
 TASImage.cxx:124
 TASImage.cxx:125
 TASImage.cxx:126
 TASImage.cxx:127
 TASImage.cxx:128
 TASImage.cxx:129
 TASImage.cxx:130
 TASImage.cxx:131
 TASImage.cxx:132
 TASImage.cxx:133
 TASImage.cxx:134
 TASImage.cxx:135
 TASImage.cxx:136
 TASImage.cxx:137
 TASImage.cxx:138
 TASImage.cxx:139
 TASImage.cxx:140
 TASImage.cxx:141
 TASImage.cxx:142
 TASImage.cxx:143
 TASImage.cxx:144
 TASImage.cxx:145
 TASImage.cxx:146
 TASImage.cxx:147
 TASImage.cxx:148
 TASImage.cxx:149
 TASImage.cxx:150
 TASImage.cxx:151
 TASImage.cxx:152
 TASImage.cxx:153
 TASImage.cxx:154
 TASImage.cxx:155
 TASImage.cxx:156
 TASImage.cxx:157
 TASImage.cxx:158
 TASImage.cxx:159
 TASImage.cxx:160
 TASImage.cxx:161
 TASImage.cxx:162
 TASImage.cxx:163
 TASImage.cxx:164
 TASImage.cxx:165
 TASImage.cxx:166
 TASImage.cxx:167
 TASImage.cxx:168
 TASImage.cxx:169
 TASImage.cxx:170
 TASImage.cxx:171
 TASImage.cxx:172
 TASImage.cxx:173
 TASImage.cxx:174
 TASImage.cxx:175
 TASImage.cxx:176
 TASImage.cxx:177
 TASImage.cxx:178
 TASImage.cxx:179
 TASImage.cxx:180
 TASImage.cxx:181
 TASImage.cxx:182
 TASImage.cxx:183
 TASImage.cxx:184
 TASImage.cxx:185
 TASImage.cxx:186
 TASImage.cxx:187
 TASImage.cxx:188
 TASImage.cxx:189
 TASImage.cxx:190
 TASImage.cxx:191
 TASImage.cxx:192
 TASImage.cxx:193
 TASImage.cxx:194
 TASImage.cxx:195
 TASImage.cxx:196
 TASImage.cxx:197
 TASImage.cxx:198
 TASImage.cxx:199
 TASImage.cxx:200
 TASImage.cxx:201
 TASImage.cxx:202
 TASImage.cxx:203
 TASImage.cxx:204
 TASImage.cxx:205
 TASImage.cxx:206
 TASImage.cxx:207
 TASImage.cxx:208
 TASImage.cxx:209
 TASImage.cxx:210
 TASImage.cxx:211
 TASImage.cxx:212
 TASImage.cxx:213
 TASImage.cxx:214
 TASImage.cxx:215
 TASImage.cxx:216
 TASImage.cxx:217
 TASImage.cxx:218
 TASImage.cxx:219
 TASImage.cxx:220
 TASImage.cxx:221
 TASImage.cxx:222
 TASImage.cxx:223
 TASImage.cxx:224
 TASImage.cxx:225
 TASImage.cxx:226
 TASImage.cxx:227
 TASImage.cxx:228
 TASImage.cxx:229
 TASImage.cxx:230
 TASImage.cxx:231
 TASImage.cxx:232
 TASImage.cxx:233
 TASImage.cxx:234
 TASImage.cxx:235
 TASImage.cxx:236
 TASImage.cxx:237
 TASImage.cxx:238
 TASImage.cxx:239
 TASImage.cxx:240
 TASImage.cxx:241
 TASImage.cxx:242
 TASImage.cxx:243
 TASImage.cxx:244
 TASImage.cxx:245
 TASImage.cxx:246
 TASImage.cxx:247
 TASImage.cxx:248
 TASImage.cxx:249
 TASImage.cxx:250
 TASImage.cxx:251
 TASImage.cxx:252
 TASImage.cxx:253
 TASImage.cxx:254
 TASImage.cxx:255
 TASImage.cxx:256
 TASImage.cxx:257
 TASImage.cxx:258
 TASImage.cxx:259
 TASImage.cxx:260
 TASImage.cxx:261
 TASImage.cxx:262
 TASImage.cxx:263
 TASImage.cxx:264
 TASImage.cxx:265
 TASImage.cxx:266
 TASImage.cxx:267
 TASImage.cxx:268
 TASImage.cxx:269
 TASImage.cxx:270
 TASImage.cxx:271
 TASImage.cxx:272
 TASImage.cxx:273
 TASImage.cxx:274
 TASImage.cxx:275
 TASImage.cxx:276
 TASImage.cxx:277
 TASImage.cxx:278
 TASImage.cxx:279
 TASImage.cxx:280
 TASImage.cxx:281
 TASImage.cxx:282
 TASImage.cxx:283
 TASImage.cxx:284
 TASImage.cxx:285
 TASImage.cxx:286
 TASImage.cxx:287
 TASImage.cxx:288
 TASImage.cxx:289
 TASImage.cxx:290
 TASImage.cxx:291
 TASImage.cxx:292
 TASImage.cxx:293
 TASImage.cxx:294
 TASImage.cxx:295
 TASImage.cxx:296
 TASImage.cxx:297
 TASImage.cxx:298
 TASImage.cxx:299
 TASImage.cxx:300
 TASImage.cxx:301
 TASImage.cxx:302
 TASImage.cxx:303
 TASImage.cxx:304
 TASImage.cxx:305
 TASImage.cxx:306
 TASImage.cxx:307
 TASImage.cxx:308
 TASImage.cxx:309
 TASImage.cxx:310
 TASImage.cxx:311
 TASImage.cxx:312
 TASImage.cxx:313
 TASImage.cxx:314
 TASImage.cxx:315
 TASImage.cxx:316
 TASImage.cxx:317
 TASImage.cxx:318
 TASImage.cxx:319
 TASImage.cxx:320
 TASImage.cxx:321
 TASImage.cxx:322
 TASImage.cxx:323
 TASImage.cxx:324
 TASImage.cxx:325
 TASImage.cxx:326
 TASImage.cxx:327
 TASImage.cxx:328
 TASImage.cxx:329
 TASImage.cxx:330
 TASImage.cxx:331
 TASImage.cxx:332
 TASImage.cxx:333
 TASImage.cxx:334
 TASImage.cxx:335
 TASImage.cxx:336
 TASImage.cxx:337
 TASImage.cxx:338
 TASImage.cxx:339
 TASImage.cxx:340
 TASImage.cxx:341
 TASImage.cxx:342
 TASImage.cxx:343
 TASImage.cxx:344
 TASImage.cxx:345
 TASImage.cxx:346
 TASImage.cxx:347
 TASImage.cxx:348
 TASImage.cxx:349
 TASImage.cxx:350
 TASImage.cxx:351
 TASImage.cxx:352
 TASImage.cxx:353
 TASImage.cxx:354
 TASImage.cxx:355
 TASImage.cxx:356
 TASImage.cxx:357
 TASImage.cxx:358
 TASImage.cxx:359
 TASImage.cxx:360
 TASImage.cxx:361
 TASImage.cxx:362
 TASImage.cxx:363
 TASImage.cxx:364
 TASImage.cxx:365
 TASImage.cxx:366
 TASImage.cxx:367
 TASImage.cxx:368
 TASImage.cxx:369
 TASImage.cxx:370
 TASImage.cxx:371
 TASImage.cxx:372
 TASImage.cxx:373
 TASImage.cxx:374
 TASImage.cxx:375
 TASImage.cxx:376
 TASImage.cxx:377
 TASImage.cxx:378
 TASImage.cxx:379
 TASImage.cxx:380
 TASImage.cxx:381
 TASImage.cxx:382
 TASImage.cxx:383
 TASImage.cxx:384
 TASImage.cxx:385
 TASImage.cxx:386
 TASImage.cxx:387
 TASImage.cxx:388
 TASImage.cxx:389
 TASImage.cxx:390
 TASImage.cxx:391
 TASImage.cxx:392
 TASImage.cxx:393
 TASImage.cxx:394
 TASImage.cxx:395
 TASImage.cxx:396
 TASImage.cxx:397
 TASImage.cxx:398
 TASImage.cxx:399
 TASImage.cxx:400
 TASImage.cxx:401
 TASImage.cxx:402
 TASImage.cxx:403
 TASImage.cxx:404
 TASImage.cxx:405
 TASImage.cxx:406
 TASImage.cxx:407
 TASImage.cxx:408
 TASImage.cxx:409
 TASImage.cxx:410
 TASImage.cxx:411
 TASImage.cxx:412
 TASImage.cxx:413
 TASImage.cxx:414
 TASImage.cxx:415
 TASImage.cxx:416
 TASImage.cxx:417
 TASImage.cxx:418
 TASImage.cxx:419
 TASImage.cxx:420
 TASImage.cxx:421
 TASImage.cxx:422
 TASImage.cxx:423
 TASImage.cxx:424
 TASImage.cxx:425
 TASImage.cxx:426
 TASImage.cxx:427
 TASImage.cxx:428
 TASImage.cxx:429
 TASImage.cxx:430
 TASImage.cxx:431
 TASImage.cxx:432
 TASImage.cxx:433
 TASImage.cxx:434
 TASImage.cxx:435
 TASImage.cxx:436
 TASImage.cxx:437
 TASImage.cxx:438
 TASImage.cxx:439
 TASImage.cxx:440
 TASImage.cxx:441
 TASImage.cxx:442
 TASImage.cxx:443
 TASImage.cxx:444
 TASImage.cxx:445
 TASImage.cxx:446
 TASImage.cxx:447
 TASImage.cxx:448
 TASImage.cxx:449
 TASImage.cxx:450
 TASImage.cxx:451
 TASImage.cxx:452
 TASImage.cxx:453
 TASImage.cxx:454
 TASImage.cxx:455
 TASImage.cxx:456
 TASImage.cxx:457
 TASImage.cxx:458
 TASImage.cxx:459
 TASImage.cxx:460
 TASImage.cxx:461
 TASImage.cxx:462
 TASImage.cxx:463
 TASImage.cxx:464
 TASImage.cxx:465
 TASImage.cxx:466
 TASImage.cxx:467
 TASImage.cxx:468
 TASImage.cxx:469
 TASImage.cxx:470
 TASImage.cxx:471
 TASImage.cxx:472
 TASImage.cxx:473
 TASImage.cxx:474
 TASImage.cxx:475
 TASImage.cxx:476
 TASImage.cxx:477
 TASImage.cxx:478
 TASImage.cxx:479
 TASImage.cxx:480
 TASImage.cxx:481
 TASImage.cxx:482
 TASImage.cxx:483
 TASImage.cxx:484
 TASImage.cxx:485
 TASImage.cxx:486
 TASImage.cxx:487
 TASImage.cxx:488
 TASImage.cxx:489
 TASImage.cxx:490
 TASImage.cxx:491
 TASImage.cxx:492
 TASImage.cxx:493
 TASImage.cxx:494
 TASImage.cxx:495
 TASImage.cxx:496
 TASImage.cxx:497
 TASImage.cxx:498
 TASImage.cxx:499
 TASImage.cxx:500
 TASImage.cxx:501
 TASImage.cxx:502
 TASImage.cxx:503
 TASImage.cxx:504
 TASImage.cxx:505
 TASImage.cxx:506
 TASImage.cxx:507
 TASImage.cxx:508
 TASImage.cxx:509
 TASImage.cxx:510
 TASImage.cxx:511
 TASImage.cxx:512
 TASImage.cxx:513
 TASImage.cxx:514
 TASImage.cxx:515
 TASImage.cxx:516
 TASImage.cxx:517
 TASImage.cxx:518
 TASImage.cxx:519
 TASImage.cxx:520
 TASImage.cxx:521
 TASImage.cxx:522
 TASImage.cxx:523
 TASImage.cxx:524
 TASImage.cxx:525
 TASImage.cxx:526
 TASImage.cxx:527
 TASImage.cxx:528
 TASImage.cxx:529
 TASImage.cxx:530
 TASImage.cxx:531
 TASImage.cxx:532
 TASImage.cxx:533
 TASImage.cxx:534
 TASImage.cxx:535
 TASImage.cxx:536
 TASImage.cxx:537
 TASImage.cxx:538
 TASImage.cxx:539
 TASImage.cxx:540
 TASImage.cxx:541
 TASImage.cxx:542
 TASImage.cxx:543
 TASImage.cxx:544
 TASImage.cxx:545
 TASImage.cxx:546
 TASImage.cxx:547
 TASImage.cxx:548
 TASImage.cxx:549
 TASImage.cxx:550
 TASImage.cxx:551
 TASImage.cxx:552
 TASImage.cxx:553
 TASImage.cxx:554
 TASImage.cxx:555
 TASImage.cxx:556
 TASImage.cxx:557
 TASImage.cxx:558
 TASImage.cxx:559
 TASImage.cxx:560
 TASImage.cxx:561
 TASImage.cxx:562
 TASImage.cxx:563
 TASImage.cxx:564
 TASImage.cxx:565
 TASImage.cxx:566
 TASImage.cxx:567
 TASImage.cxx:568
 TASImage.cxx:569
 TASImage.cxx:570
 TASImage.cxx:571
 TASImage.cxx:572
 TASImage.cxx:573
 TASImage.cxx:574
 TASImage.cxx:575
 TASImage.cxx:576
 TASImage.cxx:577
 TASImage.cxx:578
 TASImage.cxx:579
 TASImage.cxx:580
 TASImage.cxx:581
 TASImage.cxx:582
 TASImage.cxx:583
 TASImage.cxx:584
 TASImage.cxx:585
 TASImage.cxx:586
 TASImage.cxx:587
 TASImage.cxx:588
 TASImage.cxx:589
 TASImage.cxx:590
 TASImage.cxx:591
 TASImage.cxx:592
 TASImage.cxx:593
 TASImage.cxx:594
 TASImage.cxx:595
 TASImage.cxx:596
 TASImage.cxx:597
 TASImage.cxx:598
 TASImage.cxx:599
 TASImage.cxx:600
 TASImage.cxx:601
 TASImage.cxx:602
 TASImage.cxx:603
 TASImage.cxx:604
 TASImage.cxx:605
 TASImage.cxx:606
 TASImage.cxx:607
 TASImage.cxx:608
 TASImage.cxx:609
 TASImage.cxx:610
 TASImage.cxx:611
 TASImage.cxx:612
 TASImage.cxx:613
 TASImage.cxx:614
 TASImage.cxx:615
 TASImage.cxx:616
 TASImage.cxx:617
 TASImage.cxx:618
 TASImage.cxx:619
 TASImage.cxx:620
 TASImage.cxx:621
 TASImage.cxx:622
 TASImage.cxx:623
 TASImage.cxx:624
 TASImage.cxx:625
 TASImage.cxx:626
 TASImage.cxx:627
 TASImage.cxx:628
 TASImage.cxx:629
 TASImage.cxx:630
 TASImage.cxx:631
 TASImage.cxx:632
 TASImage.cxx:633
 TASImage.cxx:634
 TASImage.cxx:635
 TASImage.cxx:636
 TASImage.cxx:637
 TASImage.cxx:638
 TASImage.cxx:639
 TASImage.cxx:640
 TASImage.cxx:641
 TASImage.cxx:642
 TASImage.cxx:643
 TASImage.cxx:644
 TASImage.cxx:645
 TASImage.cxx:646
 TASImage.cxx:647
 TASImage.cxx:648
 TASImage.cxx:649
 TASImage.cxx:650
 TASImage.cxx:651
 TASImage.cxx:652
 TASImage.cxx:653
 TASImage.cxx:654
 TASImage.cxx:655
 TASImage.cxx:656
 TASImage.cxx:657
 TASImage.cxx:658
 TASImage.cxx:659
 TASImage.cxx:660
 TASImage.cxx:661
 TASImage.cxx:662
 TASImage.cxx:663
 TASImage.cxx:664
 TASImage.cxx:665
 TASImage.cxx:666
 TASImage.cxx:667
 TASImage.cxx:668
 TASImage.cxx:669
 TASImage.cxx:670
 TASImage.cxx:671
 TASImage.cxx:672
 TASImage.cxx:673
 TASImage.cxx:674
 TASImage.cxx:675
 TASImage.cxx:676
 TASImage.cxx:677
 TASImage.cxx:678
 TASImage.cxx:679
 TASImage.cxx:680
 TASImage.cxx:681
 TASImage.cxx:682
 TASImage.cxx:683
 TASImage.cxx:684
 TASImage.cxx:685
 TASImage.cxx:686
 TASImage.cxx:687
 TASImage.cxx:688
 TASImage.cxx:689
 TASImage.cxx:690
 TASImage.cxx:691
 TASImage.cxx:692
 TASImage.cxx:693
 TASImage.cxx:694
 TASImage.cxx:695
 TASImage.cxx:696
 TASImage.cxx:697
 TASImage.cxx:698
 TASImage.cxx:699
 TASImage.cxx:700
 TASImage.cxx:701
 TASImage.cxx:702
 TASImage.cxx:703
 TASImage.cxx:704
 TASImage.cxx:705
 TASImage.cxx:706
 TASImage.cxx:707
 TASImage.cxx:708
 TASImage.cxx:709
 TASImage.cxx:710
 TASImage.cxx:711
 TASImage.cxx:712
 TASImage.cxx:713
 TASImage.cxx:714
 TASImage.cxx:715
 TASImage.cxx:716
 TASImage.cxx:717
 TASImage.cxx:718
 TASImage.cxx:719
 TASImage.cxx:720
 TASImage.cxx:721
 TASImage.cxx:722
 TASImage.cxx:723
 TASImage.cxx:724
 TASImage.cxx:725
 TASImage.cxx:726
 TASImage.cxx:727
 TASImage.cxx:728
 TASImage.cxx:729
 TASImage.cxx:730
 TASImage.cxx:731
 TASImage.cxx:732
 TASImage.cxx:733
 TASImage.cxx:734
 TASImage.cxx:735
 TASImage.cxx:736
 TASImage.cxx:737
 TASImage.cxx:738
 TASImage.cxx:739
 TASImage.cxx:740
 TASImage.cxx:741
 TASImage.cxx:742
 TASImage.cxx:743
 TASImage.cxx:744
 TASImage.cxx:745
 TASImage.cxx:746
 TASImage.cxx:747
 TASImage.cxx:748
 TASImage.cxx:749
 TASImage.cxx:750
 TASImage.cxx:751
 TASImage.cxx:752
 TASImage.cxx:753
 TASImage.cxx:754
 TASImage.cxx:755
 TASImage.cxx:756
 TASImage.cxx:757
 TASImage.cxx:758
 TASImage.cxx:759
 TASImage.cxx:760
 TASImage.cxx:761
 TASImage.cxx:762
 TASImage.cxx:763
 TASImage.cxx:764
 TASImage.cxx:765
 TASImage.cxx:766
 TASImage.cxx:767
 TASImage.cxx:768
 TASImage.cxx:769
 TASImage.cxx:770
 TASImage.cxx:771
 TASImage.cxx:772
 TASImage.cxx:773
 TASImage.cxx:774
 TASImage.cxx:775
 TASImage.cxx:776
 TASImage.cxx:777
 TASImage.cxx:778
 TASImage.cxx:779
 TASImage.cxx:780
 TASImage.cxx:781
 TASImage.cxx:782
 TASImage.cxx:783
 TASImage.cxx:784
 TASImage.cxx:785
 TASImage.cxx:786
 TASImage.cxx:787
 TASImage.cxx:788
 TASImage.cxx:789
 TASImage.cxx:790
 TASImage.cxx:791
 TASImage.cxx:792
 TASImage.cxx:793
 TASImage.cxx:794
 TASImage.cxx:795
 TASImage.cxx:796
 TASImage.cxx:797
 TASImage.cxx:798
 TASImage.cxx:799
 TASImage.cxx:800
 TASImage.cxx:801
 TASImage.cxx:802
 TASImage.cxx:803
 TASImage.cxx:804
 TASImage.cxx:805
 TASImage.cxx:806
 TASImage.cxx:807
 TASImage.cxx:808
 TASImage.cxx:809
 TASImage.cxx:810
 TASImage.cxx:811
 TASImage.cxx:812
 TASImage.cxx:813
 TASImage.cxx:814
 TASImage.cxx:815
 TASImage.cxx:816
 TASImage.cxx:817
 TASImage.cxx:818
 TASImage.cxx:819
 TASImage.cxx:820
 TASImage.cxx:821
 TASImage.cxx:822
 TASImage.cxx:823
 TASImage.cxx:824
 TASImage.cxx:825
 TASImage.cxx:826
 TASImage.cxx:827
 TASImage.cxx:828
 TASImage.cxx:829
 TASImage.cxx:830
 TASImage.cxx:831
 TASImage.cxx:832
 TASImage.cxx:833
 TASImage.cxx:834
 TASImage.cxx:835
 TASImage.cxx:836
 TASImage.cxx:837
 TASImage.cxx:838
 TASImage.cxx:839
 TASImage.cxx:840
 TASImage.cxx:841
 TASImage.cxx:842
 TASImage.cxx:843
 TASImage.cxx:844
 TASImage.cxx:845
 TASImage.cxx:846
 TASImage.cxx:847
 TASImage.cxx:848
 TASImage.cxx:849
 TASImage.cxx:850
 TASImage.cxx:851
 TASImage.cxx:852
 TASImage.cxx:853
 TASImage.cxx:854
 TASImage.cxx:855
 TASImage.cxx:856
 TASImage.cxx:857
 TASImage.cxx:858
 TASImage.cxx:859
 TASImage.cxx:860
 TASImage.cxx:861
 TASImage.cxx:862
 TASImage.cxx:863
 TASImage.cxx:864
 TASImage.cxx:865
 TASImage.cxx:866
 TASImage.cxx:867
 TASImage.cxx:868
 TASImage.cxx:869
 TASImage.cxx:870
 TASImage.cxx:871
 TASImage.cxx:872
 TASImage.cxx:873
 TASImage.cxx:874
 TASImage.cxx:875
 TASImage.cxx:876
 TASImage.cxx:877
 TASImage.cxx:878
 TASImage.cxx:879
 TASImage.cxx:880
 TASImage.cxx:881
 TASImage.cxx:882
 TASImage.cxx:883
 TASImage.cxx:884
 TASImage.cxx:885
 TASImage.cxx:886
 TASImage.cxx:887
 TASImage.cxx:888
 TASImage.cxx:889
 TASImage.cxx:890
 TASImage.cxx:891
 TASImage.cxx:892
 TASImage.cxx:893
 TASImage.cxx:894
 TASImage.cxx:895
 TASImage.cxx:896
 TASImage.cxx:897
 TASImage.cxx:898
 TASImage.cxx:899
 TASImage.cxx:900
 TASImage.cxx:901
 TASImage.cxx:902
 TASImage.cxx:903
 TASImage.cxx:904
 TASImage.cxx:905
 TASImage.cxx:906
 TASImage.cxx:907
 TASImage.cxx:908
 TASImage.cxx:909
 TASImage.cxx:910
 TASImage.cxx:911
 TASImage.cxx:912
 TASImage.cxx:913
 TASImage.cxx:914
 TASImage.cxx:915
 TASImage.cxx:916
 TASImage.cxx:917
 TASImage.cxx:918
 TASImage.cxx:919
 TASImage.cxx:920
 TASImage.cxx:921
 TASImage.cxx:922
 TASImage.cxx:923
 TASImage.cxx:924
 TASImage.cxx:925
 TASImage.cxx:926
 TASImage.cxx:927
 TASImage.cxx:928
 TASImage.cxx:929
 TASImage.cxx:930
 TASImage.cxx:931
 TASImage.cxx:932
 TASImage.cxx:933
 TASImage.cxx:934
 TASImage.cxx:935
 TASImage.cxx:936
 TASImage.cxx:937
 TASImage.cxx:938
 TASImage.cxx:939
 TASImage.cxx:940
 TASImage.cxx:941
 TASImage.cxx:942
 TASImage.cxx:943
 TASImage.cxx:944
 TASImage.cxx:945
 TASImage.cxx:946
 TASImage.cxx:947
 TASImage.cxx:948
 TASImage.cxx:949
 TASImage.cxx:950
 TASImage.cxx:951
 TASImage.cxx:952
 TASImage.cxx:953
 TASImage.cxx:954
 TASImage.cxx:955
 TASImage.cxx:956
 TASImage.cxx:957
 TASImage.cxx:958
 TASImage.cxx:959
 TASImage.cxx:960
 TASImage.cxx:961
 TASImage.cxx:962
 TASImage.cxx:963
 TASImage.cxx:964
 TASImage.cxx:965
 TASImage.cxx:966
 TASImage.cxx:967
 TASImage.cxx:968
 TASImage.cxx:969
 TASImage.cxx:970
 TASImage.cxx:971
 TASImage.cxx:972
 TASImage.cxx:973
 TASImage.cxx:974
 TASImage.cxx:975
 TASImage.cxx:976
 TASImage.cxx:977
 TASImage.cxx:978
 TASImage.cxx:979
 TASImage.cxx:980
 TASImage.cxx:981
 TASImage.cxx:982
 TASImage.cxx:983
 TASImage.cxx:984
 TASImage.cxx:985
 TASImage.cxx:986
 TASImage.cxx:987
 TASImage.cxx:988
 TASImage.cxx:989
 TASImage.cxx:990
 TASImage.cxx:991
 TASImage.cxx:992
 TASImage.cxx:993
 TASImage.cxx:994
 TASImage.cxx:995
 TASImage.cxx:996
 TASImage.cxx:997
 TASImage.cxx:998
 TASImage.cxx:999
 TASImage.cxx:1000
 TASImage.cxx:1001
 TASImage.cxx:1002
 TASImage.cxx:1003
 TASImage.cxx:1004
 TASImage.cxx:1005
 TASImage.cxx:1006
 TASImage.cxx:1007
 TASImage.cxx:1008
 TASImage.cxx:1009
 TASImage.cxx:1010
 TASImage.cxx:1011
 TASImage.cxx:1012
 TASImage.cxx:1013
 TASImage.cxx:1014
 TASImage.cxx:1015
 TASImage.cxx:1016
 TASImage.cxx:1017
 TASImage.cxx:1018
 TASImage.cxx:1019
 TASImage.cxx:1020
 TASImage.cxx:1021
 TASImage.cxx:1022
 TASImage.cxx:1023
 TASImage.cxx:1024
 TASImage.cxx:1025
 TASImage.cxx:1026
 TASImage.cxx:1027
 TASImage.cxx:1028
 TASImage.cxx:1029
 TASImage.cxx:1030
 TASImage.cxx:1031
 TASImage.cxx:1032
 TASImage.cxx:1033
 TASImage.cxx:1034
 TASImage.cxx:1035
 TASImage.cxx:1036
 TASImage.cxx:1037
 TASImage.cxx:1038
 TASImage.cxx:1039
 TASImage.cxx:1040
 TASImage.cxx:1041
 TASImage.cxx:1042
 TASImage.cxx:1043
 TASImage.cxx:1044
 TASImage.cxx:1045
 TASImage.cxx:1046
 TASImage.cxx:1047
 TASImage.cxx:1048
 TASImage.cxx:1049
 TASImage.cxx:1050
 TASImage.cxx:1051
 TASImage.cxx:1052
 TASImage.cxx:1053
 TASImage.cxx:1054
 TASImage.cxx:1055
 TASImage.cxx:1056
 TASImage.cxx:1057
 TASImage.cxx:1058
 TASImage.cxx:1059
 TASImage.cxx:1060
 TASImage.cxx:1061
 TASImage.cxx:1062
 TASImage.cxx:1063
 TASImage.cxx:1064
 TASImage.cxx:1065
 TASImage.cxx:1066
 TASImage.cxx:1067
 TASImage.cxx:1068
 TASImage.cxx:1069
 TASImage.cxx:1070
 TASImage.cxx:1071
 TASImage.cxx:1072
 TASImage.cxx:1073
 TASImage.cxx:1074
 TASImage.cxx:1075
 TASImage.cxx:1076
 TASImage.cxx:1077
 TASImage.cxx:1078
 TASImage.cxx:1079
 TASImage.cxx:1080
 TASImage.cxx:1081
 TASImage.cxx:1082
 TASImage.cxx:1083
 TASImage.cxx:1084
 TASImage.cxx:1085
 TASImage.cxx:1086
 TASImage.cxx:1087
 TASImage.cxx:1088
 TASImage.cxx:1089
 TASImage.cxx:1090
 TASImage.cxx:1091
 TASImage.cxx:1092
 TASImage.cxx:1093
 TASImage.cxx:1094
 TASImage.cxx:1095
 TASImage.cxx:1096
 TASImage.cxx:1097
 TASImage.cxx:1098
 TASImage.cxx:1099
 TASImage.cxx:1100
 TASImage.cxx:1101
 TASImage.cxx:1102
 TASImage.cxx:1103
 TASImage.cxx:1104
 TASImage.cxx:1105
 TASImage.cxx:1106
 TASImage.cxx:1107
 TASImage.cxx:1108
 TASImage.cxx:1109
 TASImage.cxx:1110
 TASImage.cxx:1111
 TASImage.cxx:1112
 TASImage.cxx:1113
 TASImage.cxx:1114
 TASImage.cxx:1115
 TASImage.cxx:1116
 TASImage.cxx:1117
 TASImage.cxx:1118
 TASImage.cxx:1119
 TASImage.cxx:1120
 TASImage.cxx:1121
 TASImage.cxx:1122
 TASImage.cxx:1123
 TASImage.cxx:1124
 TASImage.cxx:1125
 TASImage.cxx:1126
 TASImage.cxx:1127
 TASImage.cxx:1128
 TASImage.cxx:1129
 TASImage.cxx:1130
 TASImage.cxx:1131
 TASImage.cxx:1132
 TASImage.cxx:1133
 TASImage.cxx:1134
 TASImage.cxx:1135
 TASImage.cxx:1136
 TASImage.cxx:1137
 TASImage.cxx:1138
 TASImage.cxx:1139
 TASImage.cxx:1140
 TASImage.cxx:1141
 TASImage.cxx:1142
 TASImage.cxx:1143
 TASImage.cxx:1144
 TASImage.cxx:1145
 TASImage.cxx:1146
 TASImage.cxx:1147
 TASImage.cxx:1148
 TASImage.cxx:1149
 TASImage.cxx:1150
 TASImage.cxx:1151
 TASImage.cxx:1152
 TASImage.cxx:1153
 TASImage.cxx:1154
 TASImage.cxx:1155
 TASImage.cxx:1156
 TASImage.cxx:1157
 TASImage.cxx:1158
 TASImage.cxx:1159
 TASImage.cxx:1160
 TASImage.cxx:1161
 TASImage.cxx:1162
 TASImage.cxx:1163
 TASImage.cxx:1164
 TASImage.cxx:1165
 TASImage.cxx:1166
 TASImage.cxx:1167
 TASImage.cxx:1168
 TASImage.cxx:1169
 TASImage.cxx:1170
 TASImage.cxx:1171
 TASImage.cxx:1172
 TASImage.cxx:1173
 TASImage.cxx:1174
 TASImage.cxx:1175
 TASImage.cxx:1176
 TASImage.cxx:1177
 TASImage.cxx:1178
 TASImage.cxx:1179
 TASImage.cxx:1180
 TASImage.cxx:1181
 TASImage.cxx:1182
 TASImage.cxx:1183
 TASImage.cxx:1184
 TASImage.cxx:1185
 TASImage.cxx:1186
 TASImage.cxx:1187
 TASImage.cxx:1188
 TASImage.cxx:1189
 TASImage.cxx:1190
 TASImage.cxx:1191
 TASImage.cxx:1192
 TASImage.cxx:1193
 TASImage.cxx:1194
 TASImage.cxx:1195
 TASImage.cxx:1196
 TASImage.cxx:1197
 TASImage.cxx:1198
 TASImage.cxx:1199
 TASImage.cxx:1200
 TASImage.cxx:1201
 TASImage.cxx:1202
 TASImage.cxx:1203
 TASImage.cxx:1204
 TASImage.cxx:1205
 TASImage.cxx:1206
 TASImage.cxx:1207
 TASImage.cxx:1208
 TASImage.cxx:1209
 TASImage.cxx:1210
 TASImage.cxx:1211
 TASImage.cxx:1212
 TASImage.cxx:1213
 TASImage.cxx:1214
 TASImage.cxx:1215
 TASImage.cxx:1216
 TASImage.cxx:1217
 TASImage.cxx:1218
 TASImage.cxx:1219
 TASImage.cxx:1220
 TASImage.cxx:1221
 TASImage.cxx:1222
 TASImage.cxx:1223
 TASImage.cxx:1224
 TASImage.cxx:1225
 TASImage.cxx:1226
 TASImage.cxx:1227
 TASImage.cxx:1228
 TASImage.cxx:1229
 TASImage.cxx:1230
 TASImage.cxx:1231
 TASImage.cxx:1232
 TASImage.cxx:1233
 TASImage.cxx:1234
 TASImage.cxx:1235
 TASImage.cxx:1236
 TASImage.cxx:1237
 TASImage.cxx:1238
 TASImage.cxx:1239
 TASImage.cxx:1240
 TASImage.cxx:1241
 TASImage.cxx:1242
 TASImage.cxx:1243
 TASImage.cxx:1244
 TASImage.cxx:1245
 TASImage.cxx:1246
 TASImage.cxx:1247
 TASImage.cxx:1248
 TASImage.cxx:1249
 TASImage.cxx:1250
 TASImage.cxx:1251
 TASImage.cxx:1252
 TASImage.cxx:1253
 TASImage.cxx:1254
 TASImage.cxx:1255
 TASImage.cxx:1256
 TASImage.cxx:1257
 TASImage.cxx:1258
 TASImage.cxx:1259
 TASImage.cxx:1260
 TASImage.cxx:1261
 TASImage.cxx:1262
 TASImage.cxx:1263
 TASImage.cxx:1264
 TASImage.cxx:1265
 TASImage.cxx:1266
 TASImage.cxx:1267
 TASImage.cxx:1268
 TASImage.cxx:1269
 TASImage.cxx:1270
 TASImage.cxx:1271
 TASImage.cxx:1272
 TASImage.cxx:1273
 TASImage.cxx:1274
 TASImage.cxx:1275
 TASImage.cxx:1276
 TASImage.cxx:1277
 TASImage.cxx:1278
 TASImage.cxx:1279
 TASImage.cxx:1280
 TASImage.cxx:1281
 TASImage.cxx:1282
 TASImage.cxx:1283
 TASImage.cxx:1284
 TASImage.cxx:1285
 TASImage.cxx:1286
 TASImage.cxx:1287
 TASImage.cxx:1288
 TASImage.cxx:1289
 TASImage.cxx:1290
 TASImage.cxx:1291
 TASImage.cxx:1292
 TASImage.cxx:1293
 TASImage.cxx:1294
 TASImage.cxx:1295
 TASImage.cxx:1296
 TASImage.cxx:1297
 TASImage.cxx:1298
 TASImage.cxx:1299
 TASImage.cxx:1300
 TASImage.cxx:1301
 TASImage.cxx:1302
 TASImage.cxx:1303
 TASImage.cxx:1304
 TASImage.cxx:1305
 TASImage.cxx:1306
 TASImage.cxx:1307
 TASImage.cxx:1308
 TASImage.cxx:1309
 TASImage.cxx:1310
 TASImage.cxx:1311
 TASImage.cxx:1312
 TASImage.cxx:1313
 TASImage.cxx:1314
 TASImage.cxx:1315
 TASImage.cxx:1316
 TASImage.cxx:1317
 TASImage.cxx:1318
 TASImage.cxx:1319
 TASImage.cxx:1320
 TASImage.cxx:1321
 TASImage.cxx:1322
 TASImage.cxx:1323
 TASImage.cxx:1324
 TASImage.cxx:1325
 TASImage.cxx:1326
 TASImage.cxx:1327
 TASImage.cxx:1328
 TASImage.cxx:1329
 TASImage.cxx:1330
 TASImage.cxx:1331
 TASImage.cxx:1332
 TASImage.cxx:1333
 TASImage.cxx:1334
 TASImage.cxx:1335
 TASImage.cxx:1336
 TASImage.cxx:1337
 TASImage.cxx:1338
 TASImage.cxx:1339
 TASImage.cxx:1340
 TASImage.cxx:1341
 TASImage.cxx:1342
 TASImage.cxx:1343
 TASImage.cxx:1344
 TASImage.cxx:1345
 TASImage.cxx:1346
 TASImage.cxx:1347
 TASImage.cxx:1348
 TASImage.cxx:1349
 TASImage.cxx:1350
 TASImage.cxx:1351
 TASImage.cxx:1352
 TASImage.cxx:1353
 TASImage.cxx:1354
 TASImage.cxx:1355
 TASImage.cxx:1356
 TASImage.cxx:1357
 TASImage.cxx:1358
 TASImage.cxx:1359
 TASImage.cxx:1360
 TASImage.cxx:1361
 TASImage.cxx:1362
 TASImage.cxx:1363
 TASImage.cxx:1364
 TASImage.cxx:1365
 TASImage.cxx:1366
 TASImage.cxx:1367
 TASImage.cxx:1368
 TASImage.cxx:1369
 TASImage.cxx:1370
 TASImage.cxx:1371
 TASImage.cxx:1372
 TASImage.cxx:1373
 TASImage.cxx:1374
 TASImage.cxx:1375
 TASImage.cxx:1376
 TASImage.cxx:1377
 TASImage.cxx:1378
 TASImage.cxx:1379
 TASImage.cxx:1380
 TASImage.cxx:1381
 TASImage.cxx:1382
 TASImage.cxx:1383
 TASImage.cxx:1384
 TASImage.cxx:1385
 TASImage.cxx:1386
 TASImage.cxx:1387
 TASImage.cxx:1388
 TASImage.cxx:1389
 TASImage.cxx:1390
 TASImage.cxx:1391
 TASImage.cxx:1392
 TASImage.cxx:1393
 TASImage.cxx:1394
 TASImage.cxx:1395
 TASImage.cxx:1396
 TASImage.cxx:1397
 TASImage.cxx:1398
 TASImage.cxx:1399
 TASImage.cxx:1400
 TASImage.cxx:1401
 TASImage.cxx:1402
 TASImage.cxx:1403
 TASImage.cxx:1404
 TASImage.cxx:1405
 TASImage.cxx:1406
 TASImage.cxx:1407
 TASImage.cxx:1408
 TASImage.cxx:1409
 TASImage.cxx:1410
 TASImage.cxx:1411
 TASImage.cxx:1412
 TASImage.cxx:1413
 TASImage.cxx:1414
 TASImage.cxx:1415
 TASImage.cxx:1416
 TASImage.cxx:1417
 TASImage.cxx:1418
 TASImage.cxx:1419
 TASImage.cxx:1420
 TASImage.cxx:1421
 TASImage.cxx:1422
 TASImage.cxx:1423
 TASImage.cxx:1424
 TASImage.cxx:1425
 TASImage.cxx:1426
 TASImage.cxx:1427
 TASImage.cxx:1428
 TASImage.cxx:1429
 TASImage.cxx:1430
 TASImage.cxx:1431
 TASImage.cxx:1432
 TASImage.cxx:1433
 TASImage.cxx:1434
 TASImage.cxx:1435
 TASImage.cxx:1436
 TASImage.cxx:1437
 TASImage.cxx:1438
 TASImage.cxx:1439
 TASImage.cxx:1440
 TASImage.cxx:1441
 TASImage.cxx:1442
 TASImage.cxx:1443
 TASImage.cxx:1444
 TASImage.cxx:1445
 TASImage.cxx:1446
 TASImage.cxx:1447
 TASImage.cxx:1448
 TASImage.cxx:1449
 TASImage.cxx:1450
 TASImage.cxx:1451
 TASImage.cxx:1452
 TASImage.cxx:1453
 TASImage.cxx:1454
 TASImage.cxx:1455
 TASImage.cxx:1456
 TASImage.cxx:1457
 TASImage.cxx:1458
 TASImage.cxx:1459
 TASImage.cxx:1460
 TASImage.cxx:1461
 TASImage.cxx:1462
 TASImage.cxx:1463
 TASImage.cxx:1464
 TASImage.cxx:1465
 TASImage.cxx:1466
 TASImage.cxx:1467
 TASImage.cxx:1468
 TASImage.cxx:1469
 TASImage.cxx:1470
 TASImage.cxx:1471
 TASImage.cxx:1472
 TASImage.cxx:1473
 TASImage.cxx:1474
 TASImage.cxx:1475
 TASImage.cxx:1476
 TASImage.cxx:1477
 TASImage.cxx:1478
 TASImage.cxx:1479
 TASImage.cxx:1480
 TASImage.cxx:1481
 TASImage.cxx:1482
 TASImage.cxx:1483
 TASImage.cxx:1484
 TASImage.cxx:1485
 TASImage.cxx:1486
 TASImage.cxx:1487
 TASImage.cxx:1488
 TASImage.cxx:1489
 TASImage.cxx:1490
 TASImage.cxx:1491
 TASImage.cxx:1492
 TASImage.cxx:1493
 TASImage.cxx:1494
 TASImage.cxx:1495
 TASImage.cxx:1496
 TASImage.cxx:1497
 TASImage.cxx:1498
 TASImage.cxx:1499
 TASImage.cxx:1500
 TASImage.cxx:1501
 TASImage.cxx:1502
 TASImage.cxx:1503
 TASImage.cxx:1504
 TASImage.cxx:1505
 TASImage.cxx:1506
 TASImage.cxx:1507
 TASImage.cxx:1508
 TASImage.cxx:1509
 TASImage.cxx:1510
 TASImage.cxx:1511
 TASImage.cxx:1512
 TASImage.cxx:1513
 TASImage.cxx:1514
 TASImage.cxx:1515
 TASImage.cxx:1516
 TASImage.cxx:1517
 TASImage.cxx:1518
 TASImage.cxx:1519
 TASImage.cxx:1520
 TASImage.cxx:1521
 TASImage.cxx:1522
 TASImage.cxx:1523
 TASImage.cxx:1524
 TASImage.cxx:1525
 TASImage.cxx:1526
 TASImage.cxx:1527
 TASImage.cxx:1528
 TASImage.cxx:1529
 TASImage.cxx:1530
 TASImage.cxx:1531
 TASImage.cxx:1532
 TASImage.cxx:1533
 TASImage.cxx:1534
 TASImage.cxx:1535
 TASImage.cxx:1536
 TASImage.cxx:1537
 TASImage.cxx:1538
 TASImage.cxx:1539
 TASImage.cxx:1540
 TASImage.cxx:1541
 TASImage.cxx:1542
 TASImage.cxx:1543
 TASImage.cxx:1544
 TASImage.cxx:1545
 TASImage.cxx:1546
 TASImage.cxx:1547
 TASImage.cxx:1548
 TASImage.cxx:1549
 TASImage.cxx:1550
 TASImage.cxx:1551
 TASImage.cxx:1552
 TASImage.cxx:1553
 TASImage.cxx:1554
 TASImage.cxx:1555
 TASImage.cxx:1556
 TASImage.cxx:1557
 TASImage.cxx:1558
 TASImage.cxx:1559
 TASImage.cxx:1560
 TASImage.cxx:1561
 TASImage.cxx:1562
 TASImage.cxx:1563
 TASImage.cxx:1564
 TASImage.cxx:1565
 TASImage.cxx:1566
 TASImage.cxx:1567
 TASImage.cxx:1568
 TASImage.cxx:1569
 TASImage.cxx:1570
 TASImage.cxx:1571
 TASImage.cxx:1572
 TASImage.cxx:1573
 TASImage.cxx:1574
 TASImage.cxx:1575
 TASImage.cxx:1576
 TASImage.cxx:1577
 TASImage.cxx:1578
 TASImage.cxx:1579
 TASImage.cxx:1580
 TASImage.cxx:1581
 TASImage.cxx:1582
 TASImage.cxx:1583
 TASImage.cxx:1584
 TASImage.cxx:1585
 TASImage.cxx:1586
 TASImage.cxx:1587
 TASImage.cxx:1588
 TASImage.cxx:1589
 TASImage.cxx:1590
 TASImage.cxx:1591
 TASImage.cxx:1592
 TASImage.cxx:1593
 TASImage.cxx:1594
 TASImage.cxx:1595
 TASImage.cxx:1596
 TASImage.cxx:1597
 TASImage.cxx:1598
 TASImage.cxx:1599
 TASImage.cxx:1600
 TASImage.cxx:1601
 TASImage.cxx:1602
 TASImage.cxx:1603
 TASImage.cxx:1604
 TASImage.cxx:1605
 TASImage.cxx:1606
 TASImage.cxx:1607
 TASImage.cxx:1608
 TASImage.cxx:1609
 TASImage.cxx:1610
 TASImage.cxx:1611
 TASImage.cxx:1612
 TASImage.cxx:1613
 TASImage.cxx:1614
 TASImage.cxx:1615
 TASImage.cxx:1616
 TASImage.cxx:1617
 TASImage.cxx:1618
 TASImage.cxx:1619
 TASImage.cxx:1620
 TASImage.cxx:1621
 TASImage.cxx:1622
 TASImage.cxx:1623
 TASImage.cxx:1624
 TASImage.cxx:1625
 TASImage.cxx:1626
 TASImage.cxx:1627
 TASImage.cxx:1628
 TASImage.cxx:1629
 TASImage.cxx:1630
 TASImage.cxx:1631
 TASImage.cxx:1632
 TASImage.cxx:1633
 TASImage.cxx:1634
 TASImage.cxx:1635
 TASImage.cxx:1636
 TASImage.cxx:1637
 TASImage.cxx:1638
 TASImage.cxx:1639
 TASImage.cxx:1640
 TASImage.cxx:1641
 TASImage.cxx:1642
 TASImage.cxx:1643
 TASImage.cxx:1644
 TASImage.cxx:1645
 TASImage.cxx:1646
 TASImage.cxx:1647
 TASImage.cxx:1648
 TASImage.cxx:1649
 TASImage.cxx:1650
 TASImage.cxx:1651
 TASImage.cxx:1652
 TASImage.cxx:1653
 TASImage.cxx:1654
 TASImage.cxx:1655
 TASImage.cxx:1656
 TASImage.cxx:1657
 TASImage.cxx:1658
 TASImage.cxx:1659
 TASImage.cxx:1660
 TASImage.cxx:1661
 TASImage.cxx:1662
 TASImage.cxx:1663
 TASImage.cxx:1664
 TASImage.cxx:1665
 TASImage.cxx:1666
 TASImage.cxx:1667
 TASImage.cxx:1668
 TASImage.cxx:1669
 TASImage.cxx:1670
 TASImage.cxx:1671
 TASImage.cxx:1672
 TASImage.cxx:1673
 TASImage.cxx:1674
 TASImage.cxx:1675
 TASImage.cxx:1676
 TASImage.cxx:1677
 TASImage.cxx:1678
 TASImage.cxx:1679
 TASImage.cxx:1680
 TASImage.cxx:1681
 TASImage.cxx:1682
 TASImage.cxx:1683
 TASImage.cxx:1684
 TASImage.cxx:1685
 TASImage.cxx:1686
 TASImage.cxx:1687
 TASImage.cxx:1688
 TASImage.cxx:1689
 TASImage.cxx:1690
 TASImage.cxx:1691
 TASImage.cxx:1692
 TASImage.cxx:1693
 TASImage.cxx:1694
 TASImage.cxx:1695
 TASImage.cxx:1696
 TASImage.cxx:1697
 TASImage.cxx:1698
 TASImage.cxx:1699
 TASImage.cxx:1700
 TASImage.cxx:1701
 TASImage.cxx:1702
 TASImage.cxx:1703
 TASImage.cxx:1704
 TASImage.cxx:1705
 TASImage.cxx:1706
 TASImage.cxx:1707
 TASImage.cxx:1708
 TASImage.cxx:1709
 TASImage.cxx:1710
 TASImage.cxx:1711
 TASImage.cxx:1712
 TASImage.cxx:1713
 TASImage.cxx:1714
 TASImage.cxx:1715
 TASImage.cxx:1716
 TASImage.cxx:1717
 TASImage.cxx:1718
 TASImage.cxx:1719
 TASImage.cxx:1720
 TASImage.cxx:1721
 TASImage.cxx:1722
 TASImage.cxx:1723
 TASImage.cxx:1724
 TASImage.cxx:1725
 TASImage.cxx:1726
 TASImage.cxx:1727
 TASImage.cxx:1728
 TASImage.cxx:1729
 TASImage.cxx:1730
 TASImage.cxx:1731
 TASImage.cxx:1732
 TASImage.cxx:1733
 TASImage.cxx:1734
 TASImage.cxx:1735
 TASImage.cxx:1736
 TASImage.cxx:1737
 TASImage.cxx:1738
 TASImage.cxx:1739
 TASImage.cxx:1740
 TASImage.cxx:1741
 TASImage.cxx:1742
 TASImage.cxx:1743
 TASImage.cxx:1744
 TASImage.cxx:1745
 TASImage.cxx:1746
 TASImage.cxx:1747
 TASImage.cxx:1748
 TASImage.cxx:1749
 TASImage.cxx:1750
 TASImage.cxx:1751
 TASImage.cxx:1752
 TASImage.cxx:1753
 TASImage.cxx:1754
 TASImage.cxx:1755
 TASImage.cxx:1756
 TASImage.cxx:1757
 TASImage.cxx:1758
 TASImage.cxx:1759
 TASImage.cxx:1760
 TASImage.cxx:1761
 TASImage.cxx:1762
 TASImage.cxx:1763
 TASImage.cxx:1764
 TASImage.cxx:1765
 TASImage.cxx:1766
 TASImage.cxx:1767
 TASImage.cxx:1768
 TASImage.cxx:1769
 TASImage.cxx:1770
 TASImage.cxx:1771
 TASImage.cxx:1772
 TASImage.cxx:1773
 TASImage.cxx:1774
 TASImage.cxx:1775
 TASImage.cxx:1776
 TASImage.cxx:1777
 TASImage.cxx:1778
 TASImage.cxx:1779
 TASImage.cxx:1780
 TASImage.cxx:1781
 TASImage.cxx:1782
 TASImage.cxx:1783
 TASImage.cxx:1784
 TASImage.cxx:1785
 TASImage.cxx:1786
 TASImage.cxx:1787
 TASImage.cxx:1788
 TASImage.cxx:1789
 TASImage.cxx:1790
 TASImage.cxx:1791
 TASImage.cxx:1792
 TASImage.cxx:1793
 TASImage.cxx:1794
 TASImage.cxx:1795
 TASImage.cxx:1796
 TASImage.cxx:1797
 TASImage.cxx:1798
 TASImage.cxx:1799
 TASImage.cxx:1800
 TASImage.cxx:1801
 TASImage.cxx:1802
 TASImage.cxx:1803
 TASImage.cxx:1804
 TASImage.cxx:1805
 TASImage.cxx:1806
 TASImage.cxx:1807
 TASImage.cxx:1808
 TASImage.cxx:1809
 TASImage.cxx:1810
 TASImage.cxx:1811
 TASImage.cxx:1812
 TASImage.cxx:1813
 TASImage.cxx:1814
 TASImage.cxx:1815
 TASImage.cxx:1816
 TASImage.cxx:1817
 TASImage.cxx:1818
 TASImage.cxx:1819
 TASImage.cxx:1820
 TASImage.cxx:1821
 TASImage.cxx:1822
 TASImage.cxx:1823
 TASImage.cxx:1824
 TASImage.cxx:1825
 TASImage.cxx:1826
 TASImage.cxx:1827
 TASImage.cxx:1828
 TASImage.cxx:1829
 TASImage.cxx:1830
 TASImage.cxx:1831
 TASImage.cxx:1832
 TASImage.cxx:1833
 TASImage.cxx:1834
 TASImage.cxx:1835
 TASImage.cxx:1836
 TASImage.cxx:1837
 TASImage.cxx:1838
 TASImage.cxx:1839
 TASImage.cxx:1840
 TASImage.cxx:1841
 TASImage.cxx:1842
 TASImage.cxx:1843
 TASImage.cxx:1844
 TASImage.cxx:1845
 TASImage.cxx:1846
 TASImage.cxx:1847
 TASImage.cxx:1848
 TASImage.cxx:1849
 TASImage.cxx:1850
 TASImage.cxx:1851
 TASImage.cxx:1852
 TASImage.cxx:1853
 TASImage.cxx:1854
 TASImage.cxx:1855
 TASImage.cxx:1856
 TASImage.cxx:1857
 TASImage.cxx:1858
 TASImage.cxx:1859
 TASImage.cxx:1860
 TASImage.cxx:1861
 TASImage.cxx:1862
 TASImage.cxx:1863
 TASImage.cxx:1864
 TASImage.cxx:1865
 TASImage.cxx:1866
 TASImage.cxx:1867
 TASImage.cxx:1868
 TASImage.cxx:1869
 TASImage.cxx:1870
 TASImage.cxx:1871
 TASImage.cxx:1872
 TASImage.cxx:1873
 TASImage.cxx:1874
 TASImage.cxx:1875
 TASImage.cxx:1876
 TASImage.cxx:1877
 TASImage.cxx:1878
 TASImage.cxx:1879
 TASImage.cxx:1880
 TASImage.cxx:1881
 TASImage.cxx:1882
 TASImage.cxx:1883
 TASImage.cxx:1884
 TASImage.cxx:1885
 TASImage.cxx:1886
 TASImage.cxx:1887
 TASImage.cxx:1888
 TASImage.cxx:1889
 TASImage.cxx:1890
 TASImage.cxx:1891
 TASImage.cxx:1892
 TASImage.cxx:1893
 TASImage.cxx:1894
 TASImage.cxx:1895
 TASImage.cxx:1896
 TASImage.cxx:1897
 TASImage.cxx:1898
 TASImage.cxx:1899
 TASImage.cxx:1900
 TASImage.cxx:1901
 TASImage.cxx:1902
 TASImage.cxx:1903
 TASImage.cxx:1904
 TASImage.cxx:1905
 TASImage.cxx:1906
 TASImage.cxx:1907
 TASImage.cxx:1908
 TASImage.cxx:1909
 TASImage.cxx:1910
 TASImage.cxx:1911
 TASImage.cxx:1912
 TASImage.cxx:1913
 TASImage.cxx:1914
 TASImage.cxx:1915
 TASImage.cxx:1916
 TASImage.cxx:1917
 TASImage.cxx:1918
 TASImage.cxx:1919
 TASImage.cxx:1920
 TASImage.cxx:1921
 TASImage.cxx:1922
 TASImage.cxx:1923
 TASImage.cxx:1924
 TASImage.cxx:1925
 TASImage.cxx:1926
 TASImage.cxx:1927
 TASImage.cxx:1928
 TASImage.cxx:1929
 TASImage.cxx:1930
 TASImage.cxx:1931
 TASImage.cxx:1932
 TASImage.cxx:1933
 TASImage.cxx:1934
 TASImage.cxx:1935
 TASImage.cxx:1936
 TASImage.cxx:1937
 TASImage.cxx:1938
 TASImage.cxx:1939
 TASImage.cxx:1940
 TASImage.cxx:1941
 TASImage.cxx:1942
 TASImage.cxx:1943
 TASImage.cxx:1944
 TASImage.cxx:1945
 TASImage.cxx:1946
 TASImage.cxx:1947
 TASImage.cxx:1948
 TASImage.cxx:1949
 TASImage.cxx:1950
 TASImage.cxx:1951
 TASImage.cxx:1952
 TASImage.cxx:1953
 TASImage.cxx:1954
 TASImage.cxx:1955
 TASImage.cxx:1956
 TASImage.cxx:1957
 TASImage.cxx:1958
 TASImage.cxx:1959
 TASImage.cxx:1960
 TASImage.cxx:1961
 TASImage.cxx:1962
 TASImage.cxx:1963
 TASImage.cxx:1964
 TASImage.cxx:1965
 TASImage.cxx:1966
 TASImage.cxx:1967
 TASImage.cxx:1968
 TASImage.cxx:1969
 TASImage.cxx:1970
 TASImage.cxx:1971
 TASImage.cxx:1972
 TASImage.cxx:1973
 TASImage.cxx:1974
 TASImage.cxx:1975
 TASImage.cxx:1976
 TASImage.cxx:1977
 TASImage.cxx:1978
 TASImage.cxx:1979
 TASImage.cxx:1980
 TASImage.cxx:1981
 TASImage.cxx:1982
 TASImage.cxx:1983
 TASImage.cxx:1984
 TASImage.cxx:1985
 TASImage.cxx:1986
 TASImage.cxx:1987
 TASImage.cxx:1988
 TASImage.cxx:1989
 TASImage.cxx:1990
 TASImage.cxx:1991
 TASImage.cxx:1992
 TASImage.cxx:1993
 TASImage.cxx:1994
 TASImage.cxx:1995
 TASImage.cxx:1996
 TASImage.cxx:1997
 TASImage.cxx:1998
 TASImage.cxx:1999
 TASImage.cxx:2000
 TASImage.cxx:2001
 TASImage.cxx:2002
 TASImage.cxx:2003
 TASImage.cxx:2004
 TASImage.cxx:2005
 TASImage.cxx:2006
 TASImage.cxx:2007
 TASImage.cxx:2008
 TASImage.cxx:2009
 TASImage.cxx:2010
 TASImage.cxx:2011
 TASImage.cxx:2012
 TASImage.cxx:2013
 TASImage.cxx:2014
 TASImage.cxx:2015
 TASImage.cxx:2016
 TASImage.cxx:2017
 TASImage.cxx:2018
 TASImage.cxx:2019
 TASImage.cxx:2020
 TASImage.cxx:2021
 TASImage.cxx:2022
 TASImage.cxx:2023
 TASImage.cxx:2024
 TASImage.cxx:2025
 TASImage.cxx:2026
 TASImage.cxx:2027
 TASImage.cxx:2028
 TASImage.cxx:2029
 TASImage.cxx:2030
 TASImage.cxx:2031
 TASImage.cxx:2032
 TASImage.cxx:2033
 TASImage.cxx:2034
 TASImage.cxx:2035
 TASImage.cxx:2036
 TASImage.cxx:2037
 TASImage.cxx:2038
 TASImage.cxx:2039
 TASImage.cxx:2040
 TASImage.cxx:2041
 TASImage.cxx:2042
 TASImage.cxx:2043
 TASImage.cxx:2044
 TASImage.cxx:2045
 TASImage.cxx:2046
 TASImage.cxx:2047
 TASImage.cxx:2048
 TASImage.cxx:2049
 TASImage.cxx:2050
 TASImage.cxx:2051
 TASImage.cxx:2052
 TASImage.cxx:2053
 TASImage.cxx:2054
 TASImage.cxx:2055
 TASImage.cxx:2056
 TASImage.cxx:2057
 TASImage.cxx:2058
 TASImage.cxx:2059
 TASImage.cxx:2060
 TASImage.cxx:2061
 TASImage.cxx:2062
 TASImage.cxx:2063
 TASImage.cxx:2064
 TASImage.cxx:2065
 TASImage.cxx:2066
 TASImage.cxx:2067
 TASImage.cxx:2068
 TASImage.cxx:2069
 TASImage.cxx:2070
 TASImage.cxx:2071
 TASImage.cxx:2072
 TASImage.cxx:2073
 TASImage.cxx:2074
 TASImage.cxx:2075
 TASImage.cxx:2076
 TASImage.cxx:2077
 TASImage.cxx:2078
 TASImage.cxx:2079
 TASImage.cxx:2080
 TASImage.cxx:2081
 TASImage.cxx:2082
 TASImage.cxx:2083
 TASImage.cxx:2084
 TASImage.cxx:2085
 TASImage.cxx:2086
 TASImage.cxx:2087
 TASImage.cxx:2088
 TASImage.cxx:2089
 TASImage.cxx:2090
 TASImage.cxx:2091
 TASImage.cxx:2092
 TASImage.cxx:2093
 TASImage.cxx:2094
 TASImage.cxx:2095
 TASImage.cxx:2096
 TASImage.cxx:2097
 TASImage.cxx:2098
 TASImage.cxx:2099
 TASImage.cxx:2100
 TASImage.cxx:2101
 TASImage.cxx:2102
 TASImage.cxx:2103
 TASImage.cxx:2104
 TASImage.cxx:2105
 TASImage.cxx:2106
 TASImage.cxx:2107
 TASImage.cxx:2108
 TASImage.cxx:2109
 TASImage.cxx:2110
 TASImage.cxx:2111
 TASImage.cxx:2112
 TASImage.cxx:2113
 TASImage.cxx:2114
 TASImage.cxx:2115
 TASImage.cxx:2116
 TASImage.cxx:2117
 TASImage.cxx:2118
 TASImage.cxx:2119
 TASImage.cxx:2120
 TASImage.cxx:2121
 TASImage.cxx:2122
 TASImage.cxx:2123
 TASImage.cxx:2124
 TASImage.cxx:2125
 TASImage.cxx:2126
 TASImage.cxx:2127
 TASImage.cxx:2128
 TASImage.cxx:2129
 TASImage.cxx:2130
 TASImage.cxx:2131
 TASImage.cxx:2132
 TASImage.cxx:2133
 TASImage.cxx:2134
 TASImage.cxx:2135
 TASImage.cxx:2136
 TASImage.cxx:2137
 TASImage.cxx:2138
 TASImage.cxx:2139
 TASImage.cxx:2140
 TASImage.cxx:2141
 TASImage.cxx:2142
 TASImage.cxx:2143
 TASImage.cxx:2144
 TASImage.cxx:2145
 TASImage.cxx:2146
 TASImage.cxx:2147
 TASImage.cxx:2148
 TASImage.cxx:2149
 TASImage.cxx:2150
 TASImage.cxx:2151
 TASImage.cxx:2152
 TASImage.cxx:2153
 TASImage.cxx:2154
 TASImage.cxx:2155
 TASImage.cxx:2156
 TASImage.cxx:2157
 TASImage.cxx:2158
 TASImage.cxx:2159
 TASImage.cxx:2160
 TASImage.cxx:2161
 TASImage.cxx:2162
 TASImage.cxx:2163
 TASImage.cxx:2164
 TASImage.cxx:2165
 TASImage.cxx:2166
 TASImage.cxx:2167
 TASImage.cxx:2168
 TASImage.cxx:2169
 TASImage.cxx:2170
 TASImage.cxx:2171
 TASImage.cxx:2172
 TASImage.cxx:2173
 TASImage.cxx:2174
 TASImage.cxx:2175
 TASImage.cxx:2176
 TASImage.cxx:2177
 TASImage.cxx:2178
 TASImage.cxx:2179
 TASImage.cxx:2180
 TASImage.cxx:2181
 TASImage.cxx:2182
 TASImage.cxx:2183
 TASImage.cxx:2184
 TASImage.cxx:2185
 TASImage.cxx:2186
 TASImage.cxx:2187
 TASImage.cxx:2188
 TASImage.cxx:2189
 TASImage.cxx:2190
 TASImage.cxx:2191
 TASImage.cxx:2192
 TASImage.cxx:2193
 TASImage.cxx:2194
 TASImage.cxx:2195
 TASImage.cxx:2196
 TASImage.cxx:2197
 TASImage.cxx:2198
 TASImage.cxx:2199
 TASImage.cxx:2200
 TASImage.cxx:2201
 TASImage.cxx:2202
 TASImage.cxx:2203
 TASImage.cxx:2204
 TASImage.cxx:2205
 TASImage.cxx:2206
 TASImage.cxx:2207
 TASImage.cxx:2208
 TASImage.cxx:2209
 TASImage.cxx:2210
 TASImage.cxx:2211
 TASImage.cxx:2212
 TASImage.cxx:2213
 TASImage.cxx:2214
 TASImage.cxx:2215
 TASImage.cxx:2216
 TASImage.cxx:2217
 TASImage.cxx:2218
 TASImage.cxx:2219
 TASImage.cxx:2220
 TASImage.cxx:2221
 TASImage.cxx:2222
 TASImage.cxx:2223
 TASImage.cxx:2224
 TASImage.cxx:2225
 TASImage.cxx:2226
 TASImage.cxx:2227
 TASImage.cxx:2228
 TASImage.cxx:2229
 TASImage.cxx:2230
 TASImage.cxx:2231
 TASImage.cxx:2232
 TASImage.cxx:2233
 TASImage.cxx:2234
 TASImage.cxx:2235
 TASImage.cxx:2236
 TASImage.cxx:2237
 TASImage.cxx:2238
 TASImage.cxx:2239
 TASImage.cxx:2240
 TASImage.cxx:2241
 TASImage.cxx:2242
 TASImage.cxx:2243
 TASImage.cxx:2244
 TASImage.cxx:2245
 TASImage.cxx:2246
 TASImage.cxx:2247
 TASImage.cxx:2248
 TASImage.cxx:2249
 TASImage.cxx:2250
 TASImage.cxx:2251
 TASImage.cxx:2252
 TASImage.cxx:2253
 TASImage.cxx:2254
 TASImage.cxx:2255
 TASImage.cxx:2256
 TASImage.cxx:2257
 TASImage.cxx:2258
 TASImage.cxx:2259
 TASImage.cxx:2260
 TASImage.cxx:2261
 TASImage.cxx:2262
 TASImage.cxx:2263
 TASImage.cxx:2264
 TASImage.cxx:2265
 TASImage.cxx:2266
 TASImage.cxx:2267
 TASImage.cxx:2268
 TASImage.cxx:2269
 TASImage.cxx:2270
 TASImage.cxx:2271
 TASImage.cxx:2272
 TASImage.cxx:2273
 TASImage.cxx:2274
 TASImage.cxx:2275
 TASImage.cxx:2276
 TASImage.cxx:2277
 TASImage.cxx:2278
 TASImage.cxx:2279
 TASImage.cxx:2280
 TASImage.cxx:2281
 TASImage.cxx:2282
 TASImage.cxx:2283
 TASImage.cxx:2284
 TASImage.cxx:2285
 TASImage.cxx:2286
 TASImage.cxx:2287
 TASImage.cxx:2288
 TASImage.cxx:2289
 TASImage.cxx:2290
 TASImage.cxx:2291
 TASImage.cxx:2292
 TASImage.cxx:2293
 TASImage.cxx:2294
 TASImage.cxx:2295
 TASImage.cxx:2296
 TASImage.cxx:2297
 TASImage.cxx:2298
 TASImage.cxx:2299
 TASImage.cxx:2300
 TASImage.cxx:2301
 TASImage.cxx:2302
 TASImage.cxx:2303
 TASImage.cxx:2304
 TASImage.cxx:2305
 TASImage.cxx:2306
 TASImage.cxx:2307
 TASImage.cxx:2308
 TASImage.cxx:2309
 TASImage.cxx:2310
 TASImage.cxx:2311
 TASImage.cxx:2312
 TASImage.cxx:2313
 TASImage.cxx:2314
 TASImage.cxx:2315
 TASImage.cxx:2316
 TASImage.cxx:2317
 TASImage.cxx:2318
 TASImage.cxx:2319
 TASImage.cxx:2320
 TASImage.cxx:2321
 TASImage.cxx:2322
 TASImage.cxx:2323
 TASImage.cxx:2324
 TASImage.cxx:2325
 TASImage.cxx:2326
 TASImage.cxx:2327
 TASImage.cxx:2328
 TASImage.cxx:2329
 TASImage.cxx:2330
 TASImage.cxx:2331
 TASImage.cxx:2332
 TASImage.cxx:2333
 TASImage.cxx:2334
 TASImage.cxx:2335
 TASImage.cxx:2336
 TASImage.cxx:2337
 TASImage.cxx:2338
 TASImage.cxx:2339
 TASImage.cxx:2340
 TASImage.cxx:2341
 TASImage.cxx:2342
 TASImage.cxx:2343
 TASImage.cxx:2344
 TASImage.cxx:2345
 TASImage.cxx:2346
 TASImage.cxx:2347
 TASImage.cxx:2348
 TASImage.cxx:2349
 TASImage.cxx:2350
 TASImage.cxx:2351
 TASImage.cxx:2352
 TASImage.cxx:2353
 TASImage.cxx:2354
 TASImage.cxx:2355
 TASImage.cxx:2356
 TASImage.cxx:2357
 TASImage.cxx:2358
 TASImage.cxx:2359
 TASImage.cxx:2360
 TASImage.cxx:2361
 TASImage.cxx:2362
 TASImage.cxx:2363
 TASImage.cxx:2364
 TASImage.cxx:2365
 TASImage.cxx:2366
 TASImage.cxx:2367
 TASImage.cxx:2368
 TASImage.cxx:2369
 TASImage.cxx:2370
 TASImage.cxx:2371
 TASImage.cxx:2372
 TASImage.cxx:2373
 TASImage.cxx:2374
 TASImage.cxx:2375
 TASImage.cxx:2376
 TASImage.cxx:2377
 TASImage.cxx:2378
 TASImage.cxx:2379
 TASImage.cxx:2380
 TASImage.cxx:2381
 TASImage.cxx:2382
 TASImage.cxx:2383
 TASImage.cxx:2384
 TASImage.cxx:2385
 TASImage.cxx:2386
 TASImage.cxx:2387
 TASImage.cxx:2388
 TASImage.cxx:2389
 TASImage.cxx:2390
 TASImage.cxx:2391
 TASImage.cxx:2392
 TASImage.cxx:2393
 TASImage.cxx:2394
 TASImage.cxx:2395
 TASImage.cxx:2396
 TASImage.cxx:2397
 TASImage.cxx:2398
 TASImage.cxx:2399
 TASImage.cxx:2400
 TASImage.cxx:2401
 TASImage.cxx:2402
 TASImage.cxx:2403
 TASImage.cxx:2404
 TASImage.cxx:2405
 TASImage.cxx:2406
 TASImage.cxx:2407
 TASImage.cxx:2408
 TASImage.cxx:2409
 TASImage.cxx:2410
 TASImage.cxx:2411
 TASImage.cxx:2412
 TASImage.cxx:2413
 TASImage.cxx:2414
 TASImage.cxx:2415
 TASImage.cxx:2416
 TASImage.cxx:2417
 TASImage.cxx:2418
 TASImage.cxx:2419
 TASImage.cxx:2420
 TASImage.cxx:2421
 TASImage.cxx:2422
 TASImage.cxx:2423
 TASImage.cxx:2424
 TASImage.cxx:2425
 TASImage.cxx:2426
 TASImage.cxx:2427
 TASImage.cxx:2428
 TASImage.cxx:2429
 TASImage.cxx:2430
 TASImage.cxx:2431
 TASImage.cxx:2432
 TASImage.cxx:2433
 TASImage.cxx:2434
 TASImage.cxx:2435
 TASImage.cxx:2436
 TASImage.cxx:2437
 TASImage.cxx:2438
 TASImage.cxx:2439
 TASImage.cxx:2440
 TASImage.cxx:2441
 TASImage.cxx:2442
 TASImage.cxx:2443
 TASImage.cxx:2444
 TASImage.cxx:2445
 TASImage.cxx:2446
 TASImage.cxx:2447
 TASImage.cxx:2448
 TASImage.cxx:2449
 TASImage.cxx:2450
 TASImage.cxx:2451
 TASImage.cxx:2452
 TASImage.cxx:2453
 TASImage.cxx:2454
 TASImage.cxx:2455
 TASImage.cxx:2456
 TASImage.cxx:2457
 TASImage.cxx:2458
 TASImage.cxx:2459
 TASImage.cxx:2460
 TASImage.cxx:2461
 TASImage.cxx:2462
 TASImage.cxx:2463
 TASImage.cxx:2464
 TASImage.cxx:2465
 TASImage.cxx:2466
 TASImage.cxx:2467
 TASImage.cxx:2468
 TASImage.cxx:2469
 TASImage.cxx:2470
 TASImage.cxx:2471
 TASImage.cxx:2472
 TASImage.cxx:2473
 TASImage.cxx:2474
 TASImage.cxx:2475
 TASImage.cxx:2476
 TASImage.cxx:2477
 TASImage.cxx:2478
 TASImage.cxx:2479
 TASImage.cxx:2480
 TASImage.cxx:2481
 TASImage.cxx:2482
 TASImage.cxx:2483
 TASImage.cxx:2484
 TASImage.cxx:2485
 TASImage.cxx:2486
 TASImage.cxx:2487
 TASImage.cxx:2488
 TASImage.cxx:2489
 TASImage.cxx:2490
 TASImage.cxx:2491
 TASImage.cxx:2492
 TASImage.cxx:2493
 TASImage.cxx:2494
 TASImage.cxx:2495
 TASImage.cxx:2496
 TASImage.cxx:2497
 TASImage.cxx:2498
 TASImage.cxx:2499
 TASImage.cxx:2500
 TASImage.cxx:2501
 TASImage.cxx:2502
 TASImage.cxx:2503
 TASImage.cxx:2504
 TASImage.cxx:2505
 TASImage.cxx:2506
 TASImage.cxx:2507
 TASImage.cxx:2508
 TASImage.cxx:2509
 TASImage.cxx:2510
 TASImage.cxx:2511
 TASImage.cxx:2512
 TASImage.cxx:2513
 TASImage.cxx:2514
 TASImage.cxx:2515
 TASImage.cxx:2516
 TASImage.cxx:2517
 TASImage.cxx:2518
 TASImage.cxx:2519
 TASImage.cxx:2520
 TASImage.cxx:2521
 TASImage.cxx:2522
 TASImage.cxx:2523
 TASImage.cxx:2524
 TASImage.cxx:2525
 TASImage.cxx:2526
 TASImage.cxx:2527
 TASImage.cxx:2528
 TASImage.cxx:2529
 TASImage.cxx:2530
 TASImage.cxx:2531
 TASImage.cxx:2532
 TASImage.cxx:2533
 TASImage.cxx:2534
 TASImage.cxx:2535
 TASImage.cxx:2536
 TASImage.cxx:2537
 TASImage.cxx:2538
 TASImage.cxx:2539
 TASImage.cxx:2540
 TASImage.cxx:2541
 TASImage.cxx:2542
 TASImage.cxx:2543
 TASImage.cxx:2544
 TASImage.cxx:2545
 TASImage.cxx:2546
 TASImage.cxx:2547
 TASImage.cxx:2548
 TASImage.cxx:2549
 TASImage.cxx:2550
 TASImage.cxx:2551
 TASImage.cxx:2552
 TASImage.cxx:2553
 TASImage.cxx:2554
 TASImage.cxx:2555
 TASImage.cxx:2556
 TASImage.cxx:2557
 TASImage.cxx:2558
 TASImage.cxx:2559
 TASImage.cxx:2560
 TASImage.cxx:2561
 TASImage.cxx:2562
 TASImage.cxx:2563
 TASImage.cxx:2564
 TASImage.cxx:2565
 TASImage.cxx:2566
 TASImage.cxx:2567
 TASImage.cxx:2568
 TASImage.cxx:2569
 TASImage.cxx:2570
 TASImage.cxx:2571
 TASImage.cxx:2572
 TASImage.cxx:2573
 TASImage.cxx:2574
 TASImage.cxx:2575
 TASImage.cxx:2576
 TASImage.cxx:2577
 TASImage.cxx:2578
 TASImage.cxx:2579
 TASImage.cxx:2580
 TASImage.cxx:2581
 TASImage.cxx:2582
 TASImage.cxx:2583
 TASImage.cxx:2584
 TASImage.cxx:2585
 TASImage.cxx:2586
 TASImage.cxx:2587
 TASImage.cxx:2588
 TASImage.cxx:2589
 TASImage.cxx:2590
 TASImage.cxx:2591
 TASImage.cxx:2592
 TASImage.cxx:2593
 TASImage.cxx:2594
 TASImage.cxx:2595
 TASImage.cxx:2596
 TASImage.cxx:2597
 TASImage.cxx:2598
 TASImage.cxx:2599
 TASImage.cxx:2600
 TASImage.cxx:2601
 TASImage.cxx:2602
 TASImage.cxx:2603
 TASImage.cxx:2604
 TASImage.cxx:2605
 TASImage.cxx:2606
 TASImage.cxx:2607
 TASImage.cxx:2608
 TASImage.cxx:2609
 TASImage.cxx:2610
 TASImage.cxx:2611
 TASImage.cxx:2612
 TASImage.cxx:2613
 TASImage.cxx:2614
 TASImage.cxx:2615
 TASImage.cxx:2616
 TASImage.cxx:2617
 TASImage.cxx:2618
 TASImage.cxx:2619
 TASImage.cxx:2620
 TASImage.cxx:2621
 TASImage.cxx:2622
 TASImage.cxx:2623
 TASImage.cxx:2624
 TASImage.cxx:2625
 TASImage.cxx:2626
 TASImage.cxx:2627
 TASImage.cxx:2628
 TASImage.cxx:2629
 TASImage.cxx:2630
 TASImage.cxx:2631
 TASImage.cxx:2632
 TASImage.cxx:2633
 TASImage.cxx:2634
 TASImage.cxx:2635
 TASImage.cxx:2636
 TASImage.cxx:2637
 TASImage.cxx:2638
 TASImage.cxx:2639
 TASImage.cxx:2640
 TASImage.cxx:2641
 TASImage.cxx:2642
 TASImage.cxx:2643
 TASImage.cxx:2644
 TASImage.cxx:2645
 TASImage.cxx:2646
 TASImage.cxx:2647
 TASImage.cxx:2648
 TASImage.cxx:2649
 TASImage.cxx:2650
 TASImage.cxx:2651
 TASImage.cxx:2652
 TASImage.cxx:2653
 TASImage.cxx:2654
 TASImage.cxx:2655
 TASImage.cxx:2656
 TASImage.cxx:2657
 TASImage.cxx:2658
 TASImage.cxx:2659
 TASImage.cxx:2660
 TASImage.cxx:2661
 TASImage.cxx:2662
 TASImage.cxx:2663
 TASImage.cxx:2664
 TASImage.cxx:2665
 TASImage.cxx:2666
 TASImage.cxx:2667
 TASImage.cxx:2668
 TASImage.cxx:2669
 TASImage.cxx:2670
 TASImage.cxx:2671
 TASImage.cxx:2672
 TASImage.cxx:2673
 TASImage.cxx:2674
 TASImage.cxx:2675
 TASImage.cxx:2676
 TASImage.cxx:2677
 TASImage.cxx:2678
 TASImage.cxx:2679
 TASImage.cxx:2680
 TASImage.cxx:2681
 TASImage.cxx:2682
 TASImage.cxx:2683
 TASImage.cxx:2684
 TASImage.cxx:2685
 TASImage.cxx:2686
 TASImage.cxx:2687
 TASImage.cxx:2688
 TASImage.cxx:2689
 TASImage.cxx:2690
 TASImage.cxx:2691
 TASImage.cxx:2692
 TASImage.cxx:2693
 TASImage.cxx:2694
 TASImage.cxx:2695
 TASImage.cxx:2696
 TASImage.cxx:2697
 TASImage.cxx:2698
 TASImage.cxx:2699
 TASImage.cxx:2700
 TASImage.cxx:2701
 TASImage.cxx:2702
 TASImage.cxx:2703
 TASImage.cxx:2704
 TASImage.cxx:2705
 TASImage.cxx:2706
 TASImage.cxx:2707
 TASImage.cxx:2708
 TASImage.cxx:2709
 TASImage.cxx:2710
 TASImage.cxx:2711
 TASImage.cxx:2712
 TASImage.cxx:2713
 TASImage.cxx:2714
 TASImage.cxx:2715
 TASImage.cxx:2716
 TASImage.cxx:2717
 TASImage.cxx:2718
 TASImage.cxx:2719
 TASImage.cxx:2720
 TASImage.cxx:2721
 TASImage.cxx:2722
 TASImage.cxx:2723
 TASImage.cxx:2724
 TASImage.cxx:2725
 TASImage.cxx:2726
 TASImage.cxx:2727
 TASImage.cxx:2728
 TASImage.cxx:2729
 TASImage.cxx:2730
 TASImage.cxx:2731
 TASImage.cxx:2732
 TASImage.cxx:2733
 TASImage.cxx:2734
 TASImage.cxx:2735
 TASImage.cxx:2736
 TASImage.cxx:2737
 TASImage.cxx:2738
 TASImage.cxx:2739
 TASImage.cxx:2740
 TASImage.cxx:2741
 TASImage.cxx:2742
 TASImage.cxx:2743
 TASImage.cxx:2744
 TASImage.cxx:2745
 TASImage.cxx:2746
 TASImage.cxx:2747
 TASImage.cxx:2748
 TASImage.cxx:2749
 TASImage.cxx:2750
 TASImage.cxx:2751
 TASImage.cxx:2752
 TASImage.cxx:2753
 TASImage.cxx:2754
 TASImage.cxx:2755
 TASImage.cxx:2756
 TASImage.cxx:2757
 TASImage.cxx:2758
 TASImage.cxx:2759
 TASImage.cxx:2760
 TASImage.cxx:2761
 TASImage.cxx:2762
 TASImage.cxx:2763
 TASImage.cxx:2764
 TASImage.cxx:2765
 TASImage.cxx:2766
 TASImage.cxx:2767
 TASImage.cxx:2768
 TASImage.cxx:2769
 TASImage.cxx:2770
 TASImage.cxx:2771
 TASImage.cxx:2772
 TASImage.cxx:2773
 TASImage.cxx:2774
 TASImage.cxx:2775
 TASImage.cxx:2776
 TASImage.cxx:2777
 TASImage.cxx:2778
 TASImage.cxx:2779
 TASImage.cxx:2780
 TASImage.cxx:2781
 TASImage.cxx:2782
 TASImage.cxx:2783
 TASImage.cxx:2784
 TASImage.cxx:2785
 TASImage.cxx:2786
 TASImage.cxx:2787
 TASImage.cxx:2788
 TASImage.cxx:2789
 TASImage.cxx:2790
 TASImage.cxx:2791
 TASImage.cxx:2792
 TASImage.cxx:2793
 TASImage.cxx:2794
 TASImage.cxx:2795
 TASImage.cxx:2796
 TASImage.cxx:2797
 TASImage.cxx:2798
 TASImage.cxx:2799
 TASImage.cxx:2800
 TASImage.cxx:2801
 TASImage.cxx:2802
 TASImage.cxx:2803
 TASImage.cxx:2804
 TASImage.cxx:2805
 TASImage.cxx:2806
 TASImage.cxx:2807
 TASImage.cxx:2808
 TASImage.cxx:2809
 TASImage.cxx:2810
 TASImage.cxx:2811
 TASImage.cxx:2812
 TASImage.cxx:2813
 TASImage.cxx:2814
 TASImage.cxx:2815
 TASImage.cxx:2816
 TASImage.cxx:2817
 TASImage.cxx:2818
 TASImage.cxx:2819
 TASImage.cxx:2820
 TASImage.cxx:2821
 TASImage.cxx:2822
 TASImage.cxx:2823
 TASImage.cxx:2824
 TASImage.cxx:2825
 TASImage.cxx:2826
 TASImage.cxx:2827
 TASImage.cxx:2828
 TASImage.cxx:2829
 TASImage.cxx:2830
 TASImage.cxx:2831
 TASImage.cxx:2832
 TASImage.cxx:2833
 TASImage.cxx:2834
 TASImage.cxx:2835
 TASImage.cxx:2836
 TASImage.cxx:2837
 TASImage.cxx:2838
 TASImage.cxx:2839
 TASImage.cxx:2840
 TASImage.cxx:2841
 TASImage.cxx:2842
 TASImage.cxx:2843
 TASImage.cxx:2844
 TASImage.cxx:2845
 TASImage.cxx:2846
 TASImage.cxx:2847
 TASImage.cxx:2848
 TASImage.cxx:2849
 TASImage.cxx:2850
 TASImage.cxx:2851
 TASImage.cxx:2852
 TASImage.cxx:2853
 TASImage.cxx:2854
 TASImage.cxx:2855
 TASImage.cxx:2856
 TASImage.cxx:2857
 TASImage.cxx:2858
 TASImage.cxx:2859
 TASImage.cxx:2860
 TASImage.cxx:2861
 TASImage.cxx:2862
 TASImage.cxx:2863
 TASImage.cxx:2864
 TASImage.cxx:2865
 TASImage.cxx:2866
 TASImage.cxx:2867
 TASImage.cxx:2868
 TASImage.cxx:2869
 TASImage.cxx:2870
 TASImage.cxx:2871
 TASImage.cxx:2872
 TASImage.cxx:2873
 TASImage.cxx:2874
 TASImage.cxx:2875
 TASImage.cxx:2876
 TASImage.cxx:2877
 TASImage.cxx:2878
 TASImage.cxx:2879
 TASImage.cxx:2880
 TASImage.cxx:2881
 TASImage.cxx:2882
 TASImage.cxx:2883
 TASImage.cxx:2884
 TASImage.cxx:2885
 TASImage.cxx:2886
 TASImage.cxx:2887
 TASImage.cxx:2888
 TASImage.cxx:2889
 TASImage.cxx:2890
 TASImage.cxx:2891
 TASImage.cxx:2892
 TASImage.cxx:2893
 TASImage.cxx:2894
 TASImage.cxx:2895
 TASImage.cxx:2896
 TASImage.cxx:2897
 TASImage.cxx:2898
 TASImage.cxx:2899
 TASImage.cxx:2900
 TASImage.cxx:2901
 TASImage.cxx:2902
 TASImage.cxx:2903
 TASImage.cxx:2904
 TASImage.cxx:2905
 TASImage.cxx:2906
 TASImage.cxx:2907
 TASImage.cxx:2908
 TASImage.cxx:2909
 TASImage.cxx:2910
 TASImage.cxx:2911
 TASImage.cxx:2912
 TASImage.cxx:2913
 TASImage.cxx:2914
 TASImage.cxx:2915
 TASImage.cxx:2916
 TASImage.cxx:2917
 TASImage.cxx:2918
 TASImage.cxx:2919
 TASImage.cxx:2920
 TASImage.cxx:2921
 TASImage.cxx:2922
 TASImage.cxx:2923
 TASImage.cxx:2924
 TASImage.cxx:2925
 TASImage.cxx:2926
 TASImage.cxx:2927
 TASImage.cxx:2928
 TASImage.cxx:2929
 TASImage.cxx:2930
 TASImage.cxx:2931
 TASImage.cxx:2932
 TASImage.cxx:2933
 TASImage.cxx:2934
 TASImage.cxx:2935
 TASImage.cxx:2936
 TASImage.cxx:2937
 TASImage.cxx:2938
 TASImage.cxx:2939
 TASImage.cxx:2940
 TASImage.cxx:2941
 TASImage.cxx:2942
 TASImage.cxx:2943
 TASImage.cxx:2944
 TASImage.cxx:2945
 TASImage.cxx:2946
 TASImage.cxx:2947
 TASImage.cxx:2948
 TASImage.cxx:2949
 TASImage.cxx:2950
 TASImage.cxx:2951
 TASImage.cxx:2952
 TASImage.cxx:2953
 TASImage.cxx:2954
 TASImage.cxx:2955
 TASImage.cxx:2956
 TASImage.cxx:2957
 TASImage.cxx:2958
 TASImage.cxx:2959
 TASImage.cxx:2960
 TASImage.cxx:2961
 TASImage.cxx:2962
 TASImage.cxx:2963
 TASImage.cxx:2964
 TASImage.cxx:2965
 TASImage.cxx:2966
 TASImage.cxx:2967
 TASImage.cxx:2968
 TASImage.cxx:2969
 TASImage.cxx:2970
 TASImage.cxx:2971
 TASImage.cxx:2972
 TASImage.cxx:2973
 TASImage.cxx:2974
 TASImage.cxx:2975
 TASImage.cxx:2976
 TASImage.cxx:2977
 TASImage.cxx:2978
 TASImage.cxx:2979
 TASImage.cxx:2980
 TASImage.cxx:2981
 TASImage.cxx:2982
 TASImage.cxx:2983
 TASImage.cxx:2984
 TASImage.cxx:2985
 TASImage.cxx:2986
 TASImage.cxx:2987
 TASImage.cxx:2988
 TASImage.cxx:2989
 TASImage.cxx:2990
 TASImage.cxx:2991
 TASImage.cxx:2992
 TASImage.cxx:2993
 TASImage.cxx:2994
 TASImage.cxx:2995
 TASImage.cxx:2996
 TASImage.cxx:2997
 TASImage.cxx:2998
 TASImage.cxx:2999
 TASImage.cxx:3000
 TASImage.cxx:3001
 TASImage.cxx:3002
 TASImage.cxx:3003
 TASImage.cxx:3004
 TASImage.cxx:3005
 TASImage.cxx:3006
 TASImage.cxx:3007
 TASImage.cxx:3008
 TASImage.cxx:3009
 TASImage.cxx:3010
 TASImage.cxx:3011
 TASImage.cxx:3012
 TASImage.cxx:3013
 TASImage.cxx:3014
 TASImage.cxx:3015
 TASImage.cxx:3016
 TASImage.cxx:3017
 TASImage.cxx:3018
 TASImage.cxx:3019
 TASImage.cxx:3020
 TASImage.cxx:3021
 TASImage.cxx:3022
 TASImage.cxx:3023
 TASImage.cxx:3024
 TASImage.cxx:3025
 TASImage.cxx:3026
 TASImage.cxx:3027
 TASImage.cxx:3028
 TASImage.cxx:3029
 TASImage.cxx:3030
 TASImage.cxx:3031
 TASImage.cxx:3032
 TASImage.cxx:3033
 TASImage.cxx:3034
 TASImage.cxx:3035
 TASImage.cxx:3036
 TASImage.cxx:3037
 TASImage.cxx:3038
 TASImage.cxx:3039
 TASImage.cxx:3040
 TASImage.cxx:3041
 TASImage.cxx:3042
 TASImage.cxx:3043
 TASImage.cxx:3044
 TASImage.cxx:3045
 TASImage.cxx:3046
 TASImage.cxx:3047
 TASImage.cxx:3048
 TASImage.cxx:3049
 TASImage.cxx:3050
 TASImage.cxx:3051
 TASImage.cxx:3052
 TASImage.cxx:3053
 TASImage.cxx:3054
 TASImage.cxx:3055
 TASImage.cxx:3056
 TASImage.cxx:3057
 TASImage.cxx:3058
 TASImage.cxx:3059
 TASImage.cxx:3060
 TASImage.cxx:3061
 TASImage.cxx:3062
 TASImage.cxx:3063
 TASImage.cxx:3064
 TASImage.cxx:3065
 TASImage.cxx:3066
 TASImage.cxx:3067
 TASImage.cxx:3068
 TASImage.cxx:3069
 TASImage.cxx:3070
 TASImage.cxx:3071
 TASImage.cxx:3072
 TASImage.cxx:3073
 TASImage.cxx:3074
 TASImage.cxx:3075
 TASImage.cxx:3076
 TASImage.cxx:3077
 TASImage.cxx:3078
 TASImage.cxx:3079
 TASImage.cxx:3080
 TASImage.cxx:3081
 TASImage.cxx:3082
 TASImage.cxx:3083
 TASImage.cxx:3084
 TASImage.cxx:3085
 TASImage.cxx:3086
 TASImage.cxx:3087
 TASImage.cxx:3088
 TASImage.cxx:3089
 TASImage.cxx:3090
 TASImage.cxx:3091
 TASImage.cxx:3092
 TASImage.cxx:3093
 TASImage.cxx:3094
 TASImage.cxx:3095
 TASImage.cxx:3096
 TASImage.cxx:3097
 TASImage.cxx:3098
 TASImage.cxx:3099
 TASImage.cxx:3100
 TASImage.cxx:3101
 TASImage.cxx:3102
 TASImage.cxx:3103
 TASImage.cxx:3104
 TASImage.cxx:3105
 TASImage.cxx:3106
 TASImage.cxx:3107
 TASImage.cxx:3108
 TASImage.cxx:3109
 TASImage.cxx:3110
 TASImage.cxx:3111
 TASImage.cxx:3112
 TASImage.cxx:3113
 TASImage.cxx:3114
 TASImage.cxx:3115
 TASImage.cxx:3116
 TASImage.cxx:3117
 TASImage.cxx:3118
 TASImage.cxx:3119
 TASImage.cxx:3120
 TASImage.cxx:3121
 TASImage.cxx:3122
 TASImage.cxx:3123
 TASImage.cxx:3124
 TASImage.cxx:3125
 TASImage.cxx:3126
 TASImage.cxx:3127
 TASImage.cxx:3128
 TASImage.cxx:3129
 TASImage.cxx:3130
 TASImage.cxx:3131
 TASImage.cxx:3132
 TASImage.cxx:3133
 TASImage.cxx:3134
 TASImage.cxx:3135
 TASImage.cxx:3136
 TASImage.cxx:3137
 TASImage.cxx:3138
 TASImage.cxx:3139
 TASImage.cxx:3140
 TASImage.cxx:3141
 TASImage.cxx:3142
 TASImage.cxx:3143
 TASImage.cxx:3144
 TASImage.cxx:3145
 TASImage.cxx:3146
 TASImage.cxx:3147
 TASImage.cxx:3148
 TASImage.cxx:3149
 TASImage.cxx:3150
 TASImage.cxx:3151
 TASImage.cxx:3152
 TASImage.cxx:3153
 TASImage.cxx:3154
 TASImage.cxx:3155
 TASImage.cxx:3156
 TASImage.cxx:3157
 TASImage.cxx:3158
 TASImage.cxx:3159
 TASImage.cxx:3160
 TASImage.cxx:3161
 TASImage.cxx:3162
 TASImage.cxx:3163
 TASImage.cxx:3164
 TASImage.cxx:3165
 TASImage.cxx:3166
 TASImage.cxx:3167
 TASImage.cxx:3168
 TASImage.cxx:3169
 TASImage.cxx:3170
 TASImage.cxx:3171
 TASImage.cxx:3172
 TASImage.cxx:3173
 TASImage.cxx:3174
 TASImage.cxx:3175
 TASImage.cxx:3176
 TASImage.cxx:3177
 TASImage.cxx:3178
 TASImage.cxx:3179
 TASImage.cxx:3180
 TASImage.cxx:3181
 TASImage.cxx:3182
 TASImage.cxx:3183
 TASImage.cxx:3184
 TASImage.cxx:3185
 TASImage.cxx:3186
 TASImage.cxx:3187
 TASImage.cxx:3188
 TASImage.cxx:3189
 TASImage.cxx:3190
 TASImage.cxx:3191
 TASImage.cxx:3192
 TASImage.cxx:3193
 TASImage.cxx:3194
 TASImage.cxx:3195
 TASImage.cxx:3196
 TASImage.cxx:3197
 TASImage.cxx:3198
 TASImage.cxx:3199
 TASImage.cxx:3200
 TASImage.cxx:3201
 TASImage.cxx:3202
 TASImage.cxx:3203
 TASImage.cxx:3204
 TASImage.cxx:3205
 TASImage.cxx:3206
 TASImage.cxx:3207
 TASImage.cxx:3208
 TASImage.cxx:3209
 TASImage.cxx:3210
 TASImage.cxx:3211
 TASImage.cxx:3212
 TASImage.cxx:3213
 TASImage.cxx:3214
 TASImage.cxx:3215
 TASImage.cxx:3216
 TASImage.cxx:3217
 TASImage.cxx:3218
 TASImage.cxx:3219
 TASImage.cxx:3220
 TASImage.cxx:3221
 TASImage.cxx:3222
 TASImage.cxx:3223
 TASImage.cxx:3224
 TASImage.cxx:3225
 TASImage.cxx:3226
 TASImage.cxx:3227
 TASImage.cxx:3228
 TASImage.cxx:3229
 TASImage.cxx:3230
 TASImage.cxx:3231
 TASImage.cxx:3232
 TASImage.cxx:3233
 TASImage.cxx:3234
 TASImage.cxx:3235
 TASImage.cxx:3236
 TASImage.cxx:3237
 TASImage.cxx:3238
 TASImage.cxx:3239
 TASImage.cxx:3240
 TASImage.cxx:3241
 TASImage.cxx:3242
 TASImage.cxx:3243
 TASImage.cxx:3244
 TASImage.cxx:3245
 TASImage.cxx:3246
 TASImage.cxx:3247
 TASImage.cxx:3248
 TASImage.cxx:3249
 TASImage.cxx:3250
 TASImage.cxx:3251
 TASImage.cxx:3252
 TASImage.cxx:3253
 TASImage.cxx:3254
 TASImage.cxx:3255
 TASImage.cxx:3256
 TASImage.cxx:3257
 TASImage.cxx:3258
 TASImage.cxx:3259
 TASImage.cxx:3260
 TASImage.cxx:3261
 TASImage.cxx:3262
 TASImage.cxx:3263
 TASImage.cxx:3264
 TASImage.cxx:3265
 TASImage.cxx:3266
 TASImage.cxx:3267
 TASImage.cxx:3268
 TASImage.cxx:3269
 TASImage.cxx:3270
 TASImage.cxx:3271
 TASImage.cxx:3272
 TASImage.cxx:3273
 TASImage.cxx:3274
 TASImage.cxx:3275
 TASImage.cxx:3276
 TASImage.cxx:3277
 TASImage.cxx:3278
 TASImage.cxx:3279
 TASImage.cxx:3280
 TASImage.cxx:3281
 TASImage.cxx:3282
 TASImage.cxx:3283
 TASImage.cxx:3284
 TASImage.cxx:3285
 TASImage.cxx:3286
 TASImage.cxx:3287
 TASImage.cxx:3288
 TASImage.cxx:3289
 TASImage.cxx:3290
 TASImage.cxx:3291
 TASImage.cxx:3292
 TASImage.cxx:3293
 TASImage.cxx:3294
 TASImage.cxx:3295
 TASImage.cxx:3296
 TASImage.cxx:3297
 TASImage.cxx:3298
 TASImage.cxx:3299
 TASImage.cxx:3300
 TASImage.cxx:3301
 TASImage.cxx:3302
 TASImage.cxx:3303
 TASImage.cxx:3304
 TASImage.cxx:3305
 TASImage.cxx:3306
 TASImage.cxx:3307
 TASImage.cxx:3308
 TASImage.cxx:3309
 TASImage.cxx:3310
 TASImage.cxx:3311
 TASImage.cxx:3312
 TASImage.cxx:3313
 TASImage.cxx:3314
 TASImage.cxx:3315
 TASImage.cxx:3316
 TASImage.cxx:3317
 TASImage.cxx:3318
 TASImage.cxx:3319
 TASImage.cxx:3320
 TASImage.cxx:3321
 TASImage.cxx:3322
 TASImage.cxx:3323
 TASImage.cxx:3324
 TASImage.cxx:3325
 TASImage.cxx:3326
 TASImage.cxx:3327
 TASImage.cxx:3328
 TASImage.cxx:3329
 TASImage.cxx:3330
 TASImage.cxx:3331
 TASImage.cxx:3332
 TASImage.cxx:3333
 TASImage.cxx:3334
 TASImage.cxx:3335
 TASImage.cxx:3336
 TASImage.cxx:3337
 TASImage.cxx:3338
 TASImage.cxx:3339
 TASImage.cxx:3340
 TASImage.cxx:3341
 TASImage.cxx:3342
 TASImage.cxx:3343
 TASImage.cxx:3344
 TASImage.cxx:3345
 TASImage.cxx:3346
 TASImage.cxx:3347
 TASImage.cxx:3348
 TASImage.cxx:3349
 TASImage.cxx:3350
 TASImage.cxx:3351
 TASImage.cxx:3352
 TASImage.cxx:3353
 TASImage.cxx:3354
 TASImage.cxx:3355
 TASImage.cxx:3356
 TASImage.cxx:3357
 TASImage.cxx:3358
 TASImage.cxx:3359
 TASImage.cxx:3360
 TASImage.cxx:3361
 TASImage.cxx:3362
 TASImage.cxx:3363
 TASImage.cxx:3364
 TASImage.cxx:3365
 TASImage.cxx:3366
 TASImage.cxx:3367
 TASImage.cxx:3368
 TASImage.cxx:3369
 TASImage.cxx:3370
 TASImage.cxx:3371
 TASImage.cxx:3372
 TASImage.cxx:3373
 TASImage.cxx:3374
 TASImage.cxx:3375
 TASImage.cxx:3376
 TASImage.cxx:3377
 TASImage.cxx:3378
 TASImage.cxx:3379
 TASImage.cxx:3380
 TASImage.cxx:3381
 TASImage.cxx:3382
 TASImage.cxx:3383
 TASImage.cxx:3384
 TASImage.cxx:3385
 TASImage.cxx:3386
 TASImage.cxx:3387
 TASImage.cxx:3388
 TASImage.cxx:3389
 TASImage.cxx:3390
 TASImage.cxx:3391
 TASImage.cxx:3392
 TASImage.cxx:3393
 TASImage.cxx:3394
 TASImage.cxx:3395
 TASImage.cxx:3396
 TASImage.cxx:3397
 TASImage.cxx:3398
 TASImage.cxx:3399
 TASImage.cxx:3400
 TASImage.cxx:3401
 TASImage.cxx:3402
 TASImage.cxx:3403
 TASImage.cxx:3404
 TASImage.cxx:3405
 TASImage.cxx:3406
 TASImage.cxx:3407
 TASImage.cxx:3408
 TASImage.cxx:3409
 TASImage.cxx:3410
 TASImage.cxx:3411
 TASImage.cxx:3412
 TASImage.cxx:3413
 TASImage.cxx:3414
 TASImage.cxx:3415
 TASImage.cxx:3416
 TASImage.cxx:3417
 TASImage.cxx:3418
 TASImage.cxx:3419
 TASImage.cxx:3420
 TASImage.cxx:3421
 TASImage.cxx:3422
 TASImage.cxx:3423
 TASImage.cxx:3424
 TASImage.cxx:3425
 TASImage.cxx:3426
 TASImage.cxx:3427
 TASImage.cxx:3428
 TASImage.cxx:3429
 TASImage.cxx:3430
 TASImage.cxx:3431
 TASImage.cxx:3432
 TASImage.cxx:3433
 TASImage.cxx:3434
 TASImage.cxx:3435
 TASImage.cxx:3436
 TASImage.cxx:3437
 TASImage.cxx:3438
 TASImage.cxx:3439
 TASImage.cxx:3440
 TASImage.cxx:3441
 TASImage.cxx:3442
 TASImage.cxx:3443
 TASImage.cxx:3444
 TASImage.cxx:3445
 TASImage.cxx:3446
 TASImage.cxx:3447
 TASImage.cxx:3448
 TASImage.cxx:3449
 TASImage.cxx:3450
 TASImage.cxx:3451
 TASImage.cxx:3452
 TASImage.cxx:3453
 TASImage.cxx:3454
 TASImage.cxx:3455
 TASImage.cxx:3456
 TASImage.cxx:3457
 TASImage.cxx:3458
 TASImage.cxx:3459
 TASImage.cxx:3460
 TASImage.cxx:3461
 TASImage.cxx:3462
 TASImage.cxx:3463
 TASImage.cxx:3464
 TASImage.cxx:3465
 TASImage.cxx:3466
 TASImage.cxx:3467
 TASImage.cxx:3468
 TASImage.cxx:3469
 TASImage.cxx:3470
 TASImage.cxx:3471
 TASImage.cxx:3472
 TASImage.cxx:3473
 TASImage.cxx:3474
 TASImage.cxx:3475
 TASImage.cxx:3476
 TASImage.cxx:3477
 TASImage.cxx:3478
 TASImage.cxx:3479
 TASImage.cxx:3480
 TASImage.cxx:3481
 TASImage.cxx:3482
 TASImage.cxx:3483
 TASImage.cxx:3484
 TASImage.cxx:3485
 TASImage.cxx:3486
 TASImage.cxx:3487
 TASImage.cxx:3488
 TASImage.cxx:3489
 TASImage.cxx:3490
 TASImage.cxx:3491
 TASImage.cxx:3492
 TASImage.cxx:3493
 TASImage.cxx:3494
 TASImage.cxx:3495
 TASImage.cxx:3496
 TASImage.cxx:3497
 TASImage.cxx:3498
 TASImage.cxx:3499
 TASImage.cxx:3500
 TASImage.cxx:3501
 TASImage.cxx:3502
 TASImage.cxx:3503
 TASImage.cxx:3504
 TASImage.cxx:3505
 TASImage.cxx:3506
 TASImage.cxx:3507
 TASImage.cxx:3508
 TASImage.cxx:3509
 TASImage.cxx:3510
 TASImage.cxx:3511
 TASImage.cxx:3512
 TASImage.cxx:3513
 TASImage.cxx:3514
 TASImage.cxx:3515
 TASImage.cxx:3516
 TASImage.cxx:3517
 TASImage.cxx:3518
 TASImage.cxx:3519
 TASImage.cxx:3520
 TASImage.cxx:3521
 TASImage.cxx:3522
 TASImage.cxx:3523
 TASImage.cxx:3524
 TASImage.cxx:3525
 TASImage.cxx:3526
 TASImage.cxx:3527
 TASImage.cxx:3528
 TASImage.cxx:3529
 TASImage.cxx:3530
 TASImage.cxx:3531
 TASImage.cxx:3532
 TASImage.cxx:3533
 TASImage.cxx:3534
 TASImage.cxx:3535
 TASImage.cxx:3536
 TASImage.cxx:3537
 TASImage.cxx:3538
 TASImage.cxx:3539
 TASImage.cxx:3540
 TASImage.cxx:3541
 TASImage.cxx:3542
 TASImage.cxx:3543
 TASImage.cxx:3544
 TASImage.cxx:3545
 TASImage.cxx:3546
 TASImage.cxx:3547
 TASImage.cxx:3548
 TASImage.cxx:3549
 TASImage.cxx:3550
 TASImage.cxx:3551
 TASImage.cxx:3552
 TASImage.cxx:3553
 TASImage.cxx:3554
 TASImage.cxx:3555
 TASImage.cxx:3556
 TASImage.cxx:3557
 TASImage.cxx:3558
 TASImage.cxx:3559
 TASImage.cxx:3560
 TASImage.cxx:3561
 TASImage.cxx:3562
 TASImage.cxx:3563
 TASImage.cxx:3564
 TASImage.cxx:3565
 TASImage.cxx:3566
 TASImage.cxx:3567
 TASImage.cxx:3568
 TASImage.cxx:3569
 TASImage.cxx:3570
 TASImage.cxx:3571
 TASImage.cxx:3572
 TASImage.cxx:3573
 TASImage.cxx:3574
 TASImage.cxx:3575
 TASImage.cxx:3576
 TASImage.cxx:3577
 TASImage.cxx:3578
 TASImage.cxx:3579
 TASImage.cxx:3580
 TASImage.cxx:3581
 TASImage.cxx:3582
 TASImage.cxx:3583
 TASImage.cxx:3584
 TASImage.cxx:3585
 TASImage.cxx:3586
 TASImage.cxx:3587
 TASImage.cxx:3588
 TASImage.cxx:3589
 TASImage.cxx:3590
 TASImage.cxx:3591
 TASImage.cxx:3592
 TASImage.cxx:3593
 TASImage.cxx:3594
 TASImage.cxx:3595
 TASImage.cxx:3596
 TASImage.cxx:3597
 TASImage.cxx:3598
 TASImage.cxx:3599
 TASImage.cxx:3600
 TASImage.cxx:3601
 TASImage.cxx:3602
 TASImage.cxx:3603
 TASImage.cxx:3604
 TASImage.cxx:3605
 TASImage.cxx:3606
 TASImage.cxx:3607
 TASImage.cxx:3608
 TASImage.cxx:3609
 TASImage.cxx:3610
 TASImage.cxx:3611
 TASImage.cxx:3612
 TASImage.cxx:3613
 TASImage.cxx:3614
 TASImage.cxx:3615
 TASImage.cxx:3616
 TASImage.cxx:3617
 TASImage.cxx:3618
 TASImage.cxx:3619
 TASImage.cxx:3620
 TASImage.cxx:3621
 TASImage.cxx:3622
 TASImage.cxx:3623
 TASImage.cxx:3624
 TASImage.cxx:3625
 TASImage.cxx:3626
 TASImage.cxx:3627
 TASImage.cxx:3628
 TASImage.cxx:3629
 TASImage.cxx:3630
 TASImage.cxx:3631
 TASImage.cxx:3632
 TASImage.cxx:3633
 TASImage.cxx:3634
 TASImage.cxx:3635
 TASImage.cxx:3636
 TASImage.cxx:3637
 TASImage.cxx:3638
 TASImage.cxx:3639
 TASImage.cxx:3640
 TASImage.cxx:3641
 TASImage.cxx:3642
 TASImage.cxx:3643
 TASImage.cxx:3644
 TASImage.cxx:3645
 TASImage.cxx:3646
 TASImage.cxx:3647
 TASImage.cxx:3648
 TASImage.cxx:3649
 TASImage.cxx:3650
 TASImage.cxx:3651
 TASImage.cxx:3652
 TASImage.cxx:3653
 TASImage.cxx:3654
 TASImage.cxx:3655
 TASImage.cxx:3656
 TASImage.cxx:3657
 TASImage.cxx:3658
 TASImage.cxx:3659
 TASImage.cxx:3660
 TASImage.cxx:3661
 TASImage.cxx:3662
 TASImage.cxx:3663
 TASImage.cxx:3664
 TASImage.cxx:3665
 TASImage.cxx:3666
 TASImage.cxx:3667
 TASImage.cxx:3668
 TASImage.cxx:3669
 TASImage.cxx:3670
 TASImage.cxx:3671
 TASImage.cxx:3672
 TASImage.cxx:3673
 TASImage.cxx:3674
 TASImage.cxx:3675
 TASImage.cxx:3676
 TASImage.cxx:3677
 TASImage.cxx:3678
 TASImage.cxx:3679
 TASImage.cxx:3680
 TASImage.cxx:3681
 TASImage.cxx:3682
 TASImage.cxx:3683
 TASImage.cxx:3684
 TASImage.cxx:3685
 TASImage.cxx:3686
 TASImage.cxx:3687
 TASImage.cxx:3688
 TASImage.cxx:3689
 TASImage.cxx:3690
 TASImage.cxx:3691
 TASImage.cxx:3692
 TASImage.cxx:3693
 TASImage.cxx:3694
 TASImage.cxx:3695
 TASImage.cxx:3696
 TASImage.cxx:3697
 TASImage.cxx:3698
 TASImage.cxx:3699
 TASImage.cxx:3700
 TASImage.cxx:3701
 TASImage.cxx:3702
 TASImage.cxx:3703
 TASImage.cxx:3704
 TASImage.cxx:3705
 TASImage.cxx:3706
 TASImage.cxx:3707
 TASImage.cxx:3708
 TASImage.cxx:3709
 TASImage.cxx:3710
 TASImage.cxx:3711
 TASImage.cxx:3712
 TASImage.cxx:3713
 TASImage.cxx:3714
 TASImage.cxx:3715
 TASImage.cxx:3716
 TASImage.cxx:3717
 TASImage.cxx:3718
 TASImage.cxx:3719
 TASImage.cxx:3720
 TASImage.cxx:3721
 TASImage.cxx:3722
 TASImage.cxx:3723
 TASImage.cxx:3724
 TASImage.cxx:3725
 TASImage.cxx:3726
 TASImage.cxx:3727
 TASImage.cxx:3728
 TASImage.cxx:3729
 TASImage.cxx:3730
 TASImage.cxx:3731
 TASImage.cxx:3732
 TASImage.cxx:3733
 TASImage.cxx:3734
 TASImage.cxx:3735
 TASImage.cxx:3736
 TASImage.cxx:3737
 TASImage.cxx:3738
 TASImage.cxx:3739
 TASImage.cxx:3740
 TASImage.cxx:3741
 TASImage.cxx:3742
 TASImage.cxx:3743
 TASImage.cxx:3744
 TASImage.cxx:3745
 TASImage.cxx:3746
 TASImage.cxx:3747
 TASImage.cxx:3748
 TASImage.cxx:3749
 TASImage.cxx:3750
 TASImage.cxx:3751
 TASImage.cxx:3752
 TASImage.cxx:3753
 TASImage.cxx:3754
 TASImage.cxx:3755
 TASImage.cxx:3756
 TASImage.cxx:3757
 TASImage.cxx:3758
 TASImage.cxx:3759
 TASImage.cxx:3760
 TASImage.cxx:3761
 TASImage.cxx:3762
 TASImage.cxx:3763
 TASImage.cxx:3764
 TASImage.cxx:3765
 TASImage.cxx:3766
 TASImage.cxx:3767
 TASImage.cxx:3768
 TASImage.cxx:3769
 TASImage.cxx:3770
 TASImage.cxx:3771
 TASImage.cxx:3772
 TASImage.cxx:3773
 TASImage.cxx:3774
 TASImage.cxx:3775
 TASImage.cxx:3776
 TASImage.cxx:3777
 TASImage.cxx:3778
 TASImage.cxx:3779
 TASImage.cxx:3780
 TASImage.cxx:3781
 TASImage.cxx:3782
 TASImage.cxx:3783
 TASImage.cxx:3784
 TASImage.cxx:3785
 TASImage.cxx:3786
 TASImage.cxx:3787
 TASImage.cxx:3788
 TASImage.cxx:3789
 TASImage.cxx:3790
 TASImage.cxx:3791
 TASImage.cxx:3792
 TASImage.cxx:3793
 TASImage.cxx:3794
 TASImage.cxx:3795
 TASImage.cxx:3796
 TASImage.cxx:3797
 TASImage.cxx:3798
 TASImage.cxx:3799
 TASImage.cxx:3800
 TASImage.cxx:3801
 TASImage.cxx:3802
 TASImage.cxx:3803
 TASImage.cxx:3804
 TASImage.cxx:3805
 TASImage.cxx:3806
 TASImage.cxx:3807
 TASImage.cxx:3808
 TASImage.cxx:3809
 TASImage.cxx:3810
 TASImage.cxx:3811
 TASImage.cxx:3812
 TASImage.cxx:3813
 TASImage.cxx:3814
 TASImage.cxx:3815
 TASImage.cxx:3816
 TASImage.cxx:3817
 TASImage.cxx:3818
 TASImage.cxx:3819
 TASImage.cxx:3820
 TASImage.cxx:3821
 TASImage.cxx:3822
 TASImage.cxx:3823
 TASImage.cxx:3824
 TASImage.cxx:3825
 TASImage.cxx:3826
 TASImage.cxx:3827
 TASImage.cxx:3828
 TASImage.cxx:3829
 TASImage.cxx:3830
 TASImage.cxx:3831
 TASImage.cxx:3832
 TASImage.cxx:3833
 TASImage.cxx:3834
 TASImage.cxx:3835
 TASImage.cxx:3836
 TASImage.cxx:3837
 TASImage.cxx:3838
 TASImage.cxx:3839
 TASImage.cxx:3840
 TASImage.cxx:3841
 TASImage.cxx:3842
 TASImage.cxx:3843
 TASImage.cxx:3844
 TASImage.cxx:3845
 TASImage.cxx:3846
 TASImage.cxx:3847
 TASImage.cxx:3848
 TASImage.cxx:3849
 TASImage.cxx:3850
 TASImage.cxx:3851
 TASImage.cxx:3852
 TASImage.cxx:3853
 TASImage.cxx:3854
 TASImage.cxx:3855
 TASImage.cxx:3856
 TASImage.cxx:3857
 TASImage.cxx:3858
 TASImage.cxx:3859
 TASImage.cxx:3860
 TASImage.cxx:3861
 TASImage.cxx:3862
 TASImage.cxx:3863
 TASImage.cxx:3864
 TASImage.cxx:3865
 TASImage.cxx:3866
 TASImage.cxx:3867
 TASImage.cxx:3868
 TASImage.cxx:3869
 TASImage.cxx:3870
 TASImage.cxx:3871
 TASImage.cxx:3872
 TASImage.cxx:3873
 TASImage.cxx:3874
 TASImage.cxx:3875
 TASImage.cxx:3876
 TASImage.cxx:3877
 TASImage.cxx:3878
 TASImage.cxx:3879
 TASImage.cxx:3880
 TASImage.cxx:3881
 TASImage.cxx:3882
 TASImage.cxx:3883
 TASImage.cxx:3884
 TASImage.cxx:3885
 TASImage.cxx:3886
 TASImage.cxx:3887
 TASImage.cxx:3888
 TASImage.cxx:3889
 TASImage.cxx:3890
 TASImage.cxx:3891
 TASImage.cxx:3892
 TASImage.cxx:3893
 TASImage.cxx:3894
 TASImage.cxx:3895
 TASImage.cxx:3896
 TASImage.cxx:3897
 TASImage.cxx:3898
 TASImage.cxx:3899
 TASImage.cxx:3900
 TASImage.cxx:3901
 TASImage.cxx:3902
 TASImage.cxx:3903
 TASImage.cxx:3904
 TASImage.cxx:3905
 TASImage.cxx:3906
 TASImage.cxx:3907
 TASImage.cxx:3908
 TASImage.cxx:3909
 TASImage.cxx:3910
 TASImage.cxx:3911
 TASImage.cxx:3912
 TASImage.cxx:3913
 TASImage.cxx:3914
 TASImage.cxx:3915
 TASImage.cxx:3916
 TASImage.cxx:3917
 TASImage.cxx:3918
 TASImage.cxx:3919
 TASImage.cxx:3920
 TASImage.cxx:3921
 TASImage.cxx:3922
 TASImage.cxx:3923
 TASImage.cxx:3924
 TASImage.cxx:3925
 TASImage.cxx:3926
 TASImage.cxx:3927
 TASImage.cxx:3928
 TASImage.cxx:3929
 TASImage.cxx:3930
 TASImage.cxx:3931
 TASImage.cxx:3932
 TASImage.cxx:3933
 TASImage.cxx:3934
 TASImage.cxx:3935
 TASImage.cxx:3936
 TASImage.cxx:3937
 TASImage.cxx:3938
 TASImage.cxx:3939
 TASImage.cxx:3940
 TASImage.cxx:3941
 TASImage.cxx:3942
 TASImage.cxx:3943
 TASImage.cxx:3944
 TASImage.cxx:3945
 TASImage.cxx:3946
 TASImage.cxx:3947
 TASImage.cxx:3948
 TASImage.cxx:3949
 TASImage.cxx:3950
 TASImage.cxx:3951
 TASImage.cxx:3952
 TASImage.cxx:3953
 TASImage.cxx:3954
 TASImage.cxx:3955
 TASImage.cxx:3956
 TASImage.cxx:3957
 TASImage.cxx:3958
 TASImage.cxx:3959
 TASImage.cxx:3960
 TASImage.cxx:3961
 TASImage.cxx:3962
 TASImage.cxx:3963
 TASImage.cxx:3964
 TASImage.cxx:3965
 TASImage.cxx:3966
 TASImage.cxx:3967
 TASImage.cxx:3968
 TASImage.cxx:3969
 TASImage.cxx:3970
 TASImage.cxx:3971
 TASImage.cxx:3972
 TASImage.cxx:3973
 TASImage.cxx:3974
 TASImage.cxx:3975
 TASImage.cxx:3976
 TASImage.cxx:3977
 TASImage.cxx:3978
 TASImage.cxx:3979
 TASImage.cxx:3980
 TASImage.cxx:3981
 TASImage.cxx:3982
 TASImage.cxx:3983
 TASImage.cxx:3984
 TASImage.cxx:3985
 TASImage.cxx:3986
 TASImage.cxx:3987
 TASImage.cxx:3988
 TASImage.cxx:3989
 TASImage.cxx:3990
 TASImage.cxx:3991
 TASImage.cxx:3992
 TASImage.cxx:3993
 TASImage.cxx:3994
 TASImage.cxx:3995
 TASImage.cxx:3996
 TASImage.cxx:3997
 TASImage.cxx:3998
 TASImage.cxx:3999
 TASImage.cxx:4000
 TASImage.cxx:4001
 TASImage.cxx:4002
 TASImage.cxx:4003
 TASImage.cxx:4004
 TASImage.cxx:4005
 TASImage.cxx:4006
 TASImage.cxx:4007
 TASImage.cxx:4008
 TASImage.cxx:4009
 TASImage.cxx:4010
 TASImage.cxx:4011
 TASImage.cxx:4012
 TASImage.cxx:4013
 TASImage.cxx:4014
 TASImage.cxx:4015
 TASImage.cxx:4016
 TASImage.cxx:4017
 TASImage.cxx:4018
 TASImage.cxx:4019
 TASImage.cxx:4020
 TASImage.cxx:4021
 TASImage.cxx:4022
 TASImage.cxx:4023
 TASImage.cxx:4024
 TASImage.cxx:4025
 TASImage.cxx:4026
 TASImage.cxx:4027
 TASImage.cxx:4028
 TASImage.cxx:4029
 TASImage.cxx:4030
 TASImage.cxx:4031
 TASImage.cxx:4032
 TASImage.cxx:4033
 TASImage.cxx:4034
 TASImage.cxx:4035
 TASImage.cxx:4036
 TASImage.cxx:4037
 TASImage.cxx:4038
 TASImage.cxx:4039
 TASImage.cxx:4040
 TASImage.cxx:4041
 TASImage.cxx:4042
 TASImage.cxx:4043
 TASImage.cxx:4044
 TASImage.cxx:4045
 TASImage.cxx:4046
 TASImage.cxx:4047
 TASImage.cxx:4048
 TASImage.cxx:4049
 TASImage.cxx:4050
 TASImage.cxx:4051
 TASImage.cxx:4052
 TASImage.cxx:4053
 TASImage.cxx:4054
 TASImage.cxx:4055
 TASImage.cxx:4056
 TASImage.cxx:4057
 TASImage.cxx:4058
 TASImage.cxx:4059
 TASImage.cxx:4060
 TASImage.cxx:4061
 TASImage.cxx:4062
 TASImage.cxx:4063
 TASImage.cxx:4064
 TASImage.cxx:4065
 TASImage.cxx:4066
 TASImage.cxx:4067
 TASImage.cxx:4068
 TASImage.cxx:4069
 TASImage.cxx:4070
 TASImage.cxx:4071
 TASImage.cxx:4072
 TASImage.cxx:4073
 TASImage.cxx:4074
 TASImage.cxx:4075
 TASImage.cxx:4076
 TASImage.cxx:4077
 TASImage.cxx:4078
 TASImage.cxx:4079
 TASImage.cxx:4080
 TASImage.cxx:4081
 TASImage.cxx:4082
 TASImage.cxx:4083
 TASImage.cxx:4084
 TASImage.cxx:4085
 TASImage.cxx:4086
 TASImage.cxx:4087
 TASImage.cxx:4088
 TASImage.cxx:4089
 TASImage.cxx:4090
 TASImage.cxx:4091
 TASImage.cxx:4092
 TASImage.cxx:4093
 TASImage.cxx:4094
 TASImage.cxx:4095
 TASImage.cxx:4096
 TASImage.cxx:4097
 TASImage.cxx:4098
 TASImage.cxx:4099
 TASImage.cxx:4100
 TASImage.cxx:4101
 TASImage.cxx:4102
 TASImage.cxx:4103
 TASImage.cxx:4104
 TASImage.cxx:4105
 TASImage.cxx:4106
 TASImage.cxx:4107
 TASImage.cxx:4108
 TASImage.cxx:4109
 TASImage.cxx:4110
 TASImage.cxx:4111
 TASImage.cxx:4112
 TASImage.cxx:4113
 TASImage.cxx:4114
 TASImage.cxx:4115
 TASImage.cxx:4116
 TASImage.cxx:4117
 TASImage.cxx:4118
 TASImage.cxx:4119
 TASImage.cxx:4120
 TASImage.cxx:4121
 TASImage.cxx:4122
 TASImage.cxx:4123
 TASImage.cxx:4124
 TASImage.cxx:4125
 TASImage.cxx:4126
 TASImage.cxx:4127
 TASImage.cxx:4128
 TASImage.cxx:4129
 TASImage.cxx:4130
 TASImage.cxx:4131
 TASImage.cxx:4132
 TASImage.cxx:4133
 TASImage.cxx:4134
 TASImage.cxx:4135
 TASImage.cxx:4136
 TASImage.cxx:4137
 TASImage.cxx:4138
 TASImage.cxx:4139
 TASImage.cxx:4140
 TASImage.cxx:4141
 TASImage.cxx:4142
 TASImage.cxx:4143
 TASImage.cxx:4144
 TASImage.cxx:4145
 TASImage.cxx:4146
 TASImage.cxx:4147
 TASImage.cxx:4148
 TASImage.cxx:4149
 TASImage.cxx:4150
 TASImage.cxx:4151
 TASImage.cxx:4152
 TASImage.cxx:4153
 TASImage.cxx:4154
 TASImage.cxx:4155
 TASImage.cxx:4156
 TASImage.cxx:4157
 TASImage.cxx:4158
 TASImage.cxx:4159
 TASImage.cxx:4160
 TASImage.cxx:4161
 TASImage.cxx:4162
 TASImage.cxx:4163
 TASImage.cxx:4164
 TASImage.cxx:4165
 TASImage.cxx:4166
 TASImage.cxx:4167
 TASImage.cxx:4168
 TASImage.cxx:4169
 TASImage.cxx:4170
 TASImage.cxx:4171
 TASImage.cxx:4172
 TASImage.cxx:4173
 TASImage.cxx:4174
 TASImage.cxx:4175
 TASImage.cxx:4176
 TASImage.cxx:4177
 TASImage.cxx:4178
 TASImage.cxx:4179
 TASImage.cxx:4180
 TASImage.cxx:4181
 TASImage.cxx:4182
 TASImage.cxx:4183
 TASImage.cxx:4184
 TASImage.cxx:4185
 TASImage.cxx:4186
 TASImage.cxx:4187
 TASImage.cxx:4188
 TASImage.cxx:4189
 TASImage.cxx:4190
 TASImage.cxx:4191
 TASImage.cxx:4192
 TASImage.cxx:4193
 TASImage.cxx:4194
 TASImage.cxx:4195
 TASImage.cxx:4196
 TASImage.cxx:4197
 TASImage.cxx:4198
 TASImage.cxx:4199
 TASImage.cxx:4200
 TASImage.cxx:4201
 TASImage.cxx:4202
 TASImage.cxx:4203
 TASImage.cxx:4204
 TASImage.cxx:4205
 TASImage.cxx:4206
 TASImage.cxx:4207
 TASImage.cxx:4208
 TASImage.cxx:4209
 TASImage.cxx:4210
 TASImage.cxx:4211
 TASImage.cxx:4212
 TASImage.cxx:4213
 TASImage.cxx:4214
 TASImage.cxx:4215
 TASImage.cxx:4216
 TASImage.cxx:4217
 TASImage.cxx:4218
 TASImage.cxx:4219
 TASImage.cxx:4220
 TASImage.cxx:4221
 TASImage.cxx:4222
 TASImage.cxx:4223
 TASImage.cxx:4224
 TASImage.cxx:4225
 TASImage.cxx:4226
 TASImage.cxx:4227
 TASImage.cxx:4228
 TASImage.cxx:4229
 TASImage.cxx:4230
 TASImage.cxx:4231
 TASImage.cxx:4232
 TASImage.cxx:4233
 TASImage.cxx:4234
 TASImage.cxx:4235
 TASImage.cxx:4236
 TASImage.cxx:4237
 TASImage.cxx:4238
 TASImage.cxx:4239
 TASImage.cxx:4240
 TASImage.cxx:4241
 TASImage.cxx:4242
 TASImage.cxx:4243
 TASImage.cxx:4244
 TASImage.cxx:4245
 TASImage.cxx:4246
 TASImage.cxx:4247
 TASImage.cxx:4248
 TASImage.cxx:4249
 TASImage.cxx:4250
 TASImage.cxx:4251
 TASImage.cxx:4252
 TASImage.cxx:4253
 TASImage.cxx:4254
 TASImage.cxx:4255
 TASImage.cxx:4256
 TASImage.cxx:4257
 TASImage.cxx:4258
 TASImage.cxx:4259
 TASImage.cxx:4260
 TASImage.cxx:4261
 TASImage.cxx:4262
 TASImage.cxx:4263
 TASImage.cxx:4264
 TASImage.cxx:4265
 TASImage.cxx:4266
 TASImage.cxx:4267
 TASImage.cxx:4268
 TASImage.cxx:4269
 TASImage.cxx:4270
 TASImage.cxx:4271
 TASImage.cxx:4272
 TASImage.cxx:4273
 TASImage.cxx:4274
 TASImage.cxx:4275
 TASImage.cxx:4276
 TASImage.cxx:4277
 TASImage.cxx:4278
 TASImage.cxx:4279
 TASImage.cxx:4280
 TASImage.cxx:4281
 TASImage.cxx:4282
 TASImage.cxx:4283
 TASImage.cxx:4284
 TASImage.cxx:4285
 TASImage.cxx:4286
 TASImage.cxx:4287
 TASImage.cxx:4288
 TASImage.cxx:4289
 TASImage.cxx:4290
 TASImage.cxx:4291
 TASImage.cxx:4292
 TASImage.cxx:4293
 TASImage.cxx:4294
 TASImage.cxx:4295
 TASImage.cxx:4296
 TASImage.cxx:4297
 TASImage.cxx:4298
 TASImage.cxx:4299
 TASImage.cxx:4300
 TASImage.cxx:4301
 TASImage.cxx:4302
 TASImage.cxx:4303
 TASImage.cxx:4304
 TASImage.cxx:4305
 TASImage.cxx:4306
 TASImage.cxx:4307
 TASImage.cxx:4308
 TASImage.cxx:4309
 TASImage.cxx:4310
 TASImage.cxx:4311
 TASImage.cxx:4312
 TASImage.cxx:4313
 TASImage.cxx:4314
 TASImage.cxx:4315
 TASImage.cxx:4316
 TASImage.cxx:4317
 TASImage.cxx:4318
 TASImage.cxx:4319
 TASImage.cxx:4320
 TASImage.cxx:4321
 TASImage.cxx:4322
 TASImage.cxx:4323
 TASImage.cxx:4324
 TASImage.cxx:4325
 TASImage.cxx:4326
 TASImage.cxx:4327
 TASImage.cxx:4328
 TASImage.cxx:4329
 TASImage.cxx:4330
 TASImage.cxx:4331
 TASImage.cxx:4332
 TASImage.cxx:4333
 TASImage.cxx:4334
 TASImage.cxx:4335
 TASImage.cxx:4336
 TASImage.cxx:4337
 TASImage.cxx:4338
 TASImage.cxx:4339
 TASImage.cxx:4340
 TASImage.cxx:4341
 TASImage.cxx:4342
 TASImage.cxx:4343
 TASImage.cxx:4344
 TASImage.cxx:4345
 TASImage.cxx:4346
 TASImage.cxx:4347
 TASImage.cxx:4348
 TASImage.cxx:4349
 TASImage.cxx:4350
 TASImage.cxx:4351
 TASImage.cxx:4352
 TASImage.cxx:4353
 TASImage.cxx:4354
 TASImage.cxx:4355
 TASImage.cxx:4356
 TASImage.cxx:4357
 TASImage.cxx:4358
 TASImage.cxx:4359
 TASImage.cxx:4360
 TASImage.cxx:4361
 TASImage.cxx:4362
 TASImage.cxx:4363
 TASImage.cxx:4364
 TASImage.cxx:4365
 TASImage.cxx:4366
 TASImage.cxx:4367
 TASImage.cxx:4368
 TASImage.cxx:4369
 TASImage.cxx:4370
 TASImage.cxx:4371
 TASImage.cxx:4372
 TASImage.cxx:4373
 TASImage.cxx:4374
 TASImage.cxx:4375
 TASImage.cxx:4376
 TASImage.cxx:4377
 TASImage.cxx:4378
 TASImage.cxx:4379
 TASImage.cxx:4380
 TASImage.cxx:4381
 TASImage.cxx:4382
 TASImage.cxx:4383
 TASImage.cxx:4384
 TASImage.cxx:4385
 TASImage.cxx:4386
 TASImage.cxx:4387
 TASImage.cxx:4388
 TASImage.cxx:4389
 TASImage.cxx:4390
 TASImage.cxx:4391
 TASImage.cxx:4392
 TASImage.cxx:4393
 TASImage.cxx:4394
 TASImage.cxx:4395
 TASImage.cxx:4396
 TASImage.cxx:4397
 TASImage.cxx:4398
 TASImage.cxx:4399
 TASImage.cxx:4400
 TASImage.cxx:4401
 TASImage.cxx:4402
 TASImage.cxx:4403
 TASImage.cxx:4404
 TASImage.cxx:4405
 TASImage.cxx:4406
 TASImage.cxx:4407
 TASImage.cxx:4408
 TASImage.cxx:4409
 TASImage.cxx:4410
 TASImage.cxx:4411
 TASImage.cxx:4412
 TASImage.cxx:4413
 TASImage.cxx:4414
 TASImage.cxx:4415
 TASImage.cxx:4416
 TASImage.cxx:4417
 TASImage.cxx:4418
 TASImage.cxx:4419
 TASImage.cxx:4420
 TASImage.cxx:4421
 TASImage.cxx:4422
 TASImage.cxx:4423
 TASImage.cxx:4424
 TASImage.cxx:4425
 TASImage.cxx:4426
 TASImage.cxx:4427
 TASImage.cxx:4428
 TASImage.cxx:4429
 TASImage.cxx:4430
 TASImage.cxx:4431
 TASImage.cxx:4432
 TASImage.cxx:4433
 TASImage.cxx:4434
 TASImage.cxx:4435
 TASImage.cxx:4436
 TASImage.cxx:4437
 TASImage.cxx:4438
 TASImage.cxx:4439
 TASImage.cxx:4440
 TASImage.cxx:4441
 TASImage.cxx:4442
 TASImage.cxx:4443
 TASImage.cxx:4444
 TASImage.cxx:4445
 TASImage.cxx:4446
 TASImage.cxx:4447
 TASImage.cxx:4448
 TASImage.cxx:4449
 TASImage.cxx:4450
 TASImage.cxx:4451
 TASImage.cxx:4452
 TASImage.cxx:4453
 TASImage.cxx:4454
 TASImage.cxx:4455
 TASImage.cxx:4456
 TASImage.cxx:4457
 TASImage.cxx:4458
 TASImage.cxx:4459
 TASImage.cxx:4460
 TASImage.cxx:4461
 TASImage.cxx:4462
 TASImage.cxx:4463
 TASImage.cxx:4464
 TASImage.cxx:4465
 TASImage.cxx:4466
 TASImage.cxx:4467
 TASImage.cxx:4468
 TASImage.cxx:4469
 TASImage.cxx:4470
 TASImage.cxx:4471
 TASImage.cxx:4472
 TASImage.cxx:4473
 TASImage.cxx:4474
 TASImage.cxx:4475
 TASImage.cxx:4476
 TASImage.cxx:4477
 TASImage.cxx:4478
 TASImage.cxx:4479
 TASImage.cxx:4480
 TASImage.cxx:4481
 TASImage.cxx:4482
 TASImage.cxx:4483
 TASImage.cxx:4484
 TASImage.cxx:4485
 TASImage.cxx:4486
 TASImage.cxx:4487
 TASImage.cxx:4488
 TASImage.cxx:4489
 TASImage.cxx:4490
 TASImage.cxx:4491
 TASImage.cxx:4492
 TASImage.cxx:4493
 TASImage.cxx:4494
 TASImage.cxx:4495
 TASImage.cxx:4496
 TASImage.cxx:4497
 TASImage.cxx:4498
 TASImage.cxx:4499
 TASImage.cxx:4500
 TASImage.cxx:4501
 TASImage.cxx:4502
 TASImage.cxx:4503
 TASImage.cxx:4504
 TASImage.cxx:4505
 TASImage.cxx:4506
 TASImage.cxx:4507
 TASImage.cxx:4508
 TASImage.cxx:4509
 TASImage.cxx:4510
 TASImage.cxx:4511
 TASImage.cxx:4512
 TASImage.cxx:4513
 TASImage.cxx:4514
 TASImage.cxx:4515
 TASImage.cxx:4516
 TASImage.cxx:4517
 TASImage.cxx:4518
 TASImage.cxx:4519
 TASImage.cxx:4520
 TASImage.cxx:4521
 TASImage.cxx:4522
 TASImage.cxx:4523
 TASImage.cxx:4524
 TASImage.cxx:4525
 TASImage.cxx:4526
 TASImage.cxx:4527
 TASImage.cxx:4528
 TASImage.cxx:4529
 TASImage.cxx:4530
 TASImage.cxx:4531
 TASImage.cxx:4532
 TASImage.cxx:4533
 TASImage.cxx:4534
 TASImage.cxx:4535
 TASImage.cxx:4536
 TASImage.cxx:4537
 TASImage.cxx:4538
 TASImage.cxx:4539
 TASImage.cxx:4540
 TASImage.cxx:4541
 TASImage.cxx:4542
 TASImage.cxx:4543
 TASImage.cxx:4544
 TASImage.cxx:4545
 TASImage.cxx:4546
 TASImage.cxx:4547
 TASImage.cxx:4548
 TASImage.cxx:4549
 TASImage.cxx:4550
 TASImage.cxx:4551
 TASImage.cxx:4552
 TASImage.cxx:4553
 TASImage.cxx:4554
 TASImage.cxx:4555
 TASImage.cxx:4556
 TASImage.cxx:4557
 TASImage.cxx:4558
 TASImage.cxx:4559
 TASImage.cxx:4560
 TASImage.cxx:4561
 TASImage.cxx:4562
 TASImage.cxx:4563
 TASImage.cxx:4564
 TASImage.cxx:4565
 TASImage.cxx:4566
 TASImage.cxx:4567
 TASImage.cxx:4568
 TASImage.cxx:4569
 TASImage.cxx:4570
 TASImage.cxx:4571
 TASImage.cxx:4572
 TASImage.cxx:4573
 TASImage.cxx:4574
 TASImage.cxx:4575
 TASImage.cxx:4576
 TASImage.cxx:4577
 TASImage.cxx:4578
 TASImage.cxx:4579
 TASImage.cxx:4580
 TASImage.cxx:4581
 TASImage.cxx:4582
 TASImage.cxx:4583
 TASImage.cxx:4584
 TASImage.cxx:4585
 TASImage.cxx:4586
 TASImage.cxx:4587
 TASImage.cxx:4588
 TASImage.cxx:4589
 TASImage.cxx:4590
 TASImage.cxx:4591
 TASImage.cxx:4592
 TASImage.cxx:4593
 TASImage.cxx:4594
 TASImage.cxx:4595
 TASImage.cxx:4596
 TASImage.cxx:4597
 TASImage.cxx:4598
 TASImage.cxx:4599
 TASImage.cxx:4600
 TASImage.cxx:4601
 TASImage.cxx:4602
 TASImage.cxx:4603
 TASImage.cxx:4604
 TASImage.cxx:4605
 TASImage.cxx:4606
 TASImage.cxx:4607
 TASImage.cxx:4608
 TASImage.cxx:4609
 TASImage.cxx:4610
 TASImage.cxx:4611
 TASImage.cxx:4612
 TASImage.cxx:4613
 TASImage.cxx:4614
 TASImage.cxx:4615
 TASImage.cxx:4616
 TASImage.cxx:4617
 TASImage.cxx:4618
 TASImage.cxx:4619
 TASImage.cxx:4620
 TASImage.cxx:4621
 TASImage.cxx:4622
 TASImage.cxx:4623
 TASImage.cxx:4624
 TASImage.cxx:4625
 TASImage.cxx:4626
 TASImage.cxx:4627
 TASImage.cxx:4628
 TASImage.cxx:4629
 TASImage.cxx:4630
 TASImage.cxx:4631
 TASImage.cxx:4632
 TASImage.cxx:4633
 TASImage.cxx:4634
 TASImage.cxx:4635
 TASImage.cxx:4636
 TASImage.cxx:4637
 TASImage.cxx:4638
 TASImage.cxx:4639
 TASImage.cxx:4640
 TASImage.cxx:4641
 TASImage.cxx:4642
 TASImage.cxx:4643
 TASImage.cxx:4644
 TASImage.cxx:4645
 TASImage.cxx:4646
 TASImage.cxx:4647
 TASImage.cxx:4648
 TASImage.cxx:4649
 TASImage.cxx:4650
 TASImage.cxx:4651
 TASImage.cxx:4652
 TASImage.cxx:4653
 TASImage.cxx:4654
 TASImage.cxx:4655
 TASImage.cxx:4656
 TASImage.cxx:4657
 TASImage.cxx:4658
 TASImage.cxx:4659
 TASImage.cxx:4660
 TASImage.cxx:4661
 TASImage.cxx:4662
 TASImage.cxx:4663
 TASImage.cxx:4664
 TASImage.cxx:4665
 TASImage.cxx:4666
 TASImage.cxx:4667
 TASImage.cxx:4668
 TASImage.cxx:4669
 TASImage.cxx:4670
 TASImage.cxx:4671
 TASImage.cxx:4672
 TASImage.cxx:4673
 TASImage.cxx:4674
 TASImage.cxx:4675
 TASImage.cxx:4676
 TASImage.cxx:4677
 TASImage.cxx:4678
 TASImage.cxx:4679
 TASImage.cxx:4680
 TASImage.cxx:4681
 TASImage.cxx:4682
 TASImage.cxx:4683
 TASImage.cxx:4684
 TASImage.cxx:4685
 TASImage.cxx:4686
 TASImage.cxx:4687
 TASImage.cxx:4688
 TASImage.cxx:4689
 TASImage.cxx:4690
 TASImage.cxx:4691
 TASImage.cxx:4692
 TASImage.cxx:4693
 TASImage.cxx:4694
 TASImage.cxx:4695
 TASImage.cxx:4696
 TASImage.cxx:4697
 TASImage.cxx:4698
 TASImage.cxx:4699
 TASImage.cxx:4700
 TASImage.cxx:4701
 TASImage.cxx:4702
 TASImage.cxx:4703
 TASImage.cxx:4704
 TASImage.cxx:4705
 TASImage.cxx:4706
 TASImage.cxx:4707
 TASImage.cxx:4708
 TASImage.cxx:4709
 TASImage.cxx:4710
 TASImage.cxx:4711
 TASImage.cxx:4712
 TASImage.cxx:4713
 TASImage.cxx:4714
 TASImage.cxx:4715
 TASImage.cxx:4716
 TASImage.cxx:4717
 TASImage.cxx:4718
 TASImage.cxx:4719
 TASImage.cxx:4720
 TASImage.cxx:4721
 TASImage.cxx:4722
 TASImage.cxx:4723
 TASImage.cxx:4724
 TASImage.cxx:4725
 TASImage.cxx:4726
 TASImage.cxx:4727
 TASImage.cxx:4728
 TASImage.cxx:4729
 TASImage.cxx:4730
 TASImage.cxx:4731
 TASImage.cxx:4732
 TASImage.cxx:4733
 TASImage.cxx:4734
 TASImage.cxx:4735
 TASImage.cxx:4736
 TASImage.cxx:4737
 TASImage.cxx:4738
 TASImage.cxx:4739
 TASImage.cxx:4740
 TASImage.cxx:4741
 TASImage.cxx:4742
 TASImage.cxx:4743
 TASImage.cxx:4744
 TASImage.cxx:4745
 TASImage.cxx:4746
 TASImage.cxx:4747
 TASImage.cxx:4748
 TASImage.cxx:4749
 TASImage.cxx:4750
 TASImage.cxx:4751
 TASImage.cxx:4752
 TASImage.cxx:4753
 TASImage.cxx:4754
 TASImage.cxx:4755
 TASImage.cxx:4756
 TASImage.cxx:4757
 TASImage.cxx:4758
 TASImage.cxx:4759
 TASImage.cxx:4760
 TASImage.cxx:4761
 TASImage.cxx:4762
 TASImage.cxx:4763
 TASImage.cxx:4764
 TASImage.cxx:4765
 TASImage.cxx:4766
 TASImage.cxx:4767
 TASImage.cxx:4768
 TASImage.cxx:4769
 TASImage.cxx:4770
 TASImage.cxx:4771
 TASImage.cxx:4772
 TASImage.cxx:4773
 TASImage.cxx:4774
 TASImage.cxx:4775
 TASImage.cxx:4776
 TASImage.cxx:4777
 TASImage.cxx:4778
 TASImage.cxx:4779
 TASImage.cxx:4780
 TASImage.cxx:4781
 TASImage.cxx:4782
 TASImage.cxx:4783
 TASImage.cxx:4784
 TASImage.cxx:4785
 TASImage.cxx:4786
 TASImage.cxx:4787
 TASImage.cxx:4788
 TASImage.cxx:4789
 TASImage.cxx:4790
 TASImage.cxx:4791
 TASImage.cxx:4792
 TASImage.cxx:4793
 TASImage.cxx:4794
 TASImage.cxx:4795
 TASImage.cxx:4796
 TASImage.cxx:4797
 TASImage.cxx:4798
 TASImage.cxx:4799
 TASImage.cxx:4800
 TASImage.cxx:4801
 TASImage.cxx:4802
 TASImage.cxx:4803
 TASImage.cxx:4804
 TASImage.cxx:4805
 TASImage.cxx:4806
 TASImage.cxx:4807
 TASImage.cxx:4808
 TASImage.cxx:4809
 TASImage.cxx:4810
 TASImage.cxx:4811
 TASImage.cxx:4812
 TASImage.cxx:4813
 TASImage.cxx:4814
 TASImage.cxx:4815
 TASImage.cxx:4816
 TASImage.cxx:4817
 TASImage.cxx:4818
 TASImage.cxx:4819
 TASImage.cxx:4820
 TASImage.cxx:4821
 TASImage.cxx:4822
 TASImage.cxx:4823
 TASImage.cxx:4824
 TASImage.cxx:4825
 TASImage.cxx:4826
 TASImage.cxx:4827
 TASImage.cxx:4828
 TASImage.cxx:4829
 TASImage.cxx:4830
 TASImage.cxx:4831
 TASImage.cxx:4832
 TASImage.cxx:4833
 TASImage.cxx:4834
 TASImage.cxx:4835
 TASImage.cxx:4836
 TASImage.cxx:4837
 TASImage.cxx:4838
 TASImage.cxx:4839
 TASImage.cxx:4840
 TASImage.cxx:4841
 TASImage.cxx:4842
 TASImage.cxx:4843
 TASImage.cxx:4844
 TASImage.cxx:4845
 TASImage.cxx:4846
 TASImage.cxx:4847
 TASImage.cxx:4848
 TASImage.cxx:4849
 TASImage.cxx:4850
 TASImage.cxx:4851
 TASImage.cxx:4852
 TASImage.cxx:4853
 TASImage.cxx:4854
 TASImage.cxx:4855
 TASImage.cxx:4856
 TASImage.cxx:4857
 TASImage.cxx:4858
 TASImage.cxx:4859
 TASImage.cxx:4860
 TASImage.cxx:4861
 TASImage.cxx:4862
 TASImage.cxx:4863
 TASImage.cxx:4864
 TASImage.cxx:4865
 TASImage.cxx:4866
 TASImage.cxx:4867
 TASImage.cxx:4868
 TASImage.cxx:4869
 TASImage.cxx:4870
 TASImage.cxx:4871
 TASImage.cxx:4872
 TASImage.cxx:4873
 TASImage.cxx:4874
 TASImage.cxx:4875
 TASImage.cxx:4876
 TASImage.cxx:4877
 TASImage.cxx:4878
 TASImage.cxx:4879
 TASImage.cxx:4880
 TASImage.cxx:4881
 TASImage.cxx:4882
 TASImage.cxx:4883
 TASImage.cxx:4884
 TASImage.cxx:4885
 TASImage.cxx:4886
 TASImage.cxx:4887
 TASImage.cxx:4888
 TASImage.cxx:4889
 TASImage.cxx:4890
 TASImage.cxx:4891
 TASImage.cxx:4892
 TASImage.cxx:4893
 TASImage.cxx:4894
 TASImage.cxx:4895
 TASImage.cxx:4896
 TASImage.cxx:4897
 TASImage.cxx:4898
 TASImage.cxx:4899
 TASImage.cxx:4900
 TASImage.cxx:4901
 TASImage.cxx:4902
 TASImage.cxx:4903
 TASImage.cxx:4904
 TASImage.cxx:4905
 TASImage.cxx:4906
 TASImage.cxx:4907
 TASImage.cxx:4908
 TASImage.cxx:4909
 TASImage.cxx:4910
 TASImage.cxx:4911
 TASImage.cxx:4912
 TASImage.cxx:4913
 TASImage.cxx:4914
 TASImage.cxx:4915
 TASImage.cxx:4916
 TASImage.cxx:4917
 TASImage.cxx:4918
 TASImage.cxx:4919
 TASImage.cxx:4920
 TASImage.cxx:4921
 TASImage.cxx:4922
 TASImage.cxx:4923
 TASImage.cxx:4924
 TASImage.cxx:4925
 TASImage.cxx:4926
 TASImage.cxx:4927
 TASImage.cxx:4928
 TASImage.cxx:4929
 TASImage.cxx:4930
 TASImage.cxx:4931
 TASImage.cxx:4932
 TASImage.cxx:4933
 TASImage.cxx:4934
 TASImage.cxx:4935
 TASImage.cxx:4936
 TASImage.cxx:4937
 TASImage.cxx:4938
 TASImage.cxx:4939
 TASImage.cxx:4940
 TASImage.cxx:4941
 TASImage.cxx:4942
 TASImage.cxx:4943
 TASImage.cxx:4944
 TASImage.cxx:4945
 TASImage.cxx:4946
 TASImage.cxx:4947
 TASImage.cxx:4948
 TASImage.cxx:4949
 TASImage.cxx:4950
 TASImage.cxx:4951
 TASImage.cxx:4952
 TASImage.cxx:4953
 TASImage.cxx:4954
 TASImage.cxx:4955
 TASImage.cxx:4956
 TASImage.cxx:4957
 TASImage.cxx:4958
 TASImage.cxx:4959
 TASImage.cxx:4960
 TASImage.cxx:4961
 TASImage.cxx:4962
 TASImage.cxx:4963
 TASImage.cxx:4964
 TASImage.cxx:4965
 TASImage.cxx:4966
 TASImage.cxx:4967
 TASImage.cxx:4968
 TASImage.cxx:4969
 TASImage.cxx:4970
 TASImage.cxx:4971
 TASImage.cxx:4972
 TASImage.cxx:4973
 TASImage.cxx:4974
 TASImage.cxx:4975
 TASImage.cxx:4976
 TASImage.cxx:4977
 TASImage.cxx:4978
 TASImage.cxx:4979
 TASImage.cxx:4980
 TASImage.cxx:4981
 TASImage.cxx:4982
 TASImage.cxx:4983
 TASImage.cxx:4984
 TASImage.cxx:4985
 TASImage.cxx:4986
 TASImage.cxx:4987
 TASImage.cxx:4988
 TASImage.cxx:4989
 TASImage.cxx:4990
 TASImage.cxx:4991
 TASImage.cxx:4992
 TASImage.cxx:4993
 TASImage.cxx:4994
 TASImage.cxx:4995
 TASImage.cxx:4996
 TASImage.cxx:4997
 TASImage.cxx:4998
 TASImage.cxx:4999
 TASImage.cxx:5000
 TASImage.cxx:5001
 TASImage.cxx:5002
 TASImage.cxx:5003
 TASImage.cxx:5004
 TASImage.cxx:5005
 TASImage.cxx:5006
 TASImage.cxx:5007
 TASImage.cxx:5008
 TASImage.cxx:5009
 TASImage.cxx:5010
 TASImage.cxx:5011
 TASImage.cxx:5012
 TASImage.cxx:5013
 TASImage.cxx:5014
 TASImage.cxx:5015
 TASImage.cxx:5016
 TASImage.cxx:5017
 TASImage.cxx:5018
 TASImage.cxx:5019
 TASImage.cxx:5020
 TASImage.cxx:5021
 TASImage.cxx:5022
 TASImage.cxx:5023
 TASImage.cxx:5024
 TASImage.cxx:5025
 TASImage.cxx:5026
 TASImage.cxx:5027
 TASImage.cxx:5028
 TASImage.cxx:5029
 TASImage.cxx:5030
 TASImage.cxx:5031
 TASImage.cxx:5032
 TASImage.cxx:5033
 TASImage.cxx:5034
 TASImage.cxx:5035
 TASImage.cxx:5036
 TASImage.cxx:5037
 TASImage.cxx:5038
 TASImage.cxx:5039
 TASImage.cxx:5040
 TASImage.cxx:5041
 TASImage.cxx:5042
 TASImage.cxx:5043
 TASImage.cxx:5044
 TASImage.cxx:5045
 TASImage.cxx:5046
 TASImage.cxx:5047
 TASImage.cxx:5048
 TASImage.cxx:5049
 TASImage.cxx:5050
 TASImage.cxx:5051
 TASImage.cxx:5052
 TASImage.cxx:5053
 TASImage.cxx:5054
 TASImage.cxx:5055
 TASImage.cxx:5056
 TASImage.cxx:5057
 TASImage.cxx:5058
 TASImage.cxx:5059
 TASImage.cxx:5060
 TASImage.cxx:5061
 TASImage.cxx:5062
 TASImage.cxx:5063
 TASImage.cxx:5064
 TASImage.cxx:5065
 TASImage.cxx:5066
 TASImage.cxx:5067
 TASImage.cxx:5068
 TASImage.cxx:5069
 TASImage.cxx:5070
 TASImage.cxx:5071
 TASImage.cxx:5072
 TASImage.cxx:5073
 TASImage.cxx:5074
 TASImage.cxx:5075
 TASImage.cxx:5076
 TASImage.cxx:5077
 TASImage.cxx:5078
 TASImage.cxx:5079
 TASImage.cxx:5080
 TASImage.cxx:5081
 TASImage.cxx:5082
 TASImage.cxx:5083
 TASImage.cxx:5084
 TASImage.cxx:5085
 TASImage.cxx:5086
 TASImage.cxx:5087
 TASImage.cxx:5088
 TASImage.cxx:5089
 TASImage.cxx:5090
 TASImage.cxx:5091
 TASImage.cxx:5092
 TASImage.cxx:5093
 TASImage.cxx:5094
 TASImage.cxx:5095
 TASImage.cxx:5096
 TASImage.cxx:5097
 TASImage.cxx:5098
 TASImage.cxx:5099
 TASImage.cxx:5100
 TASImage.cxx:5101
 TASImage.cxx:5102
 TASImage.cxx:5103
 TASImage.cxx:5104
 TASImage.cxx:5105
 TASImage.cxx:5106
 TASImage.cxx:5107
 TASImage.cxx:5108
 TASImage.cxx:5109
 TASImage.cxx:5110
 TASImage.cxx:5111
 TASImage.cxx:5112
 TASImage.cxx:5113
 TASImage.cxx:5114
 TASImage.cxx:5115
 TASImage.cxx:5116
 TASImage.cxx:5117
 TASImage.cxx:5118
 TASImage.cxx:5119
 TASImage.cxx:5120
 TASImage.cxx:5121
 TASImage.cxx:5122
 TASImage.cxx:5123
 TASImage.cxx:5124
 TASImage.cxx:5125
 TASImage.cxx:5126
 TASImage.cxx:5127
 TASImage.cxx:5128
 TASImage.cxx:5129
 TASImage.cxx:5130
 TASImage.cxx:5131
 TASImage.cxx:5132
 TASImage.cxx:5133
 TASImage.cxx:5134
 TASImage.cxx:5135
 TASImage.cxx:5136
 TASImage.cxx:5137
 TASImage.cxx:5138
 TASImage.cxx:5139
 TASImage.cxx:5140
 TASImage.cxx:5141
 TASImage.cxx:5142
 TASImage.cxx:5143
 TASImage.cxx:5144
 TASImage.cxx:5145
 TASImage.cxx:5146
 TASImage.cxx:5147
 TASImage.cxx:5148
 TASImage.cxx:5149
 TASImage.cxx:5150
 TASImage.cxx:5151
 TASImage.cxx:5152
 TASImage.cxx:5153
 TASImage.cxx:5154
 TASImage.cxx:5155
 TASImage.cxx:5156
 TASImage.cxx:5157
 TASImage.cxx:5158
 TASImage.cxx:5159
 TASImage.cxx:5160
 TASImage.cxx:5161
 TASImage.cxx:5162
 TASImage.cxx:5163
 TASImage.cxx:5164
 TASImage.cxx:5165
 TASImage.cxx:5166
 TASImage.cxx:5167
 TASImage.cxx:5168
 TASImage.cxx:5169
 TASImage.cxx:5170
 TASImage.cxx:5171
 TASImage.cxx:5172
 TASImage.cxx:5173
 TASImage.cxx:5174
 TASImage.cxx:5175
 TASImage.cxx:5176
 TASImage.cxx:5177
 TASImage.cxx:5178
 TASImage.cxx:5179
 TASImage.cxx:5180
 TASImage.cxx:5181
 TASImage.cxx:5182
 TASImage.cxx:5183
 TASImage.cxx:5184
 TASImage.cxx:5185
 TASImage.cxx:5186
 TASImage.cxx:5187
 TASImage.cxx:5188
 TASImage.cxx:5189
 TASImage.cxx:5190
 TASImage.cxx:5191
 TASImage.cxx:5192
 TASImage.cxx:5193
 TASImage.cxx:5194
 TASImage.cxx:5195
 TASImage.cxx:5196
 TASImage.cxx:5197
 TASImage.cxx:5198
 TASImage.cxx:5199
 TASImage.cxx:5200
 TASImage.cxx:5201
 TASImage.cxx:5202
 TASImage.cxx:5203
 TASImage.cxx:5204
 TASImage.cxx:5205
 TASImage.cxx:5206
 TASImage.cxx:5207
 TASImage.cxx:5208
 TASImage.cxx:5209
 TASImage.cxx:5210
 TASImage.cxx:5211
 TASImage.cxx:5212
 TASImage.cxx:5213
 TASImage.cxx:5214
 TASImage.cxx:5215
 TASImage.cxx:5216
 TASImage.cxx:5217
 TASImage.cxx:5218
 TASImage.cxx:5219
 TASImage.cxx:5220
 TASImage.cxx:5221
 TASImage.cxx:5222
 TASImage.cxx:5223
 TASImage.cxx:5224
 TASImage.cxx:5225
 TASImage.cxx:5226
 TASImage.cxx:5227
 TASImage.cxx:5228
 TASImage.cxx:5229
 TASImage.cxx:5230
 TASImage.cxx:5231
 TASImage.cxx:5232
 TASImage.cxx:5233
 TASImage.cxx:5234
 TASImage.cxx:5235
 TASImage.cxx:5236
 TASImage.cxx:5237
 TASImage.cxx:5238
 TASImage.cxx:5239
 TASImage.cxx:5240
 TASImage.cxx:5241
 TASImage.cxx:5242
 TASImage.cxx:5243
 TASImage.cxx:5244
 TASImage.cxx:5245
 TASImage.cxx:5246
 TASImage.cxx:5247
 TASImage.cxx:5248
 TASImage.cxx:5249
 TASImage.cxx:5250
 TASImage.cxx:5251
 TASImage.cxx:5252
 TASImage.cxx:5253
 TASImage.cxx:5254
 TASImage.cxx:5255
 TASImage.cxx:5256
 TASImage.cxx:5257
 TASImage.cxx:5258
 TASImage.cxx:5259
 TASImage.cxx:5260
 TASImage.cxx:5261
 TASImage.cxx:5262
 TASImage.cxx:5263
 TASImage.cxx:5264
 TASImage.cxx:5265
 TASImage.cxx:5266
 TASImage.cxx:5267
 TASImage.cxx:5268
 TASImage.cxx:5269
 TASImage.cxx:5270
 TASImage.cxx:5271
 TASImage.cxx:5272
 TASImage.cxx:5273
 TASImage.cxx:5274
 TASImage.cxx:5275
 TASImage.cxx:5276
 TASImage.cxx:5277
 TASImage.cxx:5278
 TASImage.cxx:5279
 TASImage.cxx:5280
 TASImage.cxx:5281
 TASImage.cxx:5282
 TASImage.cxx:5283
 TASImage.cxx:5284
 TASImage.cxx:5285
 TASImage.cxx:5286
 TASImage.cxx:5287
 TASImage.cxx:5288
 TASImage.cxx:5289
 TASImage.cxx:5290
 TASImage.cxx:5291
 TASImage.cxx:5292
 TASImage.cxx:5293
 TASImage.cxx:5294
 TASImage.cxx:5295
 TASImage.cxx:5296
 TASImage.cxx:5297
 TASImage.cxx:5298
 TASImage.cxx:5299
 TASImage.cxx:5300
 TASImage.cxx:5301
 TASImage.cxx:5302
 TASImage.cxx:5303
 TASImage.cxx:5304
 TASImage.cxx:5305
 TASImage.cxx:5306
 TASImage.cxx:5307
 TASImage.cxx:5308
 TASImage.cxx:5309
 TASImage.cxx:5310
 TASImage.cxx:5311
 TASImage.cxx:5312
 TASImage.cxx:5313
 TASImage.cxx:5314
 TASImage.cxx:5315
 TASImage.cxx:5316
 TASImage.cxx:5317
 TASImage.cxx:5318
 TASImage.cxx:5319
 TASImage.cxx:5320
 TASImage.cxx:5321
 TASImage.cxx:5322
 TASImage.cxx:5323
 TASImage.cxx:5324
 TASImage.cxx:5325
 TASImage.cxx:5326
 TASImage.cxx:5327
 TASImage.cxx:5328
 TASImage.cxx:5329
 TASImage.cxx:5330
 TASImage.cxx:5331
 TASImage.cxx:5332
 TASImage.cxx:5333
 TASImage.cxx:5334
 TASImage.cxx:5335
 TASImage.cxx:5336
 TASImage.cxx:5337
 TASImage.cxx:5338
 TASImage.cxx:5339
 TASImage.cxx:5340
 TASImage.cxx:5341
 TASImage.cxx:5342
 TASImage.cxx:5343
 TASImage.cxx:5344
 TASImage.cxx:5345
 TASImage.cxx:5346
 TASImage.cxx:5347
 TASImage.cxx:5348
 TASImage.cxx:5349
 TASImage.cxx:5350
 TASImage.cxx:5351
 TASImage.cxx:5352
 TASImage.cxx:5353
 TASImage.cxx:5354
 TASImage.cxx:5355
 TASImage.cxx:5356
 TASImage.cxx:5357
 TASImage.cxx:5358
 TASImage.cxx:5359
 TASImage.cxx:5360
 TASImage.cxx:5361
 TASImage.cxx:5362
 TASImage.cxx:5363
 TASImage.cxx:5364
 TASImage.cxx:5365
 TASImage.cxx:5366
 TASImage.cxx:5367
 TASImage.cxx:5368
 TASImage.cxx:5369
 TASImage.cxx:5370
 TASImage.cxx:5371
 TASImage.cxx:5372
 TASImage.cxx:5373
 TASImage.cxx:5374
 TASImage.cxx:5375
 TASImage.cxx:5376
 TASImage.cxx:5377
 TASImage.cxx:5378
 TASImage.cxx:5379
 TASImage.cxx:5380
 TASImage.cxx:5381
 TASImage.cxx:5382
 TASImage.cxx:5383
 TASImage.cxx:5384
 TASImage.cxx:5385
 TASImage.cxx:5386
 TASImage.cxx:5387
 TASImage.cxx:5388
 TASImage.cxx:5389
 TASImage.cxx:5390
 TASImage.cxx:5391
 TASImage.cxx:5392
 TASImage.cxx:5393
 TASImage.cxx:5394
 TASImage.cxx:5395
 TASImage.cxx:5396
 TASImage.cxx:5397
 TASImage.cxx:5398
 TASImage.cxx:5399
 TASImage.cxx:5400
 TASImage.cxx:5401
 TASImage.cxx:5402
 TASImage.cxx:5403
 TASImage.cxx:5404
 TASImage.cxx:5405
 TASImage.cxx:5406
 TASImage.cxx:5407
 TASImage.cxx:5408
 TASImage.cxx:5409
 TASImage.cxx:5410
 TASImage.cxx:5411
 TASImage.cxx:5412
 TASImage.cxx:5413
 TASImage.cxx:5414
 TASImage.cxx:5415
 TASImage.cxx:5416
 TASImage.cxx:5417
 TASImage.cxx:5418
 TASImage.cxx:5419
 TASImage.cxx:5420
 TASImage.cxx:5421
 TASImage.cxx:5422
 TASImage.cxx:5423
 TASImage.cxx:5424
 TASImage.cxx:5425
 TASImage.cxx:5426
 TASImage.cxx:5427
 TASImage.cxx:5428
 TASImage.cxx:5429
 TASImage.cxx:5430
 TASImage.cxx:5431
 TASImage.cxx:5432
 TASImage.cxx:5433
 TASImage.cxx:5434
 TASImage.cxx:5435
 TASImage.cxx:5436
 TASImage.cxx:5437
 TASImage.cxx:5438
 TASImage.cxx:5439
 TASImage.cxx:5440
 TASImage.cxx:5441
 TASImage.cxx:5442
 TASImage.cxx:5443
 TASImage.cxx:5444
 TASImage.cxx:5445
 TASImage.cxx:5446
 TASImage.cxx:5447
 TASImage.cxx:5448
 TASImage.cxx:5449
 TASImage.cxx:5450
 TASImage.cxx:5451
 TASImage.cxx:5452
 TASImage.cxx:5453
 TASImage.cxx:5454
 TASImage.cxx:5455
 TASImage.cxx:5456
 TASImage.cxx:5457
 TASImage.cxx:5458
 TASImage.cxx:5459
 TASImage.cxx:5460
 TASImage.cxx:5461
 TASImage.cxx:5462
 TASImage.cxx:5463
 TASImage.cxx:5464
 TASImage.cxx:5465
 TASImage.cxx:5466
 TASImage.cxx:5467
 TASImage.cxx:5468
 TASImage.cxx:5469
 TASImage.cxx:5470
 TASImage.cxx:5471
 TASImage.cxx:5472
 TASImage.cxx:5473
 TASImage.cxx:5474
 TASImage.cxx:5475
 TASImage.cxx:5476
 TASImage.cxx:5477
 TASImage.cxx:5478
 TASImage.cxx:5479
 TASImage.cxx:5480
 TASImage.cxx:5481
 TASImage.cxx:5482
 TASImage.cxx:5483
 TASImage.cxx:5484
 TASImage.cxx:5485
 TASImage.cxx:5486
 TASImage.cxx:5487
 TASImage.cxx:5488
 TASImage.cxx:5489
 TASImage.cxx:5490
 TASImage.cxx:5491
 TASImage.cxx:5492
 TASImage.cxx:5493
 TASImage.cxx:5494
 TASImage.cxx:5495
 TASImage.cxx:5496
 TASImage.cxx:5497
 TASImage.cxx:5498
 TASImage.cxx:5499
 TASImage.cxx:5500
 TASImage.cxx:5501
 TASImage.cxx:5502
 TASImage.cxx:5503
 TASImage.cxx:5504
 TASImage.cxx:5505
 TASImage.cxx:5506
 TASImage.cxx:5507
 TASImage.cxx:5508
 TASImage.cxx:5509
 TASImage.cxx:5510
 TASImage.cxx:5511
 TASImage.cxx:5512
 TASImage.cxx:5513
 TASImage.cxx:5514
 TASImage.cxx:5515
 TASImage.cxx:5516
 TASImage.cxx:5517
 TASImage.cxx:5518
 TASImage.cxx:5519
 TASImage.cxx:5520
 TASImage.cxx:5521
 TASImage.cxx:5522
 TASImage.cxx:5523
 TASImage.cxx:5524
 TASImage.cxx:5525
 TASImage.cxx:5526
 TASImage.cxx:5527
 TASImage.cxx:5528
 TASImage.cxx:5529
 TASImage.cxx:5530
 TASImage.cxx:5531
 TASImage.cxx:5532
 TASImage.cxx:5533
 TASImage.cxx:5534
 TASImage.cxx:5535
 TASImage.cxx:5536
 TASImage.cxx:5537
 TASImage.cxx:5538
 TASImage.cxx:5539
 TASImage.cxx:5540
 TASImage.cxx:5541
 TASImage.cxx:5542
 TASImage.cxx:5543
 TASImage.cxx:5544
 TASImage.cxx:5545
 TASImage.cxx:5546
 TASImage.cxx:5547
 TASImage.cxx:5548
 TASImage.cxx:5549
 TASImage.cxx:5550
 TASImage.cxx:5551
 TASImage.cxx:5552
 TASImage.cxx:5553
 TASImage.cxx:5554
 TASImage.cxx:5555
 TASImage.cxx:5556
 TASImage.cxx:5557
 TASImage.cxx:5558
 TASImage.cxx:5559
 TASImage.cxx:5560
 TASImage.cxx:5561
 TASImage.cxx:5562
 TASImage.cxx:5563
 TASImage.cxx:5564
 TASImage.cxx:5565
 TASImage.cxx:5566
 TASImage.cxx:5567
 TASImage.cxx:5568
 TASImage.cxx:5569
 TASImage.cxx:5570
 TASImage.cxx:5571
 TASImage.cxx:5572
 TASImage.cxx:5573
 TASImage.cxx:5574
 TASImage.cxx:5575
 TASImage.cxx:5576
 TASImage.cxx:5577
 TASImage.cxx:5578
 TASImage.cxx:5579
 TASImage.cxx:5580
 TASImage.cxx:5581
 TASImage.cxx:5582
 TASImage.cxx:5583
 TASImage.cxx:5584
 TASImage.cxx:5585
 TASImage.cxx:5586
 TASImage.cxx:5587
 TASImage.cxx:5588
 TASImage.cxx:5589
 TASImage.cxx:5590
 TASImage.cxx:5591
 TASImage.cxx:5592
 TASImage.cxx:5593
 TASImage.cxx:5594
 TASImage.cxx:5595
 TASImage.cxx:5596
 TASImage.cxx:5597
 TASImage.cxx:5598
 TASImage.cxx:5599
 TASImage.cxx:5600
 TASImage.cxx:5601
 TASImage.cxx:5602
 TASImage.cxx:5603
 TASImage.cxx:5604
 TASImage.cxx:5605
 TASImage.cxx:5606
 TASImage.cxx:5607
 TASImage.cxx:5608
 TASImage.cxx:5609
 TASImage.cxx:5610
 TASImage.cxx:5611
 TASImage.cxx:5612
 TASImage.cxx:5613
 TASImage.cxx:5614
 TASImage.cxx:5615
 TASImage.cxx:5616
 TASImage.cxx:5617
 TASImage.cxx:5618
 TASImage.cxx:5619
 TASImage.cxx:5620
 TASImage.cxx: