ROOT logo
// @(#)root/base:$Id$
// Author: Fons Rademakers   04/08/95

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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TString                                                              //
//                                                                      //
// Basic string class.                                                  //
//                                                                      //
// Cannot be stored in a TCollection... use TObjString instead.         //
//                                                                      //
// The underlying string is stored as a char* that can be accessed via  //
// TString::Data().                                                     //
// TString provides Short String Optimization (SSO) so that short       //
// strings (<15 on 64-bit and <11 on 32-bit) are contained in the       //
// TString internal data structure without the need for mallocing the   //
// required space.                                                      //
//                                                                      //
// Substring operations are provided by the TSubString class, which     //
// holds a reference to the original string and its data, along with    //
// the offset and length of the substring. To retrieve the substring    //
// as a TString, construct a TString from it, eg:                       //
//   root [0] TString s("hello world")                                  //
//   root [1] TString s2( s(0,5) )                                      //
//   root [2] s2                                                        //
//   (class TString)"hello"                                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "RConfig.h"
#include <stdlib.h>
#include <ctype.h>
#include <list>
#include <algorithm>

#include "snprintf.h"
#include "Varargs.h"
#include "TString.h"
#include "TBuffer.h"
#include "TError.h"
#include "Bytes.h"
#include "TClass.h"
#include "TMD5.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TVirtualMutex.h"
#include "ThreadLocalStorage.h"


#if defined(R__WIN32)
#define strtoull _strtoui64
#endif

#ifdef R__GLOBALSTL
namespace std { using ::list; }
#endif

ClassImp(TString)

// Amount to shift hash values to avoid clustering
const UInt_t kHashShift = 5;

// ------------------------------------------------------------------------
//
// In what follows, fCap is the length of the underlying representation
// vector. Hence, the capacity for a null terminated string held in this
// vector is fCap-1.  The variable fSize is the length of the held
// string, excluding the terminating null.
//
// The algorithms make no assumptions about whether internal strings
// hold embedded nulls. However, they do assume that any string
// passed in as an argument that does not have a length count is null
// terminated and therefore has no embedded nulls.
//
// The internal string is always null terminated.
//
// ------------------------------------------------------------------------

//////////////////////////////////////////////////////////////////////////
//                                                                      //
//  TString                                                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

//______________________________________________________________________________
TString::TString()
{
   // TString default ctor.

   Zero();
}

//______________________________________________________________________________
TString::TString(Ssiz_t ic)
{
   // Create TString able to contain ic characters.

   Init(ic, 0);
}

//______________________________________________________________________________
TString::TString(const char *cs)
{
   // Create TString and initialize it with string cs.

   if (cs) {
      Ssiz_t n = strlen(cs);
      char *data = Init(n, n);
      memcpy(data, cs, n);
   } else
      Init(0, 0);
}

//______________________________________________________________________________
TString::TString(const std::string &s)
{
   // Create TString and initialize it with string cs.

   Ssiz_t n = s.length();
   char *data = Init(n, n);
   memcpy(data, s.c_str(), n);
}

//______________________________________________________________________________
TString::TString(const char *cs, Ssiz_t n)
{
   // Create TString and initialize it with the first n characters of cs.

   char *data = Init(n, n);
   memcpy(data, cs, n);
}

//______________________________________________________________________________
void TString::InitChar(char c)
{
   // Initialize a string with a single character.

   char *data = Init(1, 1);
   data[0] = c;
}

//______________________________________________________________________________
TString::TString(char c)
{
   // Initialize a string with a single character.

   InitChar(c);
}

//______________________________________________________________________________
TString::TString(char c, Ssiz_t n)
{
   // Initialize the first n locations of a TString with character c.

   char *data = Init(n, n);
   while (n--) data[n] = c;
}

//______________________________________________________________________________
TString::TString(const TString &s)
{
   // Copy constructor.

   if (!s.IsLong())
      fRep.fRaw = s.fRep.fRaw;
   else {
      Ssiz_t n = s.GetLongSize();
      char *data = Init(n, n);
      memcpy(data, s.GetLongPointer(), n);
   }
}

//______________________________________________________________________________
TString::TString(const TSubString& substr)
{
   // Copy a TSubString in a TString.

   Ssiz_t len = substr.IsNull() ? 0 : substr.Length();
   char *data = Init(len, len);
   memcpy(data, substr.Data(), len);
}

//______________________________________________________________________________
TString::TString(const char *a1, Ssiz_t n1, const char *a2, Ssiz_t n2)
{
   // Special constructor to initialize with the concatenation of a1 and a2.

   if (!a1) n1=0;
   if (!a2) n2=0;
   Ssiz_t tot = n1+n2;
   char *data = Init(tot, tot);
   memcpy(data,    a1, n1);
   memcpy(data+n1, a2, n2);
}

//______________________________________________________________________________
TString::~TString()
{
   // Delete a TString.

   UnLink();
}

//______________________________________________________________________________
char *TString::Init(Ssiz_t capacity, Ssiz_t nchar)
{
   // Private member function returning an empty string representation of
   // size capacity and containing nchar characters.

   if (capacity > MaxSize()) {
      Error("TString::Init", "capacity too large (%d, max = %d)", capacity, MaxSize());
      capacity = MaxSize();
      if (nchar > capacity)
         nchar = capacity;
   }

   char *data;
   if (capacity < kMinCap) {
      SetShortSize(nchar);
      data = GetShortPointer();
   } else {
      Ssiz_t cap = Recommend(capacity);
      data = new char[cap+1];
      SetLongCap(cap+1);
      SetLongSize(nchar);
      SetLongPointer(data);
   }
   data[nchar] = 0;  // terminating null

   return data;
}

//______________________________________________________________________________
TString& TString::operator=(char c)
{
   // Assign character c to TString.

   if (!c) {
      UnLink();
      Zero();
      return *this;
   }
   return Replace(0, Length(), &c, 1);
}

//______________________________________________________________________________
TString& TString::operator=(const char *cs)
{
   // Assign string cs to TString.

   if (!cs || !*cs) {
      UnLink();
      Zero();
      return *this;
   }
   return Replace(0, Length(), cs, strlen(cs));
}

//______________________________________________________________________________
TString& TString::operator=(const std::string &s)
{
   // Assign std::string s to TString.

   if (s.length()==0) {
      UnLink();
      Zero();
      return *this;
   }
   return Replace(0, Length(), s.c_str(), s.length());
}

//______________________________________________________________________________
TString& TString::operator=(const TString &rhs)
{
   // Assignment operator.

   if (this != &rhs) {
      UnLink();
      if (!rhs.IsLong())
         fRep.fRaw = rhs.fRep.fRaw;
      else {
         Ssiz_t n = rhs.GetLongSize();
         char *data = Init(n, n);
         memcpy(data, rhs.GetLongPointer(), n);
      }
   }
   return *this;
}

//______________________________________________________________________________
TString& TString::operator=(const TSubString &substr)
{
   // Assign a TSubString substr to TString.

   Ssiz_t len = substr.IsNull() ? 0 : substr.Length();
   if (!len) {
      UnLink();
      Zero();
      return *this;
   }
   return Replace(0, Length(), substr.Data(), len);
}

//______________________________________________________________________________
TString& TString::Append(char c, Ssiz_t rep)
{
   // Append character c rep times to string.

   if (!rep) return *this;

   Ssiz_t len = Length();
   Ssiz_t tot = len + rep;  // Final string length

   if (tot > MaxSize()) {
      Error("TString::Append", "rep too large (%d, max = %d)", rep, MaxSize()-len);
      tot = MaxSize();
      rep = tot - len;
   }

   Ssiz_t capac = Capacity();
   char *data, *p = GetPointer();

   if (capac - tot >= 0) {
      SetSize(tot);
      data = p;
   } else {
      Ssiz_t cap = AdjustCapacity(capac, tot);
      data = new char[cap+1];
      memcpy(data, p, len);
      UnLink();
      SetLongCap(cap+1);
      SetLongSize(tot);
      SetLongPointer(data);
   }
   data[tot] = 0;

   data += len;
   while (rep--)
      *data++ = c;

   return *this;
}

//______________________________________________________________________________
Ssiz_t TString::Capacity(Ssiz_t nc)
{
   // Return string capacity. If nc != current capacity Clone() the string
   // in a string with the desired capacity.

   if (nc > Length())
      Clone(nc);

   return Capacity();
}

//______________________________________________________________________________
int TString::CompareTo(const char *cs2, ECaseCompare cmp) const
{
   // Compare a string to char *cs2. Returns returns zero if the two
   // strings are identical, otherwise returns the difference between
   // the first two differing bytes (treated as unsigned char values,
   // so that `\200' is greater than `\0', for example). Zero-length
   // strings are always identical.

   if (!cs2) return 1;

   const char *cs1 = Data();
   Ssiz_t len = Length();
   Ssiz_t i = 0;
   if (cmp == kExact) {
      for (; cs2[i]; ++i) {
         if (i == len) return -1;
         if (cs1[i] != cs2[i]) return ((cs1[i] > cs2[i]) ? 1 : -1);
      }
   } else {                  // ignore case
      for (; cs2[i]; ++i) {
         if (i == len) return -1;
         char c1 = tolower((unsigned char)cs1[i]);
         char c2 = tolower((unsigned char)cs2[i]);
         if (c1 != c2) return ((c1 > c2) ? 1 : -1);
      }
   }
   return (i < len) ? 1 : 0;
}

//______________________________________________________________________________
int TString::CompareTo(const TString &str, ECaseCompare cmp) const
{
   // Compare a string to another string. Returns returns zero if the two
   // strings are identical, otherwise returns the difference between
   // the first two differing bytes (treated as unsigned char values,
   // so that `\200' is greater than `\0', for example). Zero-length
   // strings are always identical.

   const char *s1 = Data();
   const char *s2 = str.Data();
   Ssiz_t len = Length();
   Ssiz_t slen, sleno = str.Length();
   slen = sleno;
   if (len < slen) slen = len;
   if (cmp == kExact) {
      int result = memcmp(s1, s2, slen);
      if (result != 0) return result;
   } else {
      Ssiz_t i = 0;
      for (; i < slen; ++i) {
         char c1 = tolower((unsigned char)s1[i]);
         char c2 = tolower((unsigned char)s2[i]);
         if (c1 != c2) return ((c1 > c2) ? 1 : -1);
      }
   }
   // strings are equal up to the length of the shorter one.
   slen = sleno;
   if (len == slen) return 0;
   return (len > slen) ? 1 : -1;
}

//______________________________________________________________________________
Int_t TString::CountChar(Int_t c) const
{
   // Return number of times character c occurs in the string.

   Int_t count = 0;
   Int_t len   = Length();
   const char *data  = Data();
   for (Int_t n = 0; n < len; n++)
      if (data[n] == c) count++;

   return count;
}

//______________________________________________________________________________
TString TString::Copy() const
{
   // Copy a string.

   TString temp(*this);
   return temp;
}

//______________________________________________________________________________
Ssiz_t TString::First(char c) const
{
   // Find first occurrence of a character c.

   const char *f = strchr(Data(), c);
   return f ? f - Data() : kNPOS;
}

//______________________________________________________________________________
Ssiz_t TString::First(const char *cs) const
{
   // Find first occurrence of a character in cs.

   const char *f = strpbrk(Data(), cs);
   return f ? f - Data() : kNPOS;
}

#ifndef R__BYTESWAP
//______________________________________________________________________________
inline static UInt_t SwapInt(UInt_t x)
{
   return (((x & 0x000000ffU) << 24) | ((x & 0x0000ff00U) <<  8) |
           ((x & 0x00ff0000U) >>  8) | ((x & 0xff000000U) >> 24));
}
#endif

//______________________________________________________________________________
inline static void Mash(UInt_t& hash, UInt_t chars)
{
   // Utility used by Hash().

   hash = (chars ^
           ((hash << kHashShift) |
            (hash >> (kBitsPerByte*sizeof(UInt_t) - kHashShift))));
}

//______________________________________________________________________________
UInt_t Hash(const char *str)
{
   // Return a case-sensitive hash value (endian independent).

   UInt_t len = str ? strlen(str) : 0;
   UInt_t hv  = len; // Mix in the string length.
   UInt_t i   = hv*sizeof(char)/sizeof(UInt_t);

   if (((ULong_t)str)%sizeof(UInt_t) == 0) {
      // str is word aligned
      const UInt_t *p = (const UInt_t*)str;

      while (i--) {
#ifndef R__BYTESWAP
         UInt_t h = *p++;
         Mash(hv, SwapInt(h));
#else
         Mash(hv, *p++);                   // XOR in the characters.
#endif
      }

      // XOR in any remaining characters:
      if ((i = len*sizeof(char)%sizeof(UInt_t)) != 0) {
         UInt_t h = 0;
         const char* c = (const char*)p;
         while (i--)
            h = ((h << kBitsPerByte*sizeof(char)) | *c++);
         Mash(hv, h);
      }
   } else {
      // str is not word aligned
      UInt_t h;
      const unsigned char *p = (const unsigned char*)str;

      while (i--) {
         memcpy(&h, p, sizeof(UInt_t));
#ifndef R__BYTESWAP
         Mash(hv, SwapInt(h));
#else
         Mash(hv, h);
#endif
         p += sizeof(UInt_t);
      }

      // XOR in any remaining characters:
      if ((i = len*sizeof(char)%sizeof(UInt_t)) != 0) {
         h = 0;
         const char* c = (const char*)p;
         while (i--)
            h = ((h << kBitsPerByte*sizeof(char)) | *c++);
         Mash(hv, h);
      }
   }
   return hv;
}

//______________________________________________________________________________
UInt_t TString::HashCase() const
{
   // Return a case-sensitive hash value (endian independent).

   UInt_t hv       = (UInt_t)Length(); // Mix in the string length.
   UInt_t i        = hv*sizeof(char)/sizeof(UInt_t);
   const UInt_t *p = (const UInt_t*)Data();
   {
      while (i--) {
#ifndef R__BYTESWAP
         UInt_t h = *p++;
         Mash(hv, SwapInt(h));             // XOR in the characters.
#else
         Mash(hv, *p++);                   // XOR in the characters.
#endif
      }
   }
   // XOR in any remaining characters:
   if ((i = Length()*sizeof(char)%sizeof(UInt_t)) != 0) {
      UInt_t h = 0;
      const char* c = (const char*)p;
      while (i--)
         h = ((h << kBitsPerByte*sizeof(char)) | *c++);
      Mash(hv, h);
   }
   return hv;
}

//______________________________________________________________________________
UInt_t TString::HashFoldCase() const
{
   // Return a case-insensitive hash value (endian independent).

   UInt_t hv = (UInt_t)Length();    // Mix in the string length.
   UInt_t i  = hv;
   const unsigned char *p = (const unsigned char*)Data();
   while (i--) {
      Mash(hv, toupper(*p));
      ++p;
   }
   return hv;
}

//______________________________________________________________________________
UInt_t TString::Hash(ECaseCompare cmp) const
{
   // Return hash value.

   return (cmp == kExact) ? HashCase() : HashFoldCase();
}

namespace {
   // MurmurHash3 - a blazingly fast public domain hash!
   // See http://code.google.com/p/smhasher/
   // There are two versions, one optimized for 32 bit and one for 64 bit.
   // They give different hash results!
   // We use only the 64 bit version which also works on 32 bit.

   //-----------------------------------------------------------------------------
   // MurmurHash3 was written by Austin Appleby, and is placed in the public
   // domain. The author hereby disclaims copyright to this source code.

   // Note - The x86 and x64 versions do _not_ produce the same results, as the
   // algorithms are optimized for their respective platforms. You can still
   // compile and run any of them on any platform, but your performance with the
   // non-native version will be less than optimal.

   //-----------------------------------------------------------------------------
   // Platform-specific functions and macros

   // From MurmurHash.h:

#if defined(_MSC_VER)
   // Microsoft Visual Studio
   typedef unsigned char uint8_t;
   typedef unsigned long uint32_t;
   typedef unsigned __int64 uint64_t;
#else // defined(_MSC_VER)
   // Other compilers
#include <stdint.h>
#endif // !defined(_MSC_VER)

   // From MurmurHash.cpp:
#if defined(_MSC_VER)
   // Microsoft Visual Studio
#define FORCE_INLINE    __forceinline
#include <stdlib.h>
#define ROTL64(x,y)     _rotl64(x,y)
#define BIG_CONSTANT(x) (x)
#else   // defined(_MSC_VER)
   // Other compilers
   inline uint64_t rotl64 ( uint64_t x, int8_t r )
   {
      return (x << r) | (x >> (64 - r));
   }

#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) <= 40101
// gcc v4.1.1 can't inline getblock, so don't really force it.
#define FORCE_INLINE inline
#else
// (at least) in gcc v4.7, __attribute__((always_inline))" does not replace "inline" and they
// need to be used together. 
#define FORCE_INLINE __attribute__((always_inline)) inline
#endif
#define ROTL64(x,y)     rotl64(x,y)
#define BIG_CONSTANT(x) (x##LLU)
#endif // !defined(_MSC_VER)

   //-----------------------------------------------------------------------------
   FORCE_INLINE uint64_t getblock(const uint64_t* p, int i)
   {
      // Block read - if your platform needs to do endian-swapping or can only
      // handle aligned reads, do the conversion here
      return p[i];
   }

   //-----------------------------------------------------------------------------
   FORCE_INLINE uint64_t fmix(uint64_t k)
   {
      // Finalization mix - force all bits of a hash block to avalanche
      k ^= k >> 33;
      k *= BIG_CONSTANT(0xff51afd7ed558ccd);
      k ^= k >> 33;
      k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53);
      k ^= k >> 33;

      return k;
   }

   //-----------------------------------------------------------------------------
   static void MurmurHash3_x64_128(const void * key, const int len,
                                   const uint32_t seed, uint64_t out[2] )
   {
      // "key" is input to be hashed.
      // "len" is the number of bytes to hash starting at "key".
      // "seed" is a hash seed, "out" is a buffer (128 bytes) that will receive
      // the results.
      const uint8_t * data = (const uint8_t*)key;
      const int nblocks = len / 16;

      uint64_t h1 = seed;
      uint64_t h2 = seed;

      uint64_t c1 = BIG_CONSTANT(0x87c37b91114253d5);
      uint64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f);

      //----------
      // body

      const uint64_t * blocks = (const uint64_t *)(data);

      for(int i = 0; i < nblocks; i++)
         {
            uint64_t k1 = getblock(blocks,i*2+0);
            uint64_t k2 = getblock(blocks,i*2+1);

            k1 *= c1; k1  = ROTL64(k1,31); k1 *= c2; h1 ^= k1;

            h1 = ROTL64(h1,27); h1 += h2; h1 = h1*5+0x52dce729;

            k2 *= c2; k2  = ROTL64(k2,33); k2 *= c1; h2 ^= k2;

            h2 = ROTL64(h2,31); h2 += h1; h2 = h2*5+0x38495ab5;
         }

      //----------
      // tail

      const uint8_t * tail = (const uint8_t*)(data + nblocks*16);

      uint64_t k1 = 0;
      uint64_t k2 = 0;

      switch(len & 15) {
      case 15: k2 ^= uint64_t(tail[14]) << 48;    // fall through
         case 14: k2 ^= uint64_t(tail[13]) << 40; // fall through
         case 13: k2 ^= uint64_t(tail[12]) << 32; // fall through
         case 12: k2 ^= uint64_t(tail[11]) << 24; // fall through
         case 11: k2 ^= uint64_t(tail[10]) << 16; // fall through
         case 10: k2 ^= uint64_t(tail[ 9]) << 8;  // fall through
         case  9: k2 ^= uint64_t(tail[ 8]) << 0;
            k2 *= c2; k2  = ROTL64(k2,33); k2 *= c1; h2 ^= k2;
                                                  // fall through
         case  8: k1 ^= uint64_t(tail[ 7]) << 56; // fall through
         case  7: k1 ^= uint64_t(tail[ 6]) << 48; // fall through
         case  6: k1 ^= uint64_t(tail[ 5]) << 40; // fall through
         case  5: k1 ^= uint64_t(tail[ 4]) << 32; // fall through
         case  4: k1 ^= uint64_t(tail[ 3]) << 24; // fall through
         case  3: k1 ^= uint64_t(tail[ 2]) << 16; // fall through
         case  2: k1 ^= uint64_t(tail[ 1]) << 8;  // fall through
         case  1: k1 ^= uint64_t(tail[ 0]) << 0;
            k1 *= c1; k1  = ROTL64(k1,31); k1 *= c2; h1 ^= k1;
      };

      //----------
      // finalization

      h1 ^= len; h2 ^= len;

      h1 += h2;
      h2 += h1;

      h1 = fmix(h1);
      h2 = fmix(h2);

      h1 += h2;
      h2 += h1;

      ((uint64_t*)out)[0] = h1;
      ((uint64_t*)out)[1] = h2;
   }

   //-----------------------------------------------------------------------------
}

//______________________________________________________________________________
UInt_t TString::Hash(const void *txt, Int_t ntxt)
{
   // Calculates hash index from any char string. (static function)
   // For string:  i = TString::Hash(string,nstring);
   // For int:     i = TString::Hash(&intword,sizeof(int));
   // For pointer: i = TString::Hash(&pointer,sizeof(void*));
   //
   // This employs two different hash functions, depending on ntxt:
   //   ntxt == sizeof(void*): a simple bitwise xor to get fast pointer hashes
   //   else: MurmurHash3_x64_128 http://code.google.com/p/smhasher/
   if (ntxt != sizeof(void*)) {
      uint64_t buf[2] = {0};
      MurmurHash3_x64_128(txt, ntxt, 0x6384BA69, buf);
      return (UInt_t) buf[0];
   } else {
      // simple, superfast hash for pointers and alike
      UInt_t ret = (UInt_t)0x6384BA69;
      // aligned?
      if (((size_t)txt) % sizeof(void*)) {
         UInt_t* itxt = (UInt_t*)txt;
         ret ^= itxt[0];
         if (sizeof(void*) > sizeof(UInt_t)) {
            ret ^= itxt[1];
         }
      } else {
         const unsigned char* ctxt = (const unsigned char*) txt;
         for (unsigned int i = 0; i < 4; ++i) {
            ret ^= ctxt[i] << (i * 8);
         }
         if (sizeof(void*) > sizeof(UInt_t)) {
            ctxt += 4;
            for (unsigned int i = 0; i < 4; ++i) {
               ret ^= ctxt[i] << (i * 8);
            }
         }
      }
      return ret;
   }
}

//______________________________________________________________________________
static int MemIsEqual(const char *p, const char *q, Ssiz_t n)
{
   // Returns false if strings are not equal.

   while (n--)
   {
      if (tolower((unsigned char)*p) != tolower((unsigned char)*q))
         return kFALSE;
      p++; q++;
   }
   return kTRUE;
}

//______________________________________________________________________________
Ssiz_t TString::Index(const char *pattern, Ssiz_t plen, Ssiz_t startIndex,
                      ECaseCompare cmp) const
{
   // Search for a string in the TString. Plen is the length of pattern,
   // startIndex is the index from which to start and cmp selects the type
   // of case-comparison.

   Ssiz_t slen = Length();
   if (slen < startIndex + plen) return kNPOS;
   if (plen == 0) return startIndex;
   slen -= startIndex + plen;
   const char *sp = Data() + startIndex;
   if (cmp == kExact) {
      char first = *pattern;
      for (Ssiz_t i = 0; i <= slen; ++i)
         if (sp[i] == first && memcmp(sp+i+1, pattern+1, plen-1) == 0)
            return i + startIndex;
   } else {
      int first = tolower((unsigned char) *pattern);
      for (Ssiz_t i = 0; i <= slen; ++i)
         if (tolower((unsigned char) sp[i]) == first &&
             MemIsEqual(sp+i+1, pattern+1, plen-1))
            return i + startIndex;
   }
   return kNPOS;
}

//______________________________________________________________________________
Ssiz_t TString::Last(char c) const
{
   // Find last occurrence of a character c.

   const char *f = strrchr(Data(), (unsigned char) c);
   return f ? f - Data() : kNPOS;
}

//______________________________________________________________________________
TString TString::MD5() const
{
   // Return the MD5 digest for this string, in a string representation.
   TMD5 md5;
   md5.Update((const UChar_t*)Data(), Length());
   UChar_t digest[16];
   md5.Final(digest);
   return md5.AsString();
}

//______________________________________________________________________________
Bool_t TString::MaybeRegexp() const
{
   // Returns true if string contains one of the regexp characters "^$.[]*+?".

   const char *specials = "^$.[]*+?";

   if (First(specials) == kNPOS)
      return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TString::MaybeWildcard() const
{
   // Returns true if string contains one of the wildcard characters "[]*?".

   const char *specials = "[]*?";

   if (First(specials) == kNPOS)
      return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
TString& TString::Prepend(char c, Ssiz_t rep)
{
   // Prepend character c rep times to string.

   if (!rep) return *this;

   Ssiz_t len = Length();
   Ssiz_t tot = len + rep;  // Final string length

   if (tot > MaxSize()) {
      Error("TString::Prepend", "rep too large (%d, max = %d)", rep, MaxSize()-len);
      tot = MaxSize();
      rep = tot - len;
   }

   Ssiz_t capac = Capacity();
   char *data, *p = GetPointer();

   if (capac - tot >= 0) {
      memmove(p + rep, p, len);
      SetSize(tot);
      data = p;
   } else {
      Ssiz_t cap = AdjustCapacity(capac, tot);
      data = new char[cap+1];
      memcpy(data+rep, p, len);
      UnLink();
      SetLongCap(cap+1);
      SetLongSize(tot);
      SetLongPointer(data);
   }
   data[tot] = 0;

   while (rep--)
      *data++ = c;

   return *this;
}

//______________________________________________________________________________
TString &TString::Replace(Ssiz_t pos, Ssiz_t n1, const char *cs, Ssiz_t n2)
{
   // Remove at most n1 characters from self beginning at pos,
   // and replace them with the first n2 characters of cs.

   Ssiz_t len = Length();
   if (pos <= kNPOS || pos > len) {
      Error("TString::Replace",
            "first argument out of bounds: pos = %d, Length = %d", pos, len);
      return *this;
   }

   n1 = TMath::Min(n1, len - pos);
   if (!cs) n2 = 0;

   Ssiz_t tot = len - n1 + n2;  // Final string length
   Ssiz_t rem = len - n1 - pos; // Length of remnant at end of string

   Ssiz_t capac = Capacity();
   char *p = GetPointer();

   if (capac - len + n1 >= n2) {
      if (n1 != n2) {
         if (rem) {
            if (n1 > n2) {
               if (n2) memmove(p + pos, cs, n2);
               memmove(p + pos + n2, p + pos + n1, rem);
               goto finish;
            }
            if (p + pos < cs && cs < p + len) {
               if (p + pos + n1 <= cs)
                  cs += n2 - n1;
               else {    // p + pos < cs < p + pos + n1
                  memmove(p + pos, cs, n1);
                  pos += n1;
                  cs += n2;
                  n2 -= n1;
                  n1 = 0;
               }
            }
            memmove(p + pos + n2, p + pos + n1, rem);
         }
      }
      if (n2) memmove(p + pos, cs, n2);
finish:
      SetSize(tot);
      p[tot] = 0;
   } else {
      Ssiz_t cap = AdjustCapacity(capac, tot);
      char *data = new char[cap+1];
      if (pos) memcpy(data, p, pos);
      if (n2 ) memcpy(data + pos, cs, n2);
      if (rem) memcpy(data + pos + n2, p + pos + n1, rem);
      UnLink();
      SetLongCap(cap+1);
      SetLongSize(tot);
      SetLongPointer(data);
      data[tot] = 0;
   }

   return *this;
}

//______________________________________________________________________________
TString& TString::ReplaceAll(const char *s1, Ssiz_t ls1, const char *s2,
                             Ssiz_t ls2)
{
   // Find & Replace ls1 symbols of s1 with ls2 symbols of s2 if any.

   if (s1 && ls1 > 0) {
      Ssiz_t index = 0;
      while ((index = Index(s1, ls1, index, kExact)) != kNPOS) {
         Replace(index, ls1, s2, ls2);
         index += ls2;
      }
   }
   return *this;
}

//______________________________________________________________________________
TString &TString::Remove(EStripType st, char c)
{
   // Remove char c at begin and/or end of string (like Strip()) but
   // modifies directly the string.

   Ssiz_t start = 0;             // Index of first character
   Ssiz_t end = Length();        // One beyond last character
   const char *direct = Data();  // Avoid a dereference w dumb compiler
   Ssiz_t send = end;

   if (st & kLeading)
      while (start < end && direct[start] == c)
         ++start;
   if (st & kTrailing)
      while (start < end && direct[end-1] == c)
         --end;
   if (end == start) {
      UnLink();
      Zero();
      return *this;
   }
   if (start)
      Remove(0, start);
   if (send != end)
      Remove(send - start - (send - end), send - end);
   return *this;
}

//______________________________________________________________________________
void TString::Resize(Ssiz_t n)
{
   // Resize the string. Truncate or add blanks as necessary.

   if (n < Length())
      Remove(n);                  // Shrank; truncate the string
   else
      Append(' ', n-Length());    // Grew or staid the same
}

//______________________________________________________________________________
TSubString TString::Strip(EStripType st, char c) const
{
   // Return a substring of self stripped at beginning and/or end.

   Ssiz_t start = 0;             // Index of first character
   Ssiz_t end = Length();        // One beyond last character
   const char *direct = Data();  // Avoid a dereference w dumb compiler

   if (st & kLeading)
      while (start < end && direct[start] == c)
         ++start;
   if (st & kTrailing)
      while (start < end && direct[end-1] == c)
         --end;
   if (end == start) start = end = kNPOS;  // make the null substring
   return TSubString(*this, start, end-start);
}

//______________________________________________________________________________
void TString::ToLower()
{
   // Change string to lower-case.

   Ssiz_t n = Length();
   char *p = GetPointer();
   while (n--) {
      *p = tolower((unsigned char)*p);
      p++;
   }
}

//______________________________________________________________________________
void TString::ToUpper()
{
   // Change string to upper case.

   Ssiz_t n = Length();
   char *p = GetPointer();
   while (n--) {
      *p = toupper((unsigned char)*p);
      p++;
   }
}

//______________________________________________________________________________
void TString::AssertElement(Ssiz_t i) const
{
   // Check to make sure a string index is in range.

   if (i == kNPOS || i > Length())
      Error("TString::AssertElement",
            "out of bounds: i = %d, Length = %d", i, Length());
}

//______________________________________________________________________________
Ssiz_t TString::AdjustCapacity(Ssiz_t oldCap, Ssiz_t newCap)
{
   // Calculate a nice capacity greater than or equal to newCap.

   Ssiz_t ms = MaxSize();
   if (newCap > ms - 1) {
      Error("TString::AdjustCapacity", "capacity too large (%d, max = %d)",
            newCap, ms);
   }
   Ssiz_t cap = oldCap < ms / 2 - kAlignment ?
                Recommend(TMath::Max(newCap, 2 * oldCap)) : ms - 1;
   return cap;
}

//______________________________________________________________________________
void TString::Clear()
{
   // Clear string without changing its capacity.

   Clobber(Capacity());
}

//______________________________________________________________________________
void TString::Clobber(Ssiz_t nc)
{
   // Clear string and make sure it has a capacity of nc.

   if (nc > MaxSize()) {
      Error("TString::Clobber", "capacity too large (%d, max = %d)", nc, MaxSize());
      nc = MaxSize();
   }

   if (nc < kMinCap) {
      UnLink();
      Zero();
   } else {
      char *data = GetLongPointer();
      Ssiz_t cap = Recommend(nc);
      if (cap != Capacity()) {
         data = new char[cap+1];
         UnLink();
         SetLongCap(cap+1);
         SetLongPointer(data);
      }
      SetLongSize(0);
      data[0] = 0;
   }
}

//______________________________________________________________________________
void TString::Clone(Ssiz_t tot)
{
   // Make self a distinct copy with capacity of at least tot, where tot cannot
   // be smaller than the current length. Preserve previous contents.

   Ssiz_t len = Length();
   if (len >= tot) return;

   if (tot > MaxSize()) {
      Error("TString::Clone", "tot too large (%d, max = %d)", tot, MaxSize());
      tot = MaxSize();
   }

   Ssiz_t capac = Capacity();
   char *data, *p = GetPointer();

   if (capac - tot < 0) {
      Ssiz_t cap = Recommend(tot);
      data = new char[cap+1];
      memcpy(data, p, len);
      UnLink();
      SetLongCap(cap+1);
      SetLongSize(len);
      SetLongPointer(data);
      data[len] = 0;
   }
}

// ------------------- ROOT I/O ------------------------------------

//______________________________________________________________________________
void TString::FillBuffer(char *&buffer) const
{
   // Copy string into I/O buffer.

   UChar_t nwh;
   Int_t   nchars = Length();

   if (nchars > 254) {
      nwh = 255;
      tobuf(buffer, nwh);
      tobuf(buffer, nchars);
   } else {
      nwh = UChar_t(nchars);
      tobuf(buffer, nwh);
   }
   const char *data = GetPointer();
   for (int i = 0; i < nchars; i++) buffer[i] = data[i];
   buffer += nchars;
}

//______________________________________________________________________________
void TString::ReadBuffer(char *&buffer)
{
   // Read string from I/O buffer.

   UnLink();
   Zero();

   UChar_t nwh;
   Int_t   nchars;

   frombuf(buffer, &nwh);
   if (nwh == 255)
      frombuf(buffer, &nchars);
   else
      nchars = nwh;

   if (nchars < 0) {
      Error("TString::ReadBuffer", "found case with nwh=%d and nchars=%d", nwh, nchars);
      return;
   }

   char *data = Init(nchars, nchars);

   for (int i = 0; i < nchars; i++) frombuf(buffer, &data[i]);
}

//______________________________________________________________________________
TString *TString::ReadString(TBuffer &b, const TClass *clReq)
{
   // Read TString object from buffer. Simplified version of
   // TBuffer::ReadObject (does not keep track of multiple
   // references to same string).  We need to have it here
   // because TBuffer::ReadObject can only handle descendant
   // of TObject.

   R__ASSERT(b.IsReading());

   // Make sure ReadArray is initialized
   b.InitMap();

   // Before reading object save start position
   UInt_t startpos = UInt_t(b.Length());

   UInt_t tag;
   TClass *clRef = b.ReadClass(clReq, &tag);

   TString *a;
   if (!clRef) {

      a = 0;

   } else {

      a = (TString *) clRef->New();
      if (!a) {
         ::Error("TString::ReadObject", "could not create object of class %s",
                 clRef->GetName());
         // Exception
         return a;
      }

      a->Streamer(b);

      b.CheckByteCount(startpos, tag, clRef);
   }

   return a;
}

//______________________________________________________________________________
Int_t TString::Sizeof() const
{
   // Returns size string will occupy on I/O buffer.

   if (Length() > 254)
      return Length()+sizeof(UChar_t)+sizeof(Int_t);
   else
      return Length()+sizeof(UChar_t);
}

//_______________________________________________________________________
void TString::Streamer(TBuffer &b)
{
   // Stream a string object.

   Int_t   nbig;
   UChar_t nwh;
   if (b.IsReading()) {
      b >> nwh;
      if (nwh == 0) {
         UnLink();
         Zero();
      } else {
         if (nwh == 255)
            b >> nbig;
         else
            nbig = nwh;

         Clobber(nbig);
         char *data = GetPointer();
         data[nbig] = 0;
         SetSize(nbig);
         b.ReadFastArray(data, nbig);
      }
   } else {
      nbig = Length();
      if (nbig > 254) {
         nwh = 255;
         b << nwh;
         b << nbig;
      } else {
         nwh = UChar_t(nbig);
         b << nwh;
      }
      const char *data = GetPointer();
      b.WriteFastArray(data, nbig);
   }
}

//______________________________________________________________________________
void TString::WriteString(TBuffer &b, const TString *a)
{
   // Write TString object to buffer. Simplified version of
   // TBuffer::WriteObject (does not keep track of multiple
   // references to the same string).  We need to have it here
   // because TBuffer::ReadObject can only handle descendant
   // of TObject

   R__ASSERT(b.IsWriting());

   // Make sure WriteMap is initialized
   b.InitMap();

   if (!a) {

      b << (UInt_t) 0;

   } else {

      // Reserve space for leading byte count
      UInt_t cntpos = UInt_t(b.Length());
      b.SetBufferOffset(Int_t(cntpos+sizeof(UInt_t)));

      TClass *cl = a->IsA();
      b.WriteClass(cl);

      ((TString *)a)->Streamer(b);

      // Write byte count
      b.SetByteCount(cntpos);
   }
}

//_______________________________________________________________________
#if defined(R__TEMPLATE_OVERLOAD_BUG)
template <>
#endif
TBuffer &operator>>(TBuffer &buf, TString *&s)
{
   // Read string from TBuffer. Function declared in ClassDef.

   s = (TString *) TString::ReadString(buf, TString::Class());
   return buf;
}

//_______________________________________________________________________
TBuffer &operator<<(TBuffer &buf, const TString *s)
{
   // Write TString or derived to TBuffer.

   TString::WriteString(buf, s);
   return buf;
}

// ------------------- Related global functions --------------------

//______________________________________________________________________________
Bool_t operator==(const TString& s1, const char *s2)
{
   // Compare TString with a char *.

   if (!s2) return kFALSE;

   const char *data = s1.Data();
   Ssiz_t len = s1.Length();
   Ssiz_t i;
   for (i = 0; s2[i]; ++i)
      if (data[i] != s2[i] || i == len) return kFALSE;
   return (i == len);
}

//______________________________________________________________________________
TString ToLower(const TString &str)
{
   // Return a lower-case version of str.

   Ssiz_t n = str.Length();
   TString temp((char)0, n);
   const char *uc = str.Data();
         char *lc = (char*)temp.Data();
   // Guard against tolower() being a macro
   while (n--) { *lc++ = tolower((unsigned char)*uc); uc++; }
   return temp;
}

//______________________________________________________________________________
TString ToUpper(const TString &str)
{
   // Return an upper-case version of str.

   Ssiz_t n = str.Length();
   TString temp((char)0, n);
   const char* uc = str.Data();
         char* lc = (char*)temp.Data();
   // Guard against toupper() being a macro
   while (n--) { *lc++ = toupper((unsigned char)*uc); uc++; }
   return temp;
}

//______________________________________________________________________________
TString operator+(const TString &s, const char *cs)
{
   // Use the special concatenation constructor.

   return TString(s.Data(), s.Length(), cs, cs ? strlen(cs) : 0);
}

//______________________________________________________________________________
TString operator+(const char *cs, const TString &s)
{
   // Use the special concatenation constructor.

   return TString(cs, cs ? strlen(cs) : 0, s.Data(), s.Length());
}

//______________________________________________________________________________
TString operator+(const TString &s1, const TString &s2)
{
   // Use the special concatenation constructor.

   return TString(s1.Data(), s1.Length(), s2.Data(), s2.Length());
}

//______________________________________________________________________________
TString operator+(const TString &s, char c)
{
   // Add char to string.

   return TString(s.Data(), s.Length(), &c, 1);
}

//______________________________________________________________________________
TString operator+(const TString &s, Long_t i)
{
   // Add integer to string.

   char si[32];
   snprintf(si, sizeof(si), "%ld", i);
   return TString(s.Data(), s.Length(), si, strlen(si));
}

//______________________________________________________________________________
TString operator+(const TString &s, ULong_t i)
{
   // Add integer to string.

   char si[32];
   snprintf(si, sizeof(si), "%lu", i);
   return TString(s.Data(), s.Length(), si, strlen(si));
}

//______________________________________________________________________________
TString operator+(const TString &s, Long64_t i)
{
   // Add integer to string.

   char si[32];
   snprintf(si, sizeof(si), "%lld", i);
   return TString(s.Data(), s.Length(), si, strlen(si));
}

//______________________________________________________________________________
TString operator+(const TString &s, ULong64_t i)
{
   // Add integer to string.

   char si[32];
   snprintf(si, sizeof(si), "%llu", i);
   return TString(s.Data(), s.Length(), si, strlen(si));
}

//______________________________________________________________________________
TString operator+(char c, const TString &s)
{
   // Add string to integer.

   return TString(&c, 1, s.Data(), s.Length());
}

//______________________________________________________________________________
TString operator+(Long_t i, const TString &s)
{
   // Add string to integer.

   char si[32];
   snprintf(si, sizeof(si), "%ld", i);
   return TString(si, strlen(si), s.Data(), s.Length());
}

//______________________________________________________________________________
TString operator+(ULong_t i, const TString &s)
{
   // Add string to integer.

   char si[32];
   snprintf(si, sizeof(si), "%lu", i);
   return TString(si, strlen(si), s.Data(), s.Length());
}

//______________________________________________________________________________
TString operator+(Long64_t i, const TString &s)
{
   // Add string to integer.

   char si[32];
   snprintf(si, sizeof(si), "%lld", i);
   return TString(si, strlen(si), s.Data(), s.Length());
}

//______________________________________________________________________________
TString operator+(ULong64_t i, const TString &s)
{
   // Add string to integer.

   char si[32];
   snprintf(si, sizeof(si), "%llu", i);
   return TString(si, strlen(si), s.Data(), s.Length());
}

// -------------------- Static Member Functions ----------------------

// ------------------- The static data members access --------------------------

//______________________________________________________________________________
Ssiz_t  TString::GetInitialCapacity()
{
   ::Obsolete("TString::GetInitialCapacity", "v5-30-00", "v5-32-00");
   return 15;
}

//______________________________________________________________________________
Ssiz_t  TString::GetResizeIncrement()
{
   ::Obsolete("TString::GetResizeIncrement", "v5-30-00", "v5-32-00");
   return 16;
}

//______________________________________________________________________________
Ssiz_t  TString::GetMaxWaste()
{
   ::Obsolete("TString::GetMaxWaste", "v5-30-00", "v5-32-00");
   return 15;
}

//______________________________________________________________________________
Ssiz_t TString::InitialCapacity(Ssiz_t)
{
   // Set default initial capacity for all TStrings. Default is 15.

   ::Obsolete("TString::InitialCapacity", "v5-30-00", "v5-32-00");
   return 15;
}

//______________________________________________________________________________
Ssiz_t TString::ResizeIncrement(Ssiz_t)
{
   // Set default resize increment for all TStrings. Default is 16.

   ::Obsolete("TString::ResizeIncrement", "v5-30-00", "v5-32-00");
   return 16;
}

//______________________________________________________________________________
Ssiz_t TString::MaxWaste(Ssiz_t)
{
   // Set maximum space that may be wasted in a string before doing a resize.
   // Default is 15.

   ::Obsolete("TString::MaxWaste", "v5-30-00", "v5-32-00");
   return 15;
}


//////////////////////////////////////////////////////////////////////////
//                                                                      //
//  TSubString                                                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

//
// A zero lengthed substring is legal. It can start
// at any character. It is considered to be "pointing"
// to just before the character.
//
// A "null" substring is a zero lengthed substring that
// starts with the nonsense index kNPOS. It can
// be detected with the member function IsNull().
//

//______________________________________________________________________________
TSubString::TSubString(const TString &str, Ssiz_t start, Ssiz_t nextent)
   : fStr((TString&)str), fBegin(start), fExtent(nextent)
{
   // Private constructor.
}

//______________________________________________________________________________
TSubString TString::operator()(Ssiz_t start, Ssiz_t len) const
{
   // Return sub-string of string starting at start with length len.

   if (start < Length() && len > 0) {
      if (start+len > Length())
         len = Length() - start;
   } else {
      start = kNPOS;
      len   = 0;
   }
   return TSubString(*this, start, len);
}

//______________________________________________________________________________
TSubString TString::SubString(const char *pattern, Ssiz_t startIndex,
                              ECaseCompare cmp) const
{
   // Returns a substring matching "pattern", or the null substring
   // if there is no such match.  It would be nice if this could be yet another
   // overloaded version of operator(), but this would result in a type
   // conversion ambiguity with operator(Ssiz_t, Ssiz_t).

   Ssiz_t len = pattern ? strlen(pattern) : 0;
   Ssiz_t i = Index(pattern, len, startIndex, cmp);
   return TSubString(*this, i, i == kNPOS ? 0 : len);
}

//______________________________________________________________________________
char& TSubString::operator[](Ssiz_t i)
{
   // Return character at pos i from sub-string. Check validity of i.

   AssertElement(i);
   return fStr(fBegin+i);
}

//______________________________________________________________________________
char& TSubString::operator()(Ssiz_t i)
{
   // Return character at pos i from sub-string. No check on i.

   return fStr(fBegin+i);
}

//______________________________________________________________________________
TSubString& TSubString::operator=(const TString &str)
{
   // Assign string to sub-string.

   if (!IsNull())
      fStr.Replace(fBegin, fExtent, str.Data(), str.Length());

   return *this;
}

//______________________________________________________________________________
TSubString& TSubString::operator=(const char *cs)
{
   // Assign char* to sub-string.

   if (!IsNull())
      fStr.Replace(fBegin, fExtent, cs, cs ? strlen(cs) : 0);

   return *this;
}

//______________________________________________________________________________
Bool_t operator==(const TSubString& ss, const char *cs)
{
   // Compare sub-string to char *.

   if (ss.IsNull()) return *cs =='\0'; // Two null strings compare equal

   const char* data = ss.fStr.Data() + ss.fBegin;
   Ssiz_t i;
   for (i = 0; cs[i]; ++i)
      if (cs[i] != data[i] || i == ss.fExtent) return kFALSE;
   return (i == ss.fExtent);
}

//______________________________________________________________________________
Bool_t operator==(const TSubString& ss, const TString &s)
{
   // Compare sub-string to string.

   if (ss.IsNull()) return s.IsNull(); // Two null strings compare equal.
   if (ss.fExtent != s.Length()) return kFALSE;
   return !memcmp(ss.fStr.Data() + ss.fBegin, s.Data(), ss.fExtent);
}

//______________________________________________________________________________
Bool_t operator==(const TSubString &s1, const TSubString &s2)
{
   // Compare two sub-strings.

   if (s1.IsNull()) return s2.IsNull();
   if (s1.fExtent != s2.fExtent) return kFALSE;
   return !memcmp(s1.fStr.Data()+s1.fBegin, s2.fStr.Data()+s2.fBegin,
                  s1.fExtent);
}

//______________________________________________________________________________
void TSubString::ToLower()
{
   // Convert sub-string to lower-case.

   if (!IsNull()) {                             // Ignore null substrings
      char *p = fStr.GetPointer() + fBegin;
      Ssiz_t n = fExtent;
      while (n--) { *p = tolower((unsigned char)*p); p++;}
   }
}

//______________________________________________________________________________
void TSubString::ToUpper()
{
   // Convert sub-string to upper-case.
   if (!IsNull()) {                             // Ignore null substrings
      char *p = fStr.GetPointer() + fBegin;
      Ssiz_t n = fExtent;
      while (n--) { *p = toupper((unsigned char)*p); p++;}
   }
}

//______________________________________________________________________________
void TSubString::SubStringError(Ssiz_t sr, Ssiz_t start, Ssiz_t n) const
{
   // Output error message.

   Error("TSubString::SubStringError",
         "out of bounds: start = %d, n = %d, sr = %d", start, n, sr);
}

//______________________________________________________________________________
void TSubString::AssertElement(Ssiz_t i) const
{
   // Check to make sure a sub-string index is in range.

   if (i == kNPOS || i >= Length())
      Error("TSubString::AssertElement",
            "out of bounds: i = %d, Length = %d", i, Length());
}

//______________________________________________________________________________
Bool_t TString::IsAscii() const
{
   // Returns true if all characters in string are ascii.

   const char *cp = Data();
   for (Ssiz_t i = 0; i < Length(); ++i)
      if (cp[i] & ~0x7F)
         return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TString::IsAlpha() const
{
   // Returns true if all characters in string are alphabetic.
   // Returns false in case string length is 0.

   const char *cp = Data();
   Ssiz_t len = Length();
   if (len == 0) return kFALSE;
   for (Ssiz_t i = 0; i < len; ++i)
      if (!isalpha(cp[i]))
         return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TString::IsAlnum() const
{
   // Returns true if all characters in string are alphanumeric.
   // Returns false in case string length is 0.

   const char *cp = Data();
   Ssiz_t len = Length();
   if (len == 0) return kFALSE;
   for (Ssiz_t i = 0; i < len; ++i)
      if (!isalnum(cp[i]))
         return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TString::IsDigit() const
{
   // Returns true if all characters in string are digits (0-9) or whitespaces,
   // i.e. "123456" and "123 456" are both valid integer strings.
   // Returns false in case string length is 0 or string contains other
   // characters or only whitespace.

   const char *cp = Data();
   Ssiz_t len = Length();
   if (len == 0) return kFALSE;
   Int_t b = 0, d = 0;
   for (Ssiz_t i = 0; i < len; ++i) {
      if (cp[i] != ' ' && !isdigit(cp[i])) return kFALSE;
      if (cp[i] == ' ') b++;
      if (isdigit(cp[i])) d++;
   }
   if (b && !d)
      return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TString::IsFloat() const
{
   // Returns kTRUE if string contains a floating point or integer number.
   // Examples of valid formats are:
   //    64320
   //    64 320
   //    6 4 3 2 0
   //    6.4320     6,4320
   //    6.43e20   6.43E20    6,43e20
   //    6.43e-20  6.43E-20   6,43e-20, -6.43e+20

   //we first check if we have an integer, in this case, IsDigit() will be true straight away
   if (IsDigit()) return kTRUE;

   TString tmp = *this;
   //now we look for occurrences of '.', ',', e', 'E', '+', '-' and replace each
   //with ' ', if it is a floating point, IsDigit() will then return kTRUE

   tmp.ToLower();
   Ssiz_t pos = tmp.First('.');
   if (pos != kNPOS) tmp.Replace(pos, 1, " ", 1);
   pos = tmp.First(',');
   if (pos != kNPOS) tmp.Replace(pos, 1, " ", 1);
   pos = tmp.Index("e-");
   if (pos >= 1) tmp.Replace(pos, 2, " ", 1);
   pos = tmp.Index("e+");
   if (pos >= 1) tmp.Replace(pos, 2, " ", 1);
   pos = tmp.Index("e");
   if (pos >= 1) tmp.Replace(pos, 1, " ", 1);
   pos = tmp.First('-');
   if (pos == 0) tmp.Replace(pos, 1, " ", 1);
   pos = tmp.First('+');
   if (pos == 0) tmp.Replace(pos, 1, " ", 1);

   //test if it is now uniquely composed of numbers
   return tmp.IsDigit();
}

//______________________________________________________________________________
Bool_t TString::IsHex() const
{
   // Returns true if all characters in string are hexidecimal digits
   // (0-9,a-f,A-F). Returns false in case string length is 0 or string
   // contains other characters.

   const char *cp = Data();
   Ssiz_t len = Length();
   if (len == 0) return kFALSE;
   for (Ssiz_t i = 0; i < len; ++i)
      if (!isxdigit(cp[i]))
         return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TString::IsBin() const
{
   // Returns true if all characters in string are binary digits (0,1).
   // Returns false in case string length is 0 or string contains other
   // characters.

   const char *cp = Data();
   Ssiz_t len = Length();
   if (len == 0) return kFALSE;
   for (Ssiz_t i = 0; i < len; ++i)
      if (cp[i] != '0' && cp[i] != '1')
         return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TString::IsOct() const
{
   // Returns true if all characters in string are octal digits (0-7).
   // Returns false in case string length is 0 or string contains other
   // characters.

   const char *cp = Data();
   Ssiz_t len = Length();
   if (len == 0) return kFALSE;
   for (Ssiz_t i = 0; i < len; ++i)
      if (!isdigit(cp[i]) || cp[i]=='8' || cp[i]=='9')
         return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TString::IsDec() const
{
   // Returns true if all characters in string are decimal digits (0-9).
   // Returns false in case string length is 0 or string contains other
   // characters.

   const char *cp = Data();
   Ssiz_t len = Length();
   if (len == 0) return kFALSE;
   for (Ssiz_t i = 0; i < len; ++i)
      if (!isdigit(cp[i]))
         return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TString::IsInBaseN(Int_t base) const
{
   // Returns true if all characters in string are expressed in the base
   // specified (range=2-36), i.e. {0,1} for base 2, {0-9,a-f,A-F} for base 16,
   // {0-9,a-z,A-Z} for base 36. Returns false in case string length is 0 or
   // string contains other characters.

   if (base < 2 || base > 36) {
      Error("TString::IsInBaseN", "base %d is not supported. Supported bases are {2,3,...,36}.", base);
      return kFALSE;
   }
   if (Length() == 0) {
      Error("TString::IsInBaseN", "input string is empty.") ;
      return kFALSE;
   }
   TString str = TString(Data()) ;
   str.ToUpper() ;
   TString str_ref0 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
   TString str_ref = str_ref0 ;
   str_ref.Remove(base) ;
   Bool_t isInBase = kTRUE ;
   for (Int_t k = 0; k < str.Length(); k++) {
      if (! str_ref.Contains(str[k])) {
         isInBase = kFALSE ;
         break ;
      }
   }
   return (isInBase);
}

//______________________________________________________________________________
Int_t TString::Atoi() const
{
   // Return integer value of string.
   // Valid strings include only digits and whitespace (see IsDigit()),
   // i.e. "123456", "123 456" and "1 2 3 4        56" are all valid
   // integer strings whose Atoi() value is 123456.

   //any whitespace ?
   Int_t end = Index(" ");
   //if no whitespaces in string, just use atoi()
   if (end == -1) return atoi(Data());
   //make temporary string, removing whitespace
   Int_t start = 0;
   TString tmp;
   //loop over all whitespace
   while (end > -1) {
      tmp += (*this)(start, end-start);
      start = end+1; end = Index(" ", start);
   }
   //finally add part from last whitespace to end of string
   end = Length();
   tmp += (*this)(start, end-start);
   return atoi(tmp.Data());
}

//______________________________________________________________________________
Long64_t TString::Atoll() const
{
   // Return long long value of string.
   // Valid strings include only digits and whitespace (see IsDigit()),
   // i.e. "123456", "123 456" and "1 2 3 4        56" are all valid
   // integer strings whose Atoll() value is 123456.

   //any whitespace ?
   Int_t end = Index(" ");
   //if no whitespaces in string, just use atoi()
#ifndef R__WIN32
   if (end == -1) return atoll(Data());
#else
   if (end == -1) return _atoi64(Data());
#endif
   //make temporary string, removing whitespace
   Int_t start = 0;
   TString tmp;
   //loop over all whitespace
   while (end > -1) {
      tmp += (*this)(start, end-start);
      start = end+1; end = Index(" ", start);
   }
   //finally add part from last whitespace to end of string
   end = Length();
   tmp += (*this)(start, end-start);
#ifndef R__WIN32
   return atoll(tmp.Data());
#else
   return _atoi64(tmp.Data());
#endif
}

//______________________________________________________________________________
Double_t TString::Atof() const
{
   // Return floating-point value contained in string.
   // Examples of valid strings are:
   //    64320
   //    64 320
   //    6 4 3 2 0
   //    6.4320     6,4320
   //    6.43e20   6.43E20    6,43e20
   //    6.43e-20  6.43E-20   6,43e-20

   //look for a comma and some whitespace
   Int_t comma = Index(",");
   Int_t end = Index(" ");
   //if no commas & no whitespace in string, just use atof()
   if (comma == -1 && end == -1) return atof(Data());
   TString tmp = *this;
   if (comma > -1) {
      //replace comma with decimal point
      tmp.Replace(comma, 1, ".");
   }
   //no whitespace ?
   if (end == -1) return atof(tmp.Data());
   //remove whitespace
   Int_t start = 0;
   TString tmp2;
   while (end > -1) {
      tmp2 += tmp(start, end-start);
      start = end+1; end = tmp.Index(" ", start);
   }
   end = tmp.Length();
   tmp2 += tmp(start, end-start);
   return atof(tmp2.Data());
}

//______________________________________________________________________________
TString TString::Itoa(Int_t value, Int_t base)
{
   // Converts an Int_t to a TString with respect to the base specified (2-36).
   // Thus it is an enhanced version of sprintf (adapted from versions 0.4 of
   // http://www.jb.man.ac.uk/~slowe/cpp/itoa.html).
   // Usage: the following statement produce the same output, namely "1111"
   //   cout << TString::Itoa(15,2) ;
   //   cout << TString::Itoa(0xF,2) ; /// 0x prefix to handle hex
   //   cout << TString::Itoa(017,2) ; /// 0  prefix to handle oct
   // In case of error returns the "!" string.

   std::string buf;
   // check that the base if valid
   if (base < 2 || base > 36) {
      Error("TString::Itoa", "base %d is not supported. Supported bases are {2,3,...,36}.",base) ;
      return (TString("!"));
   }
   buf.reserve(35); // Pre-allocate enough space (35=kMaxDigits)
   Int_t quotient = value;
   // Translating number to string with base:
   do {
      buf += "0123456789abcdefghijklmnopqrstuvwxyz"[ TMath::Abs(quotient % base) ];
      quotient /= base;
   } while (quotient);
   // Append the negative sign
   if (value < 0) buf += '-';
   std::reverse(buf.begin(), buf.end());
   return (TString(buf.data()));
}

//______________________________________________________________________________
TString TString::UItoa(UInt_t value, Int_t base)
{
   // Converts a UInt_t (twice the range of an Int_t) to a TString with respect
   // to the base specified (2-36). Thus it is an enhanced version of sprintf
   // (adapted from versions 0.4 of http://www.jb.man.ac.uk/~slowe/cpp/itoa.html).
   // In case of error returns the "!" string.

   std::string buf;
   // check that the base if valid
   if (base < 2 || base > 36) {
      Error("TString::UItoa", "base %d is not supported. Supported bases are {2,3,...,36}.",base);
      return (TString("!"));
   }
   buf.reserve(35); // Pre-allocate enough space (35=kMaxDigits)
   UInt_t quotient = value;
   // Translating number to string with base:
   do {
      buf += "0123456789abcdefghijklmnopqrstuvwxyz"[ quotient % base ];
      quotient /= base;
   } while (quotient);
   std::reverse(buf.begin(), buf.end());
   return (TString(buf.data()));
}

//______________________________________________________________________________
TString TString::LLtoa(Long64_t value, Int_t base)
{
   // Converts a Long64_t to a TString with respect to the base specified (2-36).
   // Thus it is an enhanced version of sprintf (adapted from versions 0.4 of
   // http://www.jb.man.ac.uk/~slowe/cpp/itoa.html).
   // In case of error returns the "!" string.

   std::string buf;
   // check that the base if valid
   if (base < 2 || base > 36) {
      Error("TString::LLtoa", "base %d is not supported. Supported bases are {2,3,...,36}.",base);
      return (TString("!"));
   }
   buf.reserve(35); // Pre-allocate enough space (35=kMaxDigits)
   Long64_t quotient = value;
   // Translating number to string with base:
   do {
      buf += "0123456789abcdefghijklmnopqrstuvwxyz"[ TMath::Abs(quotient % base) ];
      quotient /= base;
   } while (quotient);
   // Append the negative sign
   if (value < 0) buf += '-';
   std::reverse(buf.begin(), buf.end());
   return (TString(buf.data()));
}

//______________________________________________________________________________
TString TString::ULLtoa(ULong64_t value, Int_t base)
{
   // Converts a ULong64_t (twice the range of an Long64_t) to a TString with
   // respect to the base specified (2-36). Thus it is an enhanced version of
   // sprintf (adapted from versions 0.4 of http://www.jb.man.ac.uk/~slowe/cpp/itoa.html).
   // In case of error returns the "!" string.

   std::string buf;
   // check that the base if valid
   if (base < 2 || base > 36) {
      Error("TString::ULLtoa", "base %d is not supported. Supported bases are {2,3,...,36}.",base);
      return (TString("!"));
   }
   buf.reserve(35); // Pre-allocate enough space (35=kMaxDigits)
   ULong64_t quotient = value;
   // Translating number to string with base:
   do {
      buf += "0123456789abcdefghijklmnopqrstuvwxyz"[ quotient % base ];
      quotient /= base;
   } while (quotient);
   std::reverse(buf.begin(), buf.end());
   return (TString(buf.data()));
}

//______________________________________________________________________________
TString TString::BaseConvert(const TString& s_in, Int_t base_in, Int_t base_out)
{
   // Converts string from base base_in to base base_out. Supported bases
   // are 2-36. At most 64 bit data can be converted.

   TString s_out = "!" ;  // return value in case of issue
   // checking base range
   if (base_in < 2 || base_in > 36 || base_out < 2 || base_out > 36) {
      Error("TString::BaseConvert", "only bases 2-36 are supported (base_in=%d, base_out=%d).", base_in, base_out);
      return (s_out);
   }
   // cleaning s_in
   TString s_in_ = s_in;
   Bool_t isSigned = kFALSE;
   if (s_in_[0] == '-') {
      isSigned = kTRUE;
      s_in_.Remove(0, 1);
   }
   if (!isSigned && s_in_[0] == '+') s_in_.Remove(0, 1);  // !isSigned to avoid strings beginning with "-+"
   if (base_in == 16 && s_in_.BeginsWith("0x")) s_in_.Remove(0, 2);  // removing hex prefix if any
   s_in_ = TString(s_in_.Strip(TString::kLeading, '0'));  // removing leading zeros (necessary for length comparison below)
   if (!s_in_.Length()) s_in_ += '0';
   // checking s_in_ is expressed in the mentioned base
   if (!s_in_.IsInBaseN(base_in)) {
      Error("TString::BaseConvert", "s_in=\"%s\" is not in base %d", s_in.Data(), base_in);
      return (s_out);
   }
   // checking s_in <= 64 bits
   TString s_max = TString::ULLtoa(18446744073709551615ULL, base_in);
   if (s_in_.Length() > s_max.Length()) {
      // string comparison (s_in_>s_max) does not take care of length
      Error("TString::BaseConvert", "s_in=\"%s\" > %s = 2^64-1 in base %d.", s_in.Data(), s_max.Data(), base_in);
      return (s_out);
   } else if (s_in_.Length() == s_max.Length()) {
      // if ( s_in_.Length() < s_max.Length() ) everything's fine
      s_in_.ToLower();  // s_max is lower case
      if (s_in_ > s_max) {
         // string comparison
         Error("TString::BaseConvert", "s_in=\"%s\" > %s = 2^64-1 in base %d.", s_in.Data(), s_max.Data(), base_in);
         return (s_out);
      }
   }

   // computing s_out
   ULong64_t i = ULong64_t(strtoull(s_in.Data(), 0, base_in));
   s_out = TString::ULLtoa(i, base_out);
   if (isSigned) s_out.Prepend("-");
   return (s_out);
}

//______________________________________________________________________________
Bool_t TString::EndsWith(const char *s, ECaseCompare cmp) const
{
   // Return true if string ends with the specified string.

   if (!s) return kTRUE;

   Ssiz_t l = strlen(s);
   if (l > Length()) return kFALSE;
   const char *s2 = Data() + Length() - l;

   if (cmp == kExact)
      return strcmp(s, s2) == 0;
   return strcasecmp(s, s2) == 0;
}

//__________________________________________________________________________________
TObjArray *TString::Tokenize(const TString &delim) const
{
   // This function is used to isolate sequential tokens in a TString.
   // These tokens are separated in the string by at least one of the
   // characters in delim. The returned array contains the tokens
   // as TObjString's. The returned array is the owner of the objects,
   // and must be deleted by the user.

   std::list<Int_t> splitIndex;

   Int_t i, start, nrDiff = 0;
   for (i = 0; i < delim.Length(); i++) {
      start = 0;
      while (start < Length()) {
         Int_t pos = Index(delim(i), start);
         if (pos == kNPOS) break;
         splitIndex.push_back(pos);
         start = pos + 1;
      }
      if (start > 0) nrDiff++;
   }
   splitIndex.push_back(Length());

   if (nrDiff > 1)
      splitIndex.sort();

   TObjArray *arr = new TObjArray();
   arr->SetOwner();

   start = -1;
   std::list<Int_t>::const_iterator it;
#ifndef R__HPUX
   for (it = splitIndex.begin(); it != splitIndex.end(); it++) {
#else
   for (it = splitIndex.begin(); it != (std::list<Int_t>::const_iterator) splitIndex.end(); it++) {
#endif
      Int_t stop = *it;
      if (stop - 1 >= start + 1) {
         TString tok = (*this)(start+1, stop-start-1);
         TObjString *objstr = new TObjString(tok);
         arr->Add(objstr);
      }
      start = stop;
   }

   return arr;
}

//______________________________________________________________________________
void TString::FormImp(const char *fmt, va_list ap)
{
   // Formats a string using a printf style format descriptor.
   // Existing string contents will be overwritten.

   Ssiz_t buflen = 20 + 20 * strlen(fmt);    // pick a number, any strictly positive number
   Clobber(buflen);

   va_list sap;
   R__VA_COPY(sap, ap);

   int n, vc = 0;
again:
   n = vsnprintf(GetPointer(), buflen, fmt, ap);
   // old vsnprintf's return -1 if string is truncated new ones return
   // total number of characters that would have been written
   if (n == -1 || n >= buflen) {
      if (n == -1)
         buflen *= 2;
      else
         buflen = n+1;
      Clobber(buflen);
      va_end(ap);
      R__VA_COPY(ap, sap);
      vc = 1;
      goto again;
   }
   va_end(sap);
   if (vc)
      va_end(ap);

   SetSize(strlen(Data()));
}

//______________________________________________________________________________
void TString::Form(const char *va_(fmt), ...)
{
   // Formats a string using a printf style format descriptor.
   // Existing string contents will be overwritten.

   va_list ap;
   va_start(ap, va_(fmt));
   FormImp(va_(fmt), ap);
   va_end(ap);
}

//______________________________________________________________________________
TString TString::Format(const char *va_(fmt), ...)
{
   // Static method which formats a string using a printf style format
   // descriptor and return a TString. Same as TString::Form() but it is
   // not needed to first create a TString.

   va_list ap;
   va_start(ap, va_(fmt));
   TString str;
   str.FormImp(va_(fmt), ap);
   va_end(ap);
   return str;
}

//---- Global String Handling Functions ----------------------------------------

//______________________________________________________________________________
static char *SlowFormat(const char *format, va_list ap, int hint)
{
   // Format a string in a formatting buffer (using a printf style
   // format descriptor).

   static const int fld_size = 2048;
   TTHREAD_TLS(char*) slowBuffer(0);
   TTHREAD_TLS(int) slowBufferSize(0);

   if (hint == -1) hint = fld_size;
   if (hint > slowBufferSize) {
      delete [] slowBuffer;
      slowBufferSize = 2 * hint;
      if (hint < 0 || slowBufferSize < 0) {
         slowBufferSize = 0;
         slowBuffer = 0;
         return 0;
      }
      slowBuffer = new char[slowBufferSize];
   }

   va_list sap;
   R__VA_COPY(sap, ap);

   int n = vsnprintf(slowBuffer, slowBufferSize, format, ap);
   // old vsnprintf's return -1 if string is truncated new ones return
   // total number of characters that would have been written
   if (n == -1 || n >= slowBufferSize) {
      if (n == -1) n = 2 * slowBufferSize;
      if (n == slowBufferSize) n++;
      if (n <= 0) {
         va_end(sap);
         return 0; // int overflow!
      }
      va_end(ap);
      R__VA_COPY(ap, sap);
      char *buf = SlowFormat(format, ap, n);
      va_end(sap);
      va_end(ap);
      return buf;
   }

   va_end(sap);

   return slowBuffer;
}

//______________________________________________________________________________
static char *Format(const char *format, va_list ap)
{
   // Format a string in a circular formatting buffer (using a printf style
   // format descriptor).

   static const int cb_size  = 4096;
   static const int fld_size = 2048;

   // a circular formating buffer
   TTHREAD_TLS_ARRAY(char,cb_size,gFormbuf); // gFormbuf[cb_size]; // some slob for form overflow
   TTHREAD_TLS(char*) gBfree(0);
   TTHREAD_TLS(char*) gEndbuf(0);

   if (gBfree == 0) {
      gBfree = gFormbuf;
      gEndbuf = &gFormbuf[cb_size-1];
   }
   char *buf = gBfree;

   if (buf+fld_size > gEndbuf)
      buf = gFormbuf;

   va_list sap;
   R__VA_COPY(sap, ap);

   int n = vsnprintf(buf, fld_size, format, ap);
   // old vsnprintf's return -1 if string is truncated new ones return
   // total number of characters that would have been written
   if (n == -1 || n >= fld_size) {
      va_end(ap);
      R__VA_COPY(ap, sap);
      buf = SlowFormat(format, ap, n);
      va_end(sap);
      va_end(ap);
      return buf;
   }

   va_end(sap);

   gBfree = buf+n+1;
   return buf;
}

//______________________________________________________________________________
char *Form(const char *va_(fmt), ...)
{
   // Formats a string in a circular formatting buffer. Removes the need to
   // create and delete short lived strings. Don't pass Form() pointers
   // from user code down to ROOT functions as the circular buffer may
   // be overwritten downstream. Use Form() results immediately or use
   // TString::Format() instead.

   va_list ap;
   va_start(ap,va_(fmt));
   char *b = Format(va_(fmt), ap);
   va_end(ap);
   return b;
}

//______________________________________________________________________________
void Printf(const char *va_(fmt), ...)
{
   // Formats a string in a circular formatting buffer and prints the string.
   // Appends a newline. If gPrintViaErrorHandler is true it will print via the
   // currently active ROOT error handler.

   va_list ap;
   va_start(ap,va_(fmt));
   if (gPrintViaErrorHandler)
      ErrorHandler(kPrint, 0, va_(fmt), ap);
   else {
      char *b = Format(va_(fmt), ap);
      printf("%s\n", b);
      fflush(stdout);
   }
   va_end(ap);
}

//______________________________________________________________________________
char *Strip(const char *s, char c)
{
   // Strip leading and trailing c (blanks by default) from a string.
   // The returned string has to be deleted by the user.

   if (!s) return 0;

   int l = strlen(s);
   char *buf = new char[l+1];

   if (l == 0) {
      *buf = '\0';
      return buf;
   }

   // get rid of leading c's
   const char *t1 = s;
   while (*t1 == c)
      t1++;

   // get rid of trailing c's
   const char *t2 = s + l - 1;
   while (*t2 == c && t2 > s)
      t2--;

   if (t1 > t2) {
      *buf = '\0';
      return buf;
   }
   strncpy(buf, t1, (Ssiz_t) (t2-t1+1));
   *(buf+(t2-t1+1)) = '\0';

   return buf;
}

//______________________________________________________________________________
char *StrDup(const char *str)
{
   // Duplicate the string str. The returned string has to be deleted by
   // the user.

   if (!str) return 0;

   char *s = new char[strlen(str)+1];
   if (s) strcpy(s, str);

   return s;
}

//______________________________________________________________________________
char *Compress(const char *str)
{
   // Remove all blanks from the string str. The returned string has to be
   // deleted by the user.

   if (!str) return 0;

   const char *p = str;
   char *s, *s1 = new char[strlen(str)+1];
   s = s1;

   while (*p) {
      if (*p != ' ')
         *s++ = *p;
      p++;
   }
   *s = '\0';

   return s1;
}

//______________________________________________________________________________
int EscChar(const char *src, char *dst, int dstlen, char *specchars,
            char escchar)
{
   // Escape specchars in src with escchar and copy to dst.

   const char *p;
   char *q, *end = dst+dstlen-1;

   for (p = src, q = dst; *p && q < end; ) {
      if (strchr(specchars, *p)) {
         *q++ = escchar;
         if (q < end)
            *q++ = *p++;
      } else
         *q++ = *p++;
   }
   *q = '\0';

   if (*p != 0)
      return -1;
   return q-dst;
}

//______________________________________________________________________________
int UnEscChar(const char *src, char *dst, int dstlen, char *specchars, char)
{
   // Un-escape specchars in src from escchar and copy to dst.

   const char *p;
   char *q, *end = dst+dstlen-1;

   for (p = src, q = dst; *p && q < end; ) {
      if (strchr(specchars, *p))
         p++;
      else
         *q++ = *p++;
   }
   *q = '\0';

   if (*p != 0)
      return -1;
   return q-dst;
}

#ifdef NEED_STRCASECMP
//______________________________________________________________________________
int strcasecmp(const char *str1, const char *str2)
{
   // Case insensitive string compare.

   return strncasecmp(str1, str2, str2 ? strlen(str2)+1 : 0);
}

//______________________________________________________________________________
int strncasecmp(const char *str1, const char *str2, Ssiz_t n)
{
   // Case insensitive string compare of n characters.

   while (n > 0) {
      int c1 = *str1;
      int c2 = *str2;

      if (isupper(c1))
         c1 = tolower(c1);

      if (isupper(c2))
         c2 = tolower(c2);

      if (c1 != c2)
         return c1 - c2;

      str1++;
      str2++;
      n--;
   }
   return 0;
}
#endif
 TString.cxx:1
 TString.cxx:2
 TString.cxx:3
 TString.cxx:4
 TString.cxx:5
 TString.cxx:6
 TString.cxx:7
 TString.cxx:8
 TString.cxx:9
 TString.cxx:10
 TString.cxx:11
 TString.cxx:12
 TString.cxx:13
 TString.cxx:14
 TString.cxx:15
 TString.cxx:16
 TString.cxx:17
 TString.cxx:18
 TString.cxx:19
 TString.cxx:20
 TString.cxx:21
 TString.cxx:22
 TString.cxx:23
 TString.cxx:24
 TString.cxx:25
 TString.cxx:26
 TString.cxx:27
 TString.cxx:28
 TString.cxx:29
 TString.cxx:30
 TString.cxx:31
 TString.cxx:32
 TString.cxx:33
 TString.cxx:34
 TString.cxx:35
 TString.cxx:36
 TString.cxx:37
 TString.cxx:38
 TString.cxx:39
 TString.cxx:40
 TString.cxx:41
 TString.cxx:42
 TString.cxx:43
 TString.cxx:44
 TString.cxx:45
 TString.cxx:46
 TString.cxx:47
 TString.cxx:48
 TString.cxx:49
 TString.cxx:50
 TString.cxx:51
 TString.cxx:52
 TString.cxx:53
 TString.cxx:54
 TString.cxx:55
 TString.cxx:56
 TString.cxx:57
 TString.cxx:58
 TString.cxx:59
 TString.cxx:60
 TString.cxx:61
 TString.cxx:62
 TString.cxx:63
 TString.cxx:64
 TString.cxx:65
 TString.cxx:66
 TString.cxx:67
 TString.cxx:68
 TString.cxx:69
 TString.cxx:70
 TString.cxx:71
 TString.cxx:72
 TString.cxx:73
 TString.cxx:74
 TString.cxx:75
 TString.cxx:76
 TString.cxx:77
 TString.cxx:78
 TString.cxx:79
 TString.cxx:80
 TString.cxx:81
 TString.cxx:82
 TString.cxx:83
 TString.cxx:84
 TString.cxx:85
 TString.cxx:86
 TString.cxx:87
 TString.cxx:88
 TString.cxx:89
 TString.cxx:90
 TString.cxx:91
 TString.cxx:92
 TString.cxx:93
 TString.cxx:94
 TString.cxx:95
 TString.cxx:96
 TString.cxx:97
 TString.cxx:98
 TString.cxx:99
 TString.cxx:100
 TString.cxx:101
 TString.cxx:102
 TString.cxx:103
 TString.cxx:104
 TString.cxx:105
 TString.cxx:106
 TString.cxx:107
 TString.cxx:108
 TString.cxx:109
 TString.cxx:110
 TString.cxx:111
 TString.cxx:112
 TString.cxx:113
 TString.cxx:114
 TString.cxx:115
 TString.cxx:116
 TString.cxx:117
 TString.cxx:118
 TString.cxx:119
 TString.cxx:120
 TString.cxx:121
 TString.cxx:122
 TString.cxx:123
 TString.cxx:124
 TString.cxx:125
 TString.cxx:126
 TString.cxx:127
 TString.cxx:128
 TString.cxx:129
 TString.cxx:130
 TString.cxx:131
 TString.cxx:132
 TString.cxx:133
 TString.cxx:134
 TString.cxx:135
 TString.cxx:136
 TString.cxx:137
 TString.cxx:138
 TString.cxx:139
 TString.cxx:140
 TString.cxx:141
 TString.cxx:142
 TString.cxx:143
 TString.cxx:144
 TString.cxx:145
 TString.cxx:146
 TString.cxx:147
 TString.cxx:148
 TString.cxx:149
 TString.cxx:150
 TString.cxx:151
 TString.cxx:152
 TString.cxx:153
 TString.cxx:154
 TString.cxx:155
 TString.cxx:156
 TString.cxx:157
 TString.cxx:158
 TString.cxx:159
 TString.cxx:160
 TString.cxx:161
 TString.cxx:162
 TString.cxx:163
 TString.cxx:164
 TString.cxx:165
 TString.cxx:166
 TString.cxx:167
 TString.cxx:168
 TString.cxx:169
 TString.cxx:170
 TString.cxx:171
 TString.cxx:172
 TString.cxx:173
 TString.cxx:174
 TString.cxx:175
 TString.cxx:176
 TString.cxx:177
 TString.cxx:178
 TString.cxx:179
 TString.cxx:180
 TString.cxx:181
 TString.cxx:182
 TString.cxx:183
 TString.cxx:184
 TString.cxx:185
 TString.cxx:186
 TString.cxx:187
 TString.cxx:188
 TString.cxx:189
 TString.cxx:190
 TString.cxx:191
 TString.cxx:192
 TString.cxx:193
 TString.cxx:194
 TString.cxx:195
 TString.cxx:196
 TString.cxx:197
 TString.cxx:198
 TString.cxx:199
 TString.cxx:200
 TString.cxx:201
 TString.cxx:202
 TString.cxx:203
 TString.cxx:204
 TString.cxx:205
 TString.cxx:206
 TString.cxx:207
 TString.cxx:208
 TString.cxx:209
 TString.cxx:210
 TString.cxx:211
 TString.cxx:212
 TString.cxx:213
 TString.cxx:214
 TString.cxx:215
 TString.cxx:216
 TString.cxx:217
 TString.cxx:218
 TString.cxx:219
 TString.cxx:220
 TString.cxx:221
 TString.cxx:222
 TString.cxx:223
 TString.cxx:224
 TString.cxx:225
 TString.cxx:226
 TString.cxx:227
 TString.cxx:228
 TString.cxx:229
 TString.cxx:230
 TString.cxx:231
 TString.cxx:232
 TString.cxx:233
 TString.cxx:234
 TString.cxx:235
 TString.cxx:236
 TString.cxx:237
 TString.cxx:238
 TString.cxx:239
 TString.cxx:240
 TString.cxx:241
 TString.cxx:242
 TString.cxx:243
 TString.cxx:244
 TString.cxx:245
 TString.cxx:246
 TString.cxx:247
 TString.cxx:248
 TString.cxx:249
 TString.cxx:250
 TString.cxx:251
 TString.cxx:252
 TString.cxx:253
 TString.cxx:254
 TString.cxx:255
 TString.cxx:256
 TString.cxx:257
 TString.cxx:258
 TString.cxx:259
 TString.cxx:260
 TString.cxx:261
 TString.cxx:262
 TString.cxx:263
 TString.cxx:264
 TString.cxx:265
 TString.cxx:266
 TString.cxx:267
 TString.cxx:268
 TString.cxx:269
 TString.cxx:270
 TString.cxx:271
 TString.cxx:272
 TString.cxx:273
 TString.cxx:274
 TString.cxx:275
 TString.cxx:276
 TString.cxx:277
 TString.cxx:278
 TString.cxx:279
 TString.cxx:280
 TString.cxx:281
 TString.cxx:282
 TString.cxx:283
 TString.cxx:284
 TString.cxx:285
 TString.cxx:286
 TString.cxx:287
 TString.cxx:288
 TString.cxx:289
 TString.cxx:290
 TString.cxx:291
 TString.cxx:292
 TString.cxx:293
 TString.cxx:294
 TString.cxx:295
 TString.cxx:296
 TString.cxx:297
 TString.cxx:298
 TString.cxx:299
 TString.cxx:300
 TString.cxx:301
 TString.cxx:302
 TString.cxx:303
 TString.cxx:304
 TString.cxx:305
 TString.cxx:306
 TString.cxx:307
 TString.cxx:308
 TString.cxx:309
 TString.cxx:310
 TString.cxx:311
 TString.cxx:312
 TString.cxx:313
 TString.cxx:314
 TString.cxx:315
 TString.cxx:316
 TString.cxx:317
 TString.cxx:318
 TString.cxx:319
 TString.cxx:320
 TString.cxx:321
 TString.cxx:322
 TString.cxx:323
 TString.cxx:324
 TString.cxx:325
 TString.cxx:326
 TString.cxx:327
 TString.cxx:328
 TString.cxx:329
 TString.cxx:330
 TString.cxx:331
 TString.cxx:332
 TString.cxx:333
 TString.cxx:334
 TString.cxx:335
 TString.cxx:336
 TString.cxx:337
 TString.cxx:338
 TString.cxx:339
 TString.cxx:340
 TString.cxx:341
 TString.cxx:342
 TString.cxx:343
 TString.cxx:344
 TString.cxx:345
 TString.cxx:346
 TString.cxx:347
 TString.cxx:348
 TString.cxx:349
 TString.cxx:350
 TString.cxx:351
 TString.cxx:352
 TString.cxx:353
 TString.cxx:354
 TString.cxx:355
 TString.cxx:356
 TString.cxx:357
 TString.cxx:358
 TString.cxx:359
 TString.cxx:360
 TString.cxx:361
 TString.cxx:362
 TString.cxx:363
 TString.cxx:364
 TString.cxx:365
 TString.cxx:366
 TString.cxx:367
 TString.cxx:368
 TString.cxx:369
 TString.cxx:370
 TString.cxx:371
 TString.cxx:372
 TString.cxx:373
 TString.cxx:374
 TString.cxx:375
 TString.cxx:376
 TString.cxx:377
 TString.cxx:378
 TString.cxx:379
 TString.cxx:380
 TString.cxx:381
 TString.cxx:382
 TString.cxx:383
 TString.cxx:384
 TString.cxx:385
 TString.cxx:386
 TString.cxx:387
 TString.cxx:388
 TString.cxx:389
 TString.cxx:390
 TString.cxx:391
 TString.cxx:392
 TString.cxx:393
 TString.cxx:394
 TString.cxx:395
 TString.cxx:396
 TString.cxx:397
 TString.cxx:398
 TString.cxx:399
 TString.cxx:400
 TString.cxx:401
 TString.cxx:402
 TString.cxx:403
 TString.cxx:404
 TString.cxx:405
 TString.cxx:406
 TString.cxx:407
 TString.cxx:408
 TString.cxx:409
 TString.cxx:410
 TString.cxx:411
 TString.cxx:412
 TString.cxx:413
 TString.cxx:414
 TString.cxx:415
 TString.cxx:416
 TString.cxx:417
 TString.cxx:418
 TString.cxx:419
 TString.cxx:420
 TString.cxx:421
 TString.cxx:422
 TString.cxx:423
 TString.cxx:424
 TString.cxx:425
 TString.cxx:426
 TString.cxx:427
 TString.cxx:428
 TString.cxx:429
 TString.cxx:430
 TString.cxx:431
 TString.cxx:432
 TString.cxx:433
 TString.cxx:434
 TString.cxx:435
 TString.cxx:436
 TString.cxx:437
 TString.cxx:438
 TString.cxx:439
 TString.cxx:440
 TString.cxx:441
 TString.cxx:442
 TString.cxx:443
 TString.cxx:444
 TString.cxx:445
 TString.cxx:446
 TString.cxx:447
 TString.cxx:448
 TString.cxx:449
 TString.cxx:450
 TString.cxx:451
 TString.cxx:452
 TString.cxx:453
 TString.cxx:454
 TString.cxx:455
 TString.cxx:456
 TString.cxx:457
 TString.cxx:458
 TString.cxx:459
 TString.cxx:460
 TString.cxx:461
 TString.cxx:462
 TString.cxx:463
 TString.cxx:464
 TString.cxx:465
 TString.cxx:466
 TString.cxx:467
 TString.cxx:468
 TString.cxx:469
 TString.cxx:470
 TString.cxx:471
 TString.cxx:472
 TString.cxx:473
 TString.cxx:474
 TString.cxx:475
 TString.cxx:476
 TString.cxx:477
 TString.cxx:478
 TString.cxx:479
 TString.cxx:480
 TString.cxx:481
 TString.cxx:482
 TString.cxx:483
 TString.cxx:484
 TString.cxx:485
 TString.cxx:486
 TString.cxx:487
 TString.cxx:488
 TString.cxx:489
 TString.cxx:490
 TString.cxx:491
 TString.cxx:492
 TString.cxx:493
 TString.cxx:494
 TString.cxx:495
 TString.cxx:496
 TString.cxx:497
 TString.cxx:498
 TString.cxx:499
 TString.cxx:500
 TString.cxx:501
 TString.cxx:502
 TString.cxx:503
 TString.cxx:504
 TString.cxx:505
 TString.cxx:506
 TString.cxx:507
 TString.cxx:508
 TString.cxx:509
 TString.cxx:510
 TString.cxx:511
 TString.cxx:512
 TString.cxx:513
 TString.cxx:514
 TString.cxx:515
 TString.cxx:516
 TString.cxx:517
 TString.cxx:518
 TString.cxx:519
 TString.cxx:520
 TString.cxx:521
 TString.cxx:522
 TString.cxx:523
 TString.cxx:524
 TString.cxx:525
 TString.cxx:526
 TString.cxx:527
 TString.cxx:528
 TString.cxx:529
 TString.cxx:530
 TString.cxx:531
 TString.cxx:532
 TString.cxx:533
 TString.cxx:534
 TString.cxx:535
 TString.cxx:536
 TString.cxx:537
 TString.cxx:538
 TString.cxx:539
 TString.cxx:540
 TString.cxx:541
 TString.cxx:542
 TString.cxx:543
 TString.cxx:544
 TString.cxx:545
 TString.cxx:546
 TString.cxx:547
 TString.cxx:548
 TString.cxx:549
 TString.cxx:550
 TString.cxx:551
 TString.cxx:552
 TString.cxx:553
 TString.cxx:554
 TString.cxx:555
 TString.cxx:556
 TString.cxx:557
 TString.cxx:558
 TString.cxx:559
 TString.cxx:560
 TString.cxx:561
 TString.cxx:562
 TString.cxx:563
 TString.cxx:564
 TString.cxx:565
 TString.cxx:566
 TString.cxx:567
 TString.cxx:568
 TString.cxx:569
 TString.cxx:570
 TString.cxx:571
 TString.cxx:572
 TString.cxx:573
 TString.cxx:574
 TString.cxx:575
 TString.cxx:576
 TString.cxx:577
 TString.cxx:578
 TString.cxx:579
 TString.cxx:580
 TString.cxx:581
 TString.cxx:582
 TString.cxx:583
 TString.cxx:584
 TString.cxx:585
 TString.cxx:586
 TString.cxx:587
 TString.cxx:588
 TString.cxx:589
 TString.cxx:590
 TString.cxx:591
 TString.cxx:592
 TString.cxx:593
 TString.cxx:594
 TString.cxx:595
 TString.cxx:596
 TString.cxx:597
 TString.cxx:598
 TString.cxx:599
 TString.cxx:600
 TString.cxx:601
 TString.cxx:602
 TString.cxx:603
 TString.cxx:604
 TString.cxx:605
 TString.cxx:606
 TString.cxx:607
 TString.cxx:608
 TString.cxx:609
 TString.cxx:610
 TString.cxx:611
 TString.cxx:612
 TString.cxx:613
 TString.cxx:614
 TString.cxx:615
 TString.cxx:616
 TString.cxx:617
 TString.cxx:618
 TString.cxx:619
 TString.cxx:620
 TString.cxx:621
 TString.cxx:622
 TString.cxx:623
 TString.cxx:624
 TString.cxx:625
 TString.cxx:626
 TString.cxx:627
 TString.cxx:628
 TString.cxx:629
 TString.cxx:630
 TString.cxx:631
 TString.cxx:632
 TString.cxx:633
 TString.cxx:634
 TString.cxx:635
 TString.cxx:636
 TString.cxx:637
 TString.cxx:638
 TString.cxx:639
 TString.cxx:640
 TString.cxx:641
 TString.cxx:642
 TString.cxx:643
 TString.cxx:644
 TString.cxx:645
 TString.cxx:646
 TString.cxx:647
 TString.cxx:648
 TString.cxx:649
 TString.cxx:650
 TString.cxx:651
 TString.cxx:652
 TString.cxx:653
 TString.cxx:654
 TString.cxx:655
 TString.cxx:656
 TString.cxx:657
 TString.cxx:658
 TString.cxx:659
 TString.cxx:660
 TString.cxx:661
 TString.cxx:662
 TString.cxx:663
 TString.cxx:664
 TString.cxx:665
 TString.cxx:666
 TString.cxx:667
 TString.cxx:668
 TString.cxx:669
 TString.cxx:670
 TString.cxx:671
 TString.cxx:672
 TString.cxx:673
 TString.cxx:674
 TString.cxx:675
 TString.cxx:676
 TString.cxx:677
 TString.cxx:678
 TString.cxx:679
 TString.cxx:680
 TString.cxx:681
 TString.cxx:682
 TString.cxx:683
 TString.cxx:684
 TString.cxx:685
 TString.cxx:686
 TString.cxx:687
 TString.cxx:688
 TString.cxx:689
 TString.cxx:690
 TString.cxx:691
 TString.cxx:692
 TString.cxx:693
 TString.cxx:694
 TString.cxx:695
 TString.cxx:696
 TString.cxx:697
 TString.cxx:698
 TString.cxx:699
 TString.cxx:700
 TString.cxx:701
 TString.cxx:702
 TString.cxx:703
 TString.cxx:704
 TString.cxx:705
 TString.cxx:706
 TString.cxx:707
 TString.cxx:708
 TString.cxx:709
 TString.cxx:710
 TString.cxx:711
 TString.cxx:712
 TString.cxx:713
 TString.cxx:714
 TString.cxx:715
 TString.cxx:716
 TString.cxx:717
 TString.cxx:718
 TString.cxx:719
 TString.cxx:720
 TString.cxx:721
 TString.cxx:722
 TString.cxx:723
 TString.cxx:724
 TString.cxx:725
 TString.cxx:726
 TString.cxx:727
 TString.cxx:728
 TString.cxx:729
 TString.cxx:730
 TString.cxx:731
 TString.cxx:732
 TString.cxx:733
 TString.cxx:734
 TString.cxx:735
 TString.cxx:736
 TString.cxx:737
 TString.cxx:738
 TString.cxx:739
 TString.cxx:740
 TString.cxx:741
 TString.cxx:742
 TString.cxx:743
 TString.cxx:744
 TString.cxx:745
 TString.cxx:746
 TString.cxx:747
 TString.cxx:748
 TString.cxx:749
 TString.cxx:750
 TString.cxx:751
 TString.cxx:752
 TString.cxx:753
 TString.cxx:754
 TString.cxx:755
 TString.cxx:756
 TString.cxx:757
 TString.cxx:758
 TString.cxx:759
 TString.cxx:760
 TString.cxx:761
 TString.cxx:762
 TString.cxx:763
 TString.cxx:764
 TString.cxx:765
 TString.cxx:766
 TString.cxx:767
 TString.cxx:768
 TString.cxx:769
 TString.cxx:770
 TString.cxx:771
 TString.cxx:772
 TString.cxx:773
 TString.cxx:774
 TString.cxx:775
 TString.cxx:776
 TString.cxx:777
 TString.cxx:778
 TString.cxx:779
 TString.cxx:780
 TString.cxx:781
 TString.cxx:782
 TString.cxx:783
 TString.cxx:784
 TString.cxx:785
 TString.cxx:786
 TString.cxx:787
 TString.cxx:788
 TString.cxx:789
 TString.cxx:790
 TString.cxx:791
 TString.cxx:792
 TString.cxx:793
 TString.cxx:794
 TString.cxx:795
 TString.cxx:796
 TString.cxx:797
 TString.cxx:798
 TString.cxx:799
 TString.cxx:800
 TString.cxx:801
 TString.cxx:802
 TString.cxx:803
 TString.cxx:804
 TString.cxx:805
 TString.cxx:806
 TString.cxx:807
 TString.cxx:808
 TString.cxx:809
 TString.cxx:810
 TString.cxx:811
 TString.cxx:812
 TString.cxx:813
 TString.cxx:814
 TString.cxx:815
 TString.cxx:816
 TString.cxx:817
 TString.cxx:818
 TString.cxx:819
 TString.cxx:820
 TString.cxx:821
 TString.cxx:822
 TString.cxx:823
 TString.cxx:824
 TString.cxx:825
 TString.cxx:826
 TString.cxx:827
 TString.cxx:828
 TString.cxx:829
 TString.cxx:830
 TString.cxx:831
 TString.cxx:832
 TString.cxx:833
 TString.cxx:834
 TString.cxx:835
 TString.cxx:836
 TString.cxx:837
 TString.cxx:838
 TString.cxx:839
 TString.cxx:840
 TString.cxx:841
 TString.cxx:842
 TString.cxx:843
 TString.cxx:844
 TString.cxx:845
 TString.cxx:846
 TString.cxx:847
 TString.cxx:848
 TString.cxx:849
 TString.cxx:850
 TString.cxx:851
 TString.cxx:852
 TString.cxx:853
 TString.cxx:854
 TString.cxx:855
 TString.cxx:856
 TString.cxx:857
 TString.cxx:858
 TString.cxx:859
 TString.cxx:860
 TString.cxx:861
 TString.cxx:862
 TString.cxx:863
 TString.cxx:864
 TString.cxx:865
 TString.cxx:866
 TString.cxx:867
 TString.cxx:868
 TString.cxx:869
 TString.cxx:870
 TString.cxx:871
 TString.cxx:872
 TString.cxx:873
 TString.cxx:874
 TString.cxx:875
 TString.cxx:876
 TString.cxx:877
 TString.cxx:878
 TString.cxx:879
 TString.cxx:880
 TString.cxx:881
 TString.cxx:882
 TString.cxx:883
 TString.cxx:884
 TString.cxx:885
 TString.cxx:886
 TString.cxx:887
 TString.cxx:888
 TString.cxx:889
 TString.cxx:890
 TString.cxx:891
 TString.cxx:892
 TString.cxx:893
 TString.cxx:894
 TString.cxx:895
 TString.cxx:896
 TString.cxx:897
 TString.cxx:898
 TString.cxx:899
 TString.cxx:900
 TString.cxx:901
 TString.cxx:902
 TString.cxx:903
 TString.cxx:904
 TString.cxx:905
 TString.cxx:906
 TString.cxx:907
 TString.cxx:908
 TString.cxx:909
 TString.cxx:910
 TString.cxx:911
 TString.cxx:912
 TString.cxx:913
 TString.cxx:914
 TString.cxx:915
 TString.cxx:916
 TString.cxx:917
 TString.cxx:918
 TString.cxx:919
 TString.cxx:920
 TString.cxx:921
 TString.cxx:922
 TString.cxx:923
 TString.cxx:924
 TString.cxx:925
 TString.cxx:926
 TString.cxx:927
 TString.cxx:928
 TString.cxx:929
 TString.cxx:930
 TString.cxx:931
 TString.cxx:932
 TString.cxx:933
 TString.cxx:934
 TString.cxx:935
 TString.cxx:936
 TString.cxx:937
 TString.cxx:938
 TString.cxx:939
 TString.cxx:940
 TString.cxx:941
 TString.cxx:942
 TString.cxx:943
 TString.cxx:944
 TString.cxx:945
 TString.cxx:946
 TString.cxx:947
 TString.cxx:948
 TString.cxx:949
 TString.cxx:950
 TString.cxx:951
 TString.cxx:952
 TString.cxx:953
 TString.cxx:954
 TString.cxx:955
 TString.cxx:956
 TString.cxx:957
 TString.cxx:958
 TString.cxx:959
 TString.cxx:960
 TString.cxx:961
 TString.cxx:962
 TString.cxx:963
 TString.cxx:964
 TString.cxx:965
 TString.cxx:966
 TString.cxx:967
 TString.cxx:968
 TString.cxx:969
 TString.cxx:970
 TString.cxx:971
 TString.cxx:972
 TString.cxx:973
 TString.cxx:974
 TString.cxx:975
 TString.cxx:976
 TString.cxx:977
 TString.cxx:978
 TString.cxx:979
 TString.cxx:980
 TString.cxx:981
 TString.cxx:982
 TString.cxx:983
 TString.cxx:984
 TString.cxx:985
 TString.cxx:986
 TString.cxx:987
 TString.cxx:988
 TString.cxx:989
 TString.cxx:990
 TString.cxx:991
 TString.cxx:992
 TString.cxx:993
 TString.cxx:994
 TString.cxx:995
 TString.cxx:996
 TString.cxx:997
 TString.cxx:998
 TString.cxx:999
 TString.cxx:1000
 TString.cxx:1001
 TString.cxx:1002
 TString.cxx:1003
 TString.cxx:1004
 TString.cxx:1005
 TString.cxx:1006
 TString.cxx:1007
 TString.cxx:1008
 TString.cxx:1009
 TString.cxx:1010
 TString.cxx:1011
 TString.cxx:1012
 TString.cxx:1013
 TString.cxx:1014
 TString.cxx:1015
 TString.cxx:1016
 TString.cxx:1017
 TString.cxx:1018
 TString.cxx:1019
 TString.cxx:1020
 TString.cxx:1021
 TString.cxx:1022
 TString.cxx:1023
 TString.cxx:1024
 TString.cxx:1025
 TString.cxx:1026
 TString.cxx:1027
 TString.cxx:1028
 TString.cxx:1029
 TString.cxx:1030
 TString.cxx:1031
 TString.cxx:1032
 TString.cxx:1033
 TString.cxx:1034
 TString.cxx:1035
 TString.cxx:1036
 TString.cxx:1037
 TString.cxx:1038
 TString.cxx:1039
 TString.cxx:1040
 TString.cxx:1041
 TString.cxx:1042
 TString.cxx:1043
 TString.cxx:1044
 TString.cxx:1045
 TString.cxx:1046
 TString.cxx:1047
 TString.cxx:1048
 TString.cxx:1049
 TString.cxx:1050
 TString.cxx:1051
 TString.cxx:1052
 TString.cxx:1053
 TString.cxx:1054
 TString.cxx:1055
 TString.cxx:1056
 TString.cxx:1057
 TString.cxx:1058
 TString.cxx:1059
 TString.cxx:1060
 TString.cxx:1061
 TString.cxx:1062
 TString.cxx:1063
 TString.cxx:1064
 TString.cxx:1065
 TString.cxx:1066
 TString.cxx:1067
 TString.cxx:1068
 TString.cxx:1069
 TString.cxx:1070
 TString.cxx:1071
 TString.cxx:1072
 TString.cxx:1073
 TString.cxx:1074
 TString.cxx:1075
 TString.cxx:1076
 TString.cxx:1077
 TString.cxx:1078
 TString.cxx:1079
 TString.cxx:1080
 TString.cxx:1081
 TString.cxx:1082
 TString.cxx:1083
 TString.cxx:1084
 TString.cxx:1085
 TString.cxx:1086
 TString.cxx:1087
 TString.cxx:1088
 TString.cxx:1089
 TString.cxx:1090
 TString.cxx:1091
 TString.cxx:1092
 TString.cxx:1093
 TString.cxx:1094
 TString.cxx:1095
 TString.cxx:1096
 TString.cxx:1097
 TString.cxx:1098
 TString.cxx:1099
 TString.cxx:1100
 TString.cxx:1101
 TString.cxx:1102
 TString.cxx:1103
 TString.cxx:1104
 TString.cxx:1105
 TString.cxx:1106
 TString.cxx:1107
 TString.cxx:1108
 TString.cxx:1109
 TString.cxx:1110
 TString.cxx:1111
 TString.cxx:1112
 TString.cxx:1113
 TString.cxx:1114
 TString.cxx:1115
 TString.cxx:1116
 TString.cxx:1117
 TString.cxx:1118
 TString.cxx:1119
 TString.cxx:1120
 TString.cxx:1121
 TString.cxx:1122
 TString.cxx:1123
 TString.cxx:1124
 TString.cxx:1125
 TString.cxx:1126
 TString.cxx:1127
 TString.cxx:1128
 TString.cxx:1129
 TString.cxx:1130
 TString.cxx:1131
 TString.cxx:1132
 TString.cxx:1133
 TString.cxx:1134
 TString.cxx:1135
 TString.cxx:1136
 TString.cxx:1137
 TString.cxx:1138
 TString.cxx:1139
 TString.cxx:1140
 TString.cxx:1141
 TString.cxx:1142
 TString.cxx:1143
 TString.cxx:1144
 TString.cxx:1145
 TString.cxx:1146
 TString.cxx:1147
 TString.cxx:1148
 TString.cxx:1149
 TString.cxx:1150
 TString.cxx:1151
 TString.cxx:1152
 TString.cxx:1153
 TString.cxx:1154
 TString.cxx:1155
 TString.cxx:1156
 TString.cxx:1157
 TString.cxx:1158
 TString.cxx:1159
 TString.cxx:1160
 TString.cxx:1161
 TString.cxx:1162
 TString.cxx:1163
 TString.cxx:1164
 TString.cxx:1165
 TString.cxx:1166
 TString.cxx:1167
 TString.cxx:1168
 TString.cxx:1169
 TString.cxx:1170
 TString.cxx:1171
 TString.cxx:1172
 TString.cxx:1173
 TString.cxx:1174
 TString.cxx:1175
 TString.cxx:1176
 TString.cxx:1177
 TString.cxx:1178
 TString.cxx:1179
 TString.cxx:1180
 TString.cxx:1181
 TString.cxx:1182
 TString.cxx:1183
 TString.cxx:1184
 TString.cxx:1185
 TString.cxx:1186
 TString.cxx:1187
 TString.cxx:1188
 TString.cxx:1189
 TString.cxx:1190
 TString.cxx:1191
 TString.cxx:1192
 TString.cxx:1193
 TString.cxx:1194
 TString.cxx:1195
 TString.cxx:1196
 TString.cxx:1197
 TString.cxx:1198
 TString.cxx:1199
 TString.cxx:1200
 TString.cxx:1201
 TString.cxx:1202
 TString.cxx:1203
 TString.cxx:1204
 TString.cxx:1205
 TString.cxx:1206
 TString.cxx:1207
 TString.cxx:1208
 TString.cxx:1209
 TString.cxx:1210
 TString.cxx:1211
 TString.cxx:1212
 TString.cxx:1213
 TString.cxx:1214
 TString.cxx:1215
 TString.cxx:1216
 TString.cxx:1217
 TString.cxx:1218
 TString.cxx:1219
 TString.cxx:1220
 TString.cxx:1221
 TString.cxx:1222
 TString.cxx:1223
 TString.cxx:1224
 TString.cxx:1225
 TString.cxx:1226
 TString.cxx:1227
 TString.cxx:1228
 TString.cxx:1229
 TString.cxx:1230
 TString.cxx:1231
 TString.cxx:1232
 TString.cxx:1233
 TString.cxx:1234
 TString.cxx:1235
 TString.cxx:1236
 TString.cxx:1237
 TString.cxx:1238
 TString.cxx:1239
 TString.cxx:1240
 TString.cxx:1241
 TString.cxx:1242
 TString.cxx:1243
 TString.cxx:1244
 TString.cxx:1245
 TString.cxx:1246
 TString.cxx:1247
 TString.cxx:1248
 TString.cxx:1249
 TString.cxx:1250
 TString.cxx:1251
 TString.cxx:1252
 TString.cxx:1253
 TString.cxx:1254
 TString.cxx:1255
 TString.cxx:1256
 TString.cxx:1257
 TString.cxx:1258
 TString.cxx:1259
 TString.cxx:1260
 TString.cxx:1261
 TString.cxx:1262
 TString.cxx:1263
 TString.cxx:1264
 TString.cxx:1265
 TString.cxx:1266
 TString.cxx:1267
 TString.cxx:1268
 TString.cxx:1269
 TString.cxx:1270
 TString.cxx:1271
 TString.cxx:1272
 TString.cxx:1273
 TString.cxx:1274
 TString.cxx:1275
 TString.cxx:1276
 TString.cxx:1277
 TString.cxx:1278
 TString.cxx:1279
 TString.cxx:1280
 TString.cxx:1281
 TString.cxx:1282
 TString.cxx:1283
 TString.cxx:1284
 TString.cxx:1285
 TString.cxx:1286
 TString.cxx:1287
 TString.cxx:1288
 TString.cxx:1289
 TString.cxx:1290
 TString.cxx:1291
 TString.cxx:1292
 TString.cxx:1293
 TString.cxx:1294
 TString.cxx:1295
 TString.cxx:1296
 TString.cxx:1297
 TString.cxx:1298
 TString.cxx:1299
 TString.cxx:1300
 TString.cxx:1301
 TString.cxx:1302
 TString.cxx:1303
 TString.cxx:1304
 TString.cxx:1305
 TString.cxx:1306
 TString.cxx:1307
 TString.cxx:1308
 TString.cxx:1309
 TString.cxx:1310
 TString.cxx:1311
 TString.cxx:1312
 TString.cxx:1313
 TString.cxx:1314
 TString.cxx:1315
 TString.cxx:1316
 TString.cxx:1317
 TString.cxx:1318
 TString.cxx:1319
 TString.cxx:1320
 TString.cxx:1321
 TString.cxx:1322
 TString.cxx:1323
 TString.cxx:1324
 TString.cxx:1325
 TString.cxx:1326
 TString.cxx:1327
 TString.cxx:1328
 TString.cxx:1329
 TString.cxx:1330
 TString.cxx:1331
 TString.cxx:1332
 TString.cxx:1333
 TString.cxx:1334
 TString.cxx:1335
 TString.cxx:1336
 TString.cxx:1337
 TString.cxx:1338
 TString.cxx:1339
 TString.cxx:1340
 TString.cxx:1341
 TString.cxx:1342
 TString.cxx:1343
 TString.cxx:1344
 TString.cxx:1345
 TString.cxx:1346
 TString.cxx:1347
 TString.cxx:1348
 TString.cxx:1349
 TString.cxx:1350
 TString.cxx:1351
 TString.cxx:1352
 TString.cxx:1353
 TString.cxx:1354
 TString.cxx:1355
 TString.cxx:1356
 TString.cxx:1357
 TString.cxx:1358
 TString.cxx:1359
 TString.cxx:1360
 TString.cxx:1361
 TString.cxx:1362
 TString.cxx:1363
 TString.cxx:1364
 TString.cxx:1365
 TString.cxx:1366
 TString.cxx:1367
 TString.cxx:1368
 TString.cxx:1369
 TString.cxx:1370
 TString.cxx:1371
 TString.cxx:1372
 TString.cxx:1373
 TString.cxx:1374
 TString.cxx:1375
 TString.cxx:1376
 TString.cxx:1377
 TString.cxx:1378
 TString.cxx:1379
 TString.cxx:1380
 TString.cxx:1381
 TString.cxx:1382
 TString.cxx:1383
 TString.cxx:1384
 TString.cxx:1385
 TString.cxx:1386
 TString.cxx:1387
 TString.cxx:1388
 TString.cxx:1389
 TString.cxx:1390
 TString.cxx:1391
 TString.cxx:1392
 TString.cxx:1393
 TString.cxx:1394
 TString.cxx:1395
 TString.cxx:1396
 TString.cxx:1397
 TString.cxx:1398
 TString.cxx:1399
 TString.cxx:1400
 TString.cxx:1401
 TString.cxx:1402
 TString.cxx:1403
 TString.cxx:1404
 TString.cxx:1405
 TString.cxx:1406
 TString.cxx:1407
 TString.cxx:1408
 TString.cxx:1409
 TString.cxx:1410
 TString.cxx:1411
 TString.cxx:1412
 TString.cxx:1413
 TString.cxx:1414
 TString.cxx:1415
 TString.cxx:1416
 TString.cxx:1417
 TString.cxx:1418
 TString.cxx:1419
 TString.cxx:1420
 TString.cxx:1421
 TString.cxx:1422
 TString.cxx:1423
 TString.cxx:1424
 TString.cxx:1425
 TString.cxx:1426
 TString.cxx:1427
 TString.cxx:1428
 TString.cxx:1429
 TString.cxx:1430
 TString.cxx:1431
 TString.cxx:1432
 TString.cxx:1433
 TString.cxx:1434
 TString.cxx:1435
 TString.cxx:1436
 TString.cxx:1437
 TString.cxx:1438
 TString.cxx:1439
 TString.cxx:1440
 TString.cxx:1441
 TString.cxx:1442
 TString.cxx:1443
 TString.cxx:1444
 TString.cxx:1445
 TString.cxx:1446
 TString.cxx:1447
 TString.cxx:1448
 TString.cxx:1449
 TString.cxx:1450
 TString.cxx:1451
 TString.cxx:1452
 TString.cxx:1453
 TString.cxx:1454
 TString.cxx:1455
 TString.cxx:1456
 TString.cxx:1457
 TString.cxx:1458
 TString.cxx:1459
 TString.cxx:1460
 TString.cxx:1461
 TString.cxx:1462
 TString.cxx:1463
 TString.cxx:1464
 TString.cxx:1465
 TString.cxx:1466
 TString.cxx:1467
 TString.cxx:1468
 TString.cxx:1469
 TString.cxx:1470
 TString.cxx:1471
 TString.cxx:1472
 TString.cxx:1473
 TString.cxx:1474
 TString.cxx:1475
 TString.cxx:1476
 TString.cxx:1477
 TString.cxx:1478
 TString.cxx:1479
 TString.cxx:1480
 TString.cxx:1481
 TString.cxx:1482
 TString.cxx:1483
 TString.cxx:1484
 TString.cxx:1485
 TString.cxx:1486
 TString.cxx:1487
 TString.cxx:1488
 TString.cxx:1489
 TString.cxx:1490
 TString.cxx:1491
 TString.cxx:1492
 TString.cxx:1493
 TString.cxx:1494
 TString.cxx:1495
 TString.cxx:1496
 TString.cxx:1497
 TString.cxx:1498
 TString.cxx:1499
 TString.cxx:1500
 TString.cxx:1501
 TString.cxx:1502
 TString.cxx:1503
 TString.cxx:1504
 TString.cxx:1505
 TString.cxx:1506
 TString.cxx:1507
 TString.cxx:1508
 TString.cxx:1509
 TString.cxx:1510
 TString.cxx:1511
 TString.cxx:1512
 TString.cxx:1513
 TString.cxx:1514
 TString.cxx:1515
 TString.cxx:1516
 TString.cxx:1517
 TString.cxx:1518
 TString.cxx:1519
 TString.cxx:1520
 TString.cxx:1521
 TString.cxx:1522
 TString.cxx:1523
 TString.cxx:1524
 TString.cxx:1525
 TString.cxx:1526
 TString.cxx:1527
 TString.cxx:1528
 TString.cxx:1529
 TString.cxx:1530
 TString.cxx:1531
 TString.cxx:1532
 TString.cxx:1533
 TString.cxx:1534
 TString.cxx:1535
 TString.cxx:1536
 TString.cxx:1537
 TString.cxx:1538
 TString.cxx:1539
 TString.cxx:1540
 TString.cxx:1541
 TString.cxx:1542
 TString.cxx:1543
 TString.cxx:1544
 TString.cxx:1545
 TString.cxx:1546
 TString.cxx:1547
 TString.cxx:1548
 TString.cxx:1549
 TString.cxx:1550
 TString.cxx:1551
 TString.cxx:1552
 TString.cxx:1553
 TString.cxx:1554
 TString.cxx:1555
 TString.cxx:1556
 TString.cxx:1557
 TString.cxx:1558
 TString.cxx:1559
 TString.cxx:1560
 TString.cxx:1561
 TString.cxx:1562
 TString.cxx:1563
 TString.cxx:1564
 TString.cxx:1565
 TString.cxx:1566
 TString.cxx:1567
 TString.cxx:1568
 TString.cxx:1569
 TString.cxx:1570
 TString.cxx:1571
 TString.cxx:1572
 TString.cxx:1573
 TString.cxx:1574
 TString.cxx:1575
 TString.cxx:1576
 TString.cxx:1577
 TString.cxx:1578
 TString.cxx:1579
 TString.cxx:1580
 TString.cxx:1581
 TString.cxx:1582
 TString.cxx:1583
 TString.cxx:1584
 TString.cxx:1585
 TString.cxx:1586
 TString.cxx:1587
 TString.cxx:1588
 TString.cxx:1589
 TString.cxx:1590
 TString.cxx:1591
 TString.cxx:1592
 TString.cxx:1593
 TString.cxx:1594
 TString.cxx:1595
 TString.cxx:1596
 TString.cxx:1597
 TString.cxx:1598
 TString.cxx:1599
 TString.cxx:1600
 TString.cxx:1601
 TString.cxx:1602
 TString.cxx:1603
 TString.cxx:1604
 TString.cxx:1605
 TString.cxx:1606
 TString.cxx:1607
 TString.cxx:1608
 TString.cxx:1609
 TString.cxx:1610
 TString.cxx:1611
 TString.cxx:1612
 TString.cxx:1613
 TString.cxx:1614
 TString.cxx:1615
 TString.cxx:1616
 TString.cxx:1617
 TString.cxx:1618
 TString.cxx:1619
 TString.cxx:1620
 TString.cxx:1621
 TString.cxx:1622
 TString.cxx:1623
 TString.cxx:1624
 TString.cxx:1625
 TString.cxx:1626
 TString.cxx:1627
 TString.cxx:1628
 TString.cxx:1629
 TString.cxx:1630
 TString.cxx:1631
 TString.cxx:1632
 TString.cxx:1633
 TString.cxx:1634
 TString.cxx:1635
 TString.cxx:1636
 TString.cxx:1637
 TString.cxx:1638
 TString.cxx:1639
 TString.cxx:1640
 TString.cxx:1641
 TString.cxx:1642
 TString.cxx:1643
 TString.cxx:1644
 TString.cxx:1645
 TString.cxx:1646
 TString.cxx:1647
 TString.cxx:1648
 TString.cxx:1649
 TString.cxx:1650
 TString.cxx:1651
 TString.cxx:1652
 TString.cxx:1653
 TString.cxx:1654
 TString.cxx:1655
 TString.cxx:1656
 TString.cxx:1657
 TString.cxx:1658
 TString.cxx:1659
 TString.cxx:1660
 TString.cxx:1661
 TString.cxx:1662
 TString.cxx:1663
 TString.cxx:1664
 TString.cxx:1665
 TString.cxx:1666
 TString.cxx:1667
 TString.cxx:1668
 TString.cxx:1669
 TString.cxx:1670
 TString.cxx:1671
 TString.cxx:1672
 TString.cxx:1673
 TString.cxx:1674
 TString.cxx:1675
 TString.cxx:1676
 TString.cxx:1677
 TString.cxx:1678
 TString.cxx:1679
 TString.cxx:1680
 TString.cxx:1681
 TString.cxx:1682
 TString.cxx:1683
 TString.cxx:1684
 TString.cxx:1685
 TString.cxx:1686
 TString.cxx:1687
 TString.cxx:1688
 TString.cxx:1689
 TString.cxx:1690
 TString.cxx:1691
 TString.cxx:1692
 TString.cxx:1693
 TString.cxx:1694
 TString.cxx:1695
 TString.cxx:1696
 TString.cxx:1697
 TString.cxx:1698
 TString.cxx:1699
 TString.cxx:1700
 TString.cxx:1701
 TString.cxx:1702
 TString.cxx:1703
 TString.cxx:1704
 TString.cxx:1705
 TString.cxx:1706
 TString.cxx:1707
 TString.cxx:1708
 TString.cxx:1709
 TString.cxx:1710
 TString.cxx:1711
 TString.cxx:1712
 TString.cxx:1713
 TString.cxx:1714
 TString.cxx:1715
 TString.cxx:1716
 TString.cxx:1717
 TString.cxx:1718
 TString.cxx:1719
 TString.cxx:1720
 TString.cxx:1721
 TString.cxx:1722
 TString.cxx:1723
 TString.cxx:1724
 TString.cxx:1725
 TString.cxx:1726
 TString.cxx:1727
 TString.cxx:1728
 TString.cxx:1729
 TString.cxx:1730
 TString.cxx:1731
 TString.cxx:1732
 TString.cxx:1733
 TString.cxx:1734
 TString.cxx:1735
 TString.cxx:1736
 TString.cxx:1737
 TString.cxx:1738
 TString.cxx:1739
 TString.cxx:1740
 TString.cxx:1741
 TString.cxx:1742
 TString.cxx:1743
 TString.cxx:1744
 TString.cxx:1745
 TString.cxx:1746
 TString.cxx:1747
 TString.cxx:1748
 TString.cxx:1749
 TString.cxx:1750
 TString.cxx:1751
 TString.cxx:1752
 TString.cxx:1753
 TString.cxx:1754
 TString.cxx:1755
 TString.cxx:1756
 TString.cxx:1757
 TString.cxx:1758
 TString.cxx:1759
 TString.cxx:1760
 TString.cxx:1761
 TString.cxx:1762
 TString.cxx:1763
 TString.cxx:1764
 TString.cxx:1765
 TString.cxx:1766
 TString.cxx:1767
 TString.cxx:1768
 TString.cxx:1769
 TString.cxx:1770
 TString.cxx:1771
 TString.cxx:1772
 TString.cxx:1773
 TString.cxx:1774
 TString.cxx:1775
 TString.cxx:1776
 TString.cxx:1777
 TString.cxx:1778
 TString.cxx:1779
 TString.cxx:1780
 TString.cxx:1781
 TString.cxx:1782
 TString.cxx:1783
 TString.cxx:1784
 TString.cxx:1785
 TString.cxx:1786
 TString.cxx:1787
 TString.cxx:1788
 TString.cxx:1789
 TString.cxx:1790
 TString.cxx:1791
 TString.cxx:1792
 TString.cxx:1793
 TString.cxx:1794
 TString.cxx:1795
 TString.cxx:1796
 TString.cxx:1797
 TString.cxx:1798
 TString.cxx:1799
 TString.cxx:1800
 TString.cxx:1801
 TString.cxx:1802
 TString.cxx:1803
 TString.cxx:1804
 TString.cxx:1805
 TString.cxx:1806
 TString.cxx:1807
 TString.cxx:1808
 TString.cxx:1809
 TString.cxx:1810
 TString.cxx:1811
 TString.cxx:1812
 TString.cxx:1813
 TString.cxx:1814
 TString.cxx:1815
 TString.cxx:1816
 TString.cxx:1817
 TString.cxx:1818
 TString.cxx:1819
 TString.cxx:1820
 TString.cxx:1821
 TString.cxx:1822
 TString.cxx:1823
 TString.cxx:1824
 TString.cxx:1825
 TString.cxx:1826
 TString.cxx:1827
 TString.cxx:1828
 TString.cxx:1829
 TString.cxx:1830
 TString.cxx:1831
 TString.cxx:1832
 TString.cxx:1833
 TString.cxx:1834
 TString.cxx:1835
 TString.cxx:1836
 TString.cxx:1837
 TString.cxx:1838
 TString.cxx:1839
 TString.cxx:1840
 TString.cxx:1841
 TString.cxx:1842
 TString.cxx:1843
 TString.cxx:1844
 TString.cxx:1845
 TString.cxx:1846
 TString.cxx:1847
 TString.cxx:1848
 TString.cxx:1849
 TString.cxx:1850
 TString.cxx:1851
 TString.cxx:1852
 TString.cxx:1853
 TString.cxx:1854
 TString.cxx:1855
 TString.cxx:1856
 TString.cxx:1857
 TString.cxx:1858
 TString.cxx:1859
 TString.cxx:1860
 TString.cxx:1861
 TString.cxx:1862
 TString.cxx:1863
 TString.cxx:1864
 TString.cxx:1865
 TString.cxx:1866
 TString.cxx:1867
 TString.cxx:1868
 TString.cxx:1869
 TString.cxx:1870
 TString.cxx:1871
 TString.cxx:1872
 TString.cxx:1873
 TString.cxx:1874
 TString.cxx:1875
 TString.cxx:1876
 TString.cxx:1877
 TString.cxx:1878
 TString.cxx:1879
 TString.cxx:1880
 TString.cxx:1881
 TString.cxx:1882
 TString.cxx:1883
 TString.cxx:1884
 TString.cxx:1885
 TString.cxx:1886
 TString.cxx:1887
 TString.cxx:1888
 TString.cxx:1889
 TString.cxx:1890
 TString.cxx:1891
 TString.cxx:1892
 TString.cxx:1893
 TString.cxx:1894
 TString.cxx:1895
 TString.cxx:1896
 TString.cxx:1897
 TString.cxx:1898
 TString.cxx:1899
 TString.cxx:1900
 TString.cxx:1901
 TString.cxx:1902
 TString.cxx:1903
 TString.cxx:1904
 TString.cxx:1905
 TString.cxx:1906
 TString.cxx:1907
 TString.cxx:1908
 TString.cxx:1909
 TString.cxx:1910
 TString.cxx:1911
 TString.cxx:1912
 TString.cxx:1913
 TString.cxx:1914
 TString.cxx:1915
 TString.cxx:1916
 TString.cxx:1917
 TString.cxx:1918
 TString.cxx:1919
 TString.cxx:1920
 TString.cxx:1921
 TString.cxx:1922
 TString.cxx:1923
 TString.cxx:1924
 TString.cxx:1925
 TString.cxx:1926
 TString.cxx:1927
 TString.cxx:1928
 TString.cxx:1929
 TString.cxx:1930
 TString.cxx:1931
 TString.cxx:1932
 TString.cxx:1933
 TString.cxx:1934
 TString.cxx:1935
 TString.cxx:1936
 TString.cxx:1937
 TString.cxx:1938
 TString.cxx:1939
 TString.cxx:1940
 TString.cxx:1941
 TString.cxx:1942
 TString.cxx:1943
 TString.cxx:1944
 TString.cxx:1945
 TString.cxx:1946
 TString.cxx:1947
 TString.cxx:1948
 TString.cxx:1949
 TString.cxx:1950
 TString.cxx:1951
 TString.cxx:1952
 TString.cxx:1953
 TString.cxx:1954
 TString.cxx:1955
 TString.cxx:1956
 TString.cxx:1957
 TString.cxx:1958
 TString.cxx:1959
 TString.cxx:1960
 TString.cxx:1961
 TString.cxx:1962
 TString.cxx:1963
 TString.cxx:1964
 TString.cxx:1965
 TString.cxx:1966
 TString.cxx:1967
 TString.cxx:1968
 TString.cxx:1969
 TString.cxx:1970
 TString.cxx:1971
 TString.cxx:1972
 TString.cxx:1973
 TString.cxx:1974
 TString.cxx:1975
 TString.cxx:1976
 TString.cxx:1977
 TString.cxx:1978
 TString.cxx:1979
 TString.cxx:1980
 TString.cxx:1981
 TString.cxx:1982
 TString.cxx:1983
 TString.cxx:1984
 TString.cxx:1985
 TString.cxx:1986
 TString.cxx:1987
 TString.cxx:1988
 TString.cxx:1989
 TString.cxx:1990
 TString.cxx:1991
 TString.cxx:1992
 TString.cxx:1993
 TString.cxx:1994
 TString.cxx:1995
 TString.cxx:1996
 TString.cxx:1997
 TString.cxx:1998
 TString.cxx:1999
 TString.cxx:2000
 TString.cxx:2001
 TString.cxx:2002
 TString.cxx:2003
 TString.cxx:2004
 TString.cxx:2005
 TString.cxx:2006
 TString.cxx:2007
 TString.cxx:2008
 TString.cxx:2009
 TString.cxx:2010
 TString.cxx:2011
 TString.cxx:2012
 TString.cxx:2013
 TString.cxx:2014
 TString.cxx:2015
 TString.cxx:2016
 TString.cxx:2017
 TString.cxx:2018
 TString.cxx:2019
 TString.cxx:2020
 TString.cxx:2021
 TString.cxx:2022
 TString.cxx:2023
 TString.cxx:2024
 TString.cxx:2025
 TString.cxx:2026
 TString.cxx:2027
 TString.cxx:2028
 TString.cxx:2029
 TString.cxx:2030
 TString.cxx:2031
 TString.cxx:2032
 TString.cxx:2033
 TString.cxx:2034
 TString.cxx:2035
 TString.cxx:2036
 TString.cxx:2037
 TString.cxx:2038
 TString.cxx:2039
 TString.cxx:2040
 TString.cxx:2041
 TString.cxx:2042
 TString.cxx:2043
 TString.cxx:2044
 TString.cxx:2045
 TString.cxx:2046
 TString.cxx:2047
 TString.cxx:2048
 TString.cxx:2049
 TString.cxx:2050
 TString.cxx:2051
 TString.cxx:2052
 TString.cxx:2053
 TString.cxx:2054
 TString.cxx:2055
 TString.cxx:2056
 TString.cxx:2057
 TString.cxx:2058
 TString.cxx:2059
 TString.cxx:2060
 TString.cxx:2061
 TString.cxx:2062
 TString.cxx:2063
 TString.cxx:2064
 TString.cxx:2065
 TString.cxx:2066
 TString.cxx:2067
 TString.cxx:2068
 TString.cxx:2069
 TString.cxx:2070
 TString.cxx:2071
 TString.cxx:2072
 TString.cxx:2073
 TString.cxx:2074
 TString.cxx:2075
 TString.cxx:2076
 TString.cxx:2077
 TString.cxx:2078
 TString.cxx:2079
 TString.cxx:2080
 TString.cxx:2081
 TString.cxx:2082
 TString.cxx:2083
 TString.cxx:2084
 TString.cxx:2085
 TString.cxx:2086
 TString.cxx:2087
 TString.cxx:2088
 TString.cxx:2089
 TString.cxx:2090
 TString.cxx:2091
 TString.cxx:2092
 TString.cxx:2093
 TString.cxx:2094
 TString.cxx:2095
 TString.cxx:2096
 TString.cxx:2097
 TString.cxx:2098
 TString.cxx:2099
 TString.cxx:2100
 TString.cxx:2101
 TString.cxx:2102
 TString.cxx:2103
 TString.cxx:2104
 TString.cxx:2105
 TString.cxx:2106
 TString.cxx:2107
 TString.cxx:2108
 TString.cxx:2109
 TString.cxx:2110
 TString.cxx:2111
 TString.cxx:2112
 TString.cxx:2113
 TString.cxx:2114
 TString.cxx:2115
 TString.cxx:2116
 TString.cxx:2117
 TString.cxx:2118
 TString.cxx:2119
 TString.cxx:2120
 TString.cxx:2121
 TString.cxx:2122
 TString.cxx:2123
 TString.cxx:2124
 TString.cxx:2125
 TString.cxx:2126
 TString.cxx:2127
 TString.cxx:2128
 TString.cxx:2129
 TString.cxx:2130
 TString.cxx:2131
 TString.cxx:2132
 TString.cxx:2133
 TString.cxx:2134
 TString.cxx:2135
 TString.cxx:2136
 TString.cxx:2137
 TString.cxx:2138
 TString.cxx:2139
 TString.cxx:2140
 TString.cxx:2141
 TString.cxx:2142
 TString.cxx:2143
 TString.cxx:2144
 TString.cxx:2145
 TString.cxx:2146
 TString.cxx:2147
 TString.cxx:2148
 TString.cxx:2149
 TString.cxx:2150
 TString.cxx:2151
 TString.cxx:2152
 TString.cxx:2153
 TString.cxx:2154
 TString.cxx:2155
 TString.cxx:2156
 TString.cxx:2157
 TString.cxx:2158
 TString.cxx:2159
 TString.cxx:2160
 TString.cxx:2161
 TString.cxx:2162
 TString.cxx:2163
 TString.cxx:2164
 TString.cxx:2165
 TString.cxx:2166
 TString.cxx:2167
 TString.cxx:2168
 TString.cxx:2169
 TString.cxx:2170
 TString.cxx:2171
 TString.cxx:2172
 TString.cxx:2173
 TString.cxx:2174
 TString.cxx:2175
 TString.cxx:2176
 TString.cxx:2177
 TString.cxx:2178
 TString.cxx:2179
 TString.cxx:2180
 TString.cxx:2181
 TString.cxx:2182
 TString.cxx:2183
 TString.cxx:2184
 TString.cxx:2185
 TString.cxx:2186
 TString.cxx:2187
 TString.cxx:2188
 TString.cxx:2189
 TString.cxx:2190
 TString.cxx:2191
 TString.cxx:2192
 TString.cxx:2193
 TString.cxx:2194
 TString.cxx:2195
 TString.cxx:2196
 TString.cxx:2197
 TString.cxx:2198
 TString.cxx:2199
 TString.cxx:2200
 TString.cxx:2201
 TString.cxx:2202
 TString.cxx:2203
 TString.cxx:2204
 TString.cxx:2205
 TString.cxx:2206
 TString.cxx:2207
 TString.cxx:2208
 TString.cxx:2209
 TString.cxx:2210
 TString.cxx:2211
 TString.cxx:2212
 TString.cxx:2213
 TString.cxx:2214
 TString.cxx:2215
 TString.cxx:2216
 TString.cxx:2217
 TString.cxx:2218
 TString.cxx:2219
 TString.cxx:2220
 TString.cxx:2221
 TString.cxx:2222
 TString.cxx:2223
 TString.cxx:2224
 TString.cxx:2225
 TString.cxx:2226
 TString.cxx:2227
 TString.cxx:2228
 TString.cxx:2229
 TString.cxx:2230
 TString.cxx:2231
 TString.cxx:2232
 TString.cxx:2233
 TString.cxx:2234
 TString.cxx:2235
 TString.cxx:2236
 TString.cxx:2237
 TString.cxx:2238
 TString.cxx:2239
 TString.cxx:2240
 TString.cxx:2241
 TString.cxx:2242
 TString.cxx:2243
 TString.cxx:2244
 TString.cxx:2245
 TString.cxx:2246
 TString.cxx:2247
 TString.cxx:2248
 TString.cxx:2249
 TString.cxx:2250
 TString.cxx:2251
 TString.cxx:2252
 TString.cxx:2253
 TString.cxx:2254
 TString.cxx:2255
 TString.cxx:2256
 TString.cxx:2257
 TString.cxx:2258
 TString.cxx:2259
 TString.cxx:2260
 TString.cxx:2261
 TString.cxx:2262
 TString.cxx:2263
 TString.cxx:2264
 TString.cxx:2265
 TString.cxx:2266
 TString.cxx:2267
 TString.cxx:2268
 TString.cxx:2269
 TString.cxx:2270
 TString.cxx:2271
 TString.cxx:2272
 TString.cxx:2273
 TString.cxx:2274
 TString.cxx:2275
 TString.cxx:2276
 TString.cxx:2277
 TString.cxx:2278
 TString.cxx:2279
 TString.cxx:2280
 TString.cxx:2281
 TString.cxx:2282
 TString.cxx:2283
 TString.cxx:2284
 TString.cxx:2285
 TString.cxx:2286
 TString.cxx:2287
 TString.cxx:2288
 TString.cxx:2289
 TString.cxx:2290
 TString.cxx:2291
 TString.cxx:2292
 TString.cxx:2293
 TString.cxx:2294
 TString.cxx:2295
 TString.cxx:2296
 TString.cxx:2297
 TString.cxx:2298
 TString.cxx:2299
 TString.cxx:2300
 TString.cxx:2301
 TString.cxx:2302
 TString.cxx:2303
 TString.cxx:2304
 TString.cxx:2305
 TString.cxx:2306
 TString.cxx:2307
 TString.cxx:2308
 TString.cxx:2309
 TString.cxx:2310
 TString.cxx:2311
 TString.cxx:2312
 TString.cxx:2313
 TString.cxx:2314
 TString.cxx:2315
 TString.cxx:2316
 TString.cxx:2317
 TString.cxx:2318
 TString.cxx:2319
 TString.cxx:2320
 TString.cxx:2321
 TString.cxx:2322
 TString.cxx:2323
 TString.cxx:2324
 TString.cxx:2325
 TString.cxx:2326
 TString.cxx:2327
 TString.cxx:2328
 TString.cxx:2329
 TString.cxx:2330
 TString.cxx:2331
 TString.cxx:2332
 TString.cxx:2333
 TString.cxx:2334
 TString.cxx:2335
 TString.cxx:2336
 TString.cxx:2337
 TString.cxx:2338
 TString.cxx:2339
 TString.cxx:2340
 TString.cxx:2341
 TString.cxx:2342
 TString.cxx:2343
 TString.cxx:2344
 TString.cxx:2345
 TString.cxx:2346
 TString.cxx:2347
 TString.cxx:2348
 TString.cxx:2349
 TString.cxx:2350
 TString.cxx:2351
 TString.cxx:2352
 TString.cxx:2353
 TString.cxx:2354
 TString.cxx:2355
 TString.cxx:2356
 TString.cxx:2357
 TString.cxx:2358
 TString.cxx:2359
 TString.cxx:2360
 TString.cxx:2361
 TString.cxx:2362
 TString.cxx:2363
 TString.cxx:2364
 TString.cxx:2365
 TString.cxx:2366
 TString.cxx:2367
 TString.cxx:2368
 TString.cxx:2369
 TString.cxx:2370
 TString.cxx:2371
 TString.cxx:2372
 TString.cxx:2373
 TString.cxx:2374
 TString.cxx:2375
 TString.cxx:2376
 TString.cxx:2377
 TString.cxx:2378
 TString.cxx:2379
 TString.cxx:2380
 TString.cxx:2381
 TString.cxx:2382
 TString.cxx:2383
 TString.cxx:2384
 TString.cxx:2385
 TString.cxx:2386
 TString.cxx:2387
 TString.cxx:2388
 TString.cxx:2389
 TString.cxx:2390
 TString.cxx:2391
 TString.cxx:2392
 TString.cxx:2393
 TString.cxx:2394
 TString.cxx:2395
 TString.cxx:2396
 TString.cxx:2397
 TString.cxx:2398
 TString.cxx:2399
 TString.cxx:2400
 TString.cxx:2401
 TString.cxx:2402
 TString.cxx:2403
 TString.cxx:2404
 TString.cxx:2405
 TString.cxx:2406
 TString.cxx:2407
 TString.cxx:2408
 TString.cxx:2409
 TString.cxx:2410
 TString.cxx:2411
 TString.cxx:2412
 TString.cxx:2413
 TString.cxx:2414
 TString.cxx:2415
 TString.cxx:2416
 TString.cxx:2417
 TString.cxx:2418
 TString.cxx:2419
 TString.cxx:2420
 TString.cxx:2421
 TString.cxx:2422
 TString.cxx:2423
 TString.cxx:2424
 TString.cxx:2425
 TString.cxx:2426
 TString.cxx:2427
 TString.cxx:2428
 TString.cxx:2429
 TString.cxx:2430
 TString.cxx:2431
 TString.cxx:2432
 TString.cxx:2433
 TString.cxx:2434
 TString.cxx:2435
 TString.cxx:2436
 TString.cxx:2437
 TString.cxx:2438
 TString.cxx:2439
 TString.cxx:2440
 TString.cxx:2441
 TString.cxx:2442
 TString.cxx:2443
 TString.cxx:2444
 TString.cxx:2445
 TString.cxx:2446
 TString.cxx:2447
 TString.cxx:2448
 TString.cxx:2449
 TString.cxx:2450
 TString.cxx:2451
 TString.cxx:2452
 TString.cxx:2453
 TString.cxx:2454
 TString.cxx:2455
 TString.cxx:2456
 TString.cxx:2457
 TString.cxx:2458
 TString.cxx:2459
 TString.cxx:2460
 TString.cxx:2461
 TString.cxx:2462
 TString.cxx:2463
 TString.cxx:2464
 TString.cxx:2465
 TString.cxx:2466
 TString.cxx:2467
 TString.cxx:2468
 TString.cxx:2469
 TString.cxx:2470
 TString.cxx:2471
 TString.cxx:2472
 TString.cxx:2473
 TString.cxx:2474
 TString.cxx:2475
 TString.cxx:2476
 TString.cxx:2477
 TString.cxx:2478
 TString.cxx:2479
 TString.cxx:2480
 TString.cxx:2481
 TString.cxx:2482
 TString.cxx:2483
 TString.cxx:2484
 TString.cxx:2485
 TString.cxx:2486
 TString.cxx:2487
 TString.cxx:2488
 TString.cxx:2489
 TString.cxx:2490
 TString.cxx:2491
 TString.cxx:2492
 TString.cxx:2493
 TString.cxx:2494
 TString.cxx:2495
 TString.cxx:2496
 TString.cxx:2497
 TString.cxx:2498
 TString.cxx:2499
 TString.cxx:2500
 TString.cxx:2501
 TString.cxx:2502
 TString.cxx:2503
 TString.cxx:2504
 TString.cxx:2505
 TString.cxx:2506
 TString.cxx:2507
 TString.cxx:2508
 TString.cxx:2509
 TString.cxx:2510
 TString.cxx:2511
 TString.cxx:2512
 TString.cxx:2513
 TString.cxx:2514
 TString.cxx:2515
 TString.cxx:2516
 TString.cxx:2517
 TString.cxx:2518
 TString.cxx:2519
 TString.cxx:2520
 TString.cxx:2521
 TString.cxx:2522
 TString.cxx:2523
 TString.cxx:2524
 TString.cxx:2525
 TString.cxx:2526
 TString.cxx:2527
 TString.cxx:2528
 TString.cxx:2529
 TString.cxx:2530
 TString.cxx:2531
 TString.cxx:2532
 TString.cxx:2533
 TString.cxx:2534
 TString.cxx:2535
 TString.cxx:2536
 TString.cxx:2537
 TString.cxx:2538
 TString.cxx:2539
 TString.cxx:2540
 TString.cxx:2541
 TString.cxx:2542
 TString.cxx:2543
 TString.cxx:2544
 TString.cxx:2545
 TString.cxx:2546
 TString.cxx:2547
 TString.cxx:2548
 TString.cxx:2549
 TString.cxx:2550
 TString.cxx:2551
 TString.cxx:2552
 TString.cxx:2553
 TString.cxx:2554
 TString.cxx:2555
 TString.cxx:2556
 TString.cxx:2557
 TString.cxx:2558
 TString.cxx:2559
 TString.cxx:2560
 TString.cxx:2561
 TString.cxx:2562
 TString.cxx:2563
 TString.cxx:2564
 TString.cxx:2565
 TString.cxx:2566
 TString.cxx:2567
 TString.cxx:2568
 TString.cxx:2569
 TString.cxx:2570
 TString.cxx:2571
 TString.cxx:2572
 TString.cxx:2573
 TString.cxx:2574
 TString.cxx:2575
 TString.cxx:2576
 TString.cxx:2577
 TString.cxx:2578
 TString.cxx:2579
 TString.cxx:2580
 TString.cxx:2581
 TString.cxx:2582
 TString.cxx:2583
 TString.cxx:2584
 TString.cxx:2585
 TString.cxx:2586
 TString.cxx:2587
 TString.cxx:2588
 TString.cxx:2589
 TString.cxx:2590
 TString.cxx:2591
 TString.cxx:2592
 TString.cxx:2593
 TString.cxx:2594
 TString.cxx:2595
 TString.cxx:2596
 TString.cxx:2597
 TString.cxx:2598
 TString.cxx:2599
 TString.cxx:2600
 TString.cxx:2601
 TString.cxx:2602
 TString.cxx:2603
 TString.cxx:2604
 TString.cxx:2605
 TString.cxx:2606
 TString.cxx:2607
 TString.cxx:2608
 TString.cxx:2609
 TString.cxx:2610
 TString.cxx:2611
 TString.cxx:2612
 TString.cxx:2613
 TString.cxx:2614
 TString.cxx:2615
 TString.cxx:2616
 TString.cxx:2617
 TString.cxx:2618
 TString.cxx:2619
 TString.cxx:2620
 TString.cxx:2621
 TString.cxx:2622
 TString.cxx:2623
 TString.cxx:2624