ROOT logo
// @(#)root/unix:$Id$
// Author: Fons Rademakers   15/09/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.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TUnixSystem                                                          //
//                                                                      //
// Class providing an interface to the UNIX Operating System.           //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "RConfigure.h"
#include "RConfig.h"
#include "TUnixSystem.h"
#include "TROOT.h"
#include "TError.h"
#include "TOrdCollection.h"
#include "TRegexp.h"
#include "TPRegexp.h"
#include "TException.h"
#include "Demangle.h"
#include "TEnv.h"
#include "TSocket.h"
#include "Getline.h"
#include "TInterpreter.h"
#include "TApplication.h"
#include "TObjString.h"
#include "Riostream.h"
#include "TVirtualMutex.h"
#include "TObjArray.h"
#include "ThreadLocalStorage.h"
#include <map>
#if __cplusplus >= 201103L
#include <atomic>
#endif

//#define G__OLDEXPAND

#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#if defined(R__SUN) || defined(R__SGI) || defined(R__HPUX) || \
    defined(R__AIX) || defined(R__LINUX) || defined(R__SOLARIS) || \
    defined(R__ALPHA) || defined(R__HIUX) || defined(R__FBSD) || \
    defined(R__OBSD) || defined(R__MACOSX) || defined(R__HURD)
#define HAS_DIRENT
#endif
#ifdef HAS_DIRENT
#   include <dirent.h>
#else
#   include <sys/dir.h>
#endif
#if defined(ULTRIX) || defined(R__SUN)
#   include <sgtty.h>
#endif
#if defined(R__AIX) || defined(R__LINUX) || defined(R__ALPHA) || \
    defined(R__SGI) || defined(R__HIUX) || defined(R__FBSD) || \
    defined(R__OBSD) || defined(R__LYNXOS) || defined(R__MACOSX) || \
    defined(R__HURD)
#   include <sys/ioctl.h>
#endif
#if defined(R__AIX) || defined(R__SOLARIS)
#   include <sys/select.h>
#endif
#if defined(R__LINUX) || defined(R__HURD)
#   ifndef SIGSYS
#      define SIGSYS  SIGUNUSED       // SIGSYS does not exist in linux ??
#   endif
#endif
#if defined(R__ALPHA)
#   include <sys/mount.h>
#   ifndef R__TRUE64
   extern "C" int statfs(const char *file, struct statfs *buffer);
#   endif
#elif defined(R__MACOSX)
#   include <mach-o/dyld.h>
#   include <sys/mount.h>
   extern "C" int statfs(const char *file, struct statfs *buffer);
#elif defined(R__LINUX) || defined(R__HPUX) || defined(R__HURD)
#   include <sys/vfs.h>
#elif defined(R__FBSD) || defined(R__OBSD)
#   include <sys/param.h>
#   include <sys/mount.h>
#else
#   include <sys/statfs.h>
#endif

#include <utime.h>
#include <syslog.h>
#include <sys/stat.h>
#include <setjmp.h>
#include <signal.h>
#include <sys/param.h>
#include <pwd.h>
#include <grp.h>
#include <errno.h>
#include <sys/resource.h>
#include <sys/wait.h>
#include <time.h>
#include <sys/time.h>
#include <sys/file.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#if defined(R__AIX)
#   define _XOPEN_EXTENDED_SOURCE
#   include <arpa/inet.h>
#   undef _XOPEN_EXTENDED_SOURCE
#   if !defined(_AIX41) && !defined(_AIX43)
    // AIX 3.2 doesn't have it
#   define HASNOT_INETATON
#   endif
#else
#   include <arpa/inet.h>
#endif
#include <sys/un.h>
#include <netdb.h>
#include <fcntl.h>
#if defined(R__SGI)
#   include <net/soioctl.h>
#endif
#if defined(R__SOLARIS)
#   include <sys/systeminfo.h>
#   include <sys/filio.h>
#   include <sys/sockio.h>
#   define HASNOT_INETATON
#   ifndef INADDR_NONE
#      define INADDR_NONE (UInt_t)-1
#   endif
#endif
#if defined(R__HPUX)
#   include <symlink.h>
#   include <dl.h>
#   if defined(R__GNU)
   extern "C" {
      extern shl_t cxxshl_load(const char *path, int flags, long address);
      extern int   cxxshl_unload(shl_t handle);
   }
#   elif !defined(__STDCPP__)
#      include <cxxdl.h>
#   endif
#   if defined(hpux9)
   extern "C" {
      extern void openlog(const char *, int, int);
      extern void syslog(int, const char *, ...);
      extern void closelog(void);
      extern int setlogmask(int);
   }
#   define HASNOT_INETATON
#   endif
#endif
#if defined(R__ALPHA) && !defined(R__GNU)
#   define HASNOT_INETATON
#endif
#if defined(R__HIUX)
#   define HASNOT_INETATON
#endif

#if defined(R__SGI) || defined(R__SOLARIS)
#   define HAVE_UTMPX_H
#   define UTMP_NO_ADDR
#endif

#if defined(MAC_OS_X_VERSION_10_5)
#   define HAVE_UTMPX_H
#   define UTMP_NO_ADDR
#   ifndef ut_user
#      define ut_user ut_name
#   endif
#endif

#if defined(R__FBSD)
#   include <sys/param.h>
#   if __FreeBSD_version >= 900007
#      define HAVE_UTMPX_H
#      ifndef ut_user
#        define ut_user ut_name
#      endif
#   endif
#endif

#if defined(R__ALPHA) || defined(R__AIX) || defined(R__FBSD) || \
    defined(R__OBSD) || defined(R__LYNXOS) || \
    (defined(R__MACOSX) && !defined(MAC_OS_X_VERSION_10_5))
#   define UTMP_NO_ADDR
#endif

#if (defined(R__AIX) && !defined(_AIX43)) || \
    (defined(R__SUNGCC3) && !defined(__arch64__))
#   define USE_SIZE_T
#elif defined(R__GLIBC) || defined(R__FBSD) || \
      (defined(R__SUNGCC3) && defined(__arch64__)) || \
      defined(R__OBSD) || defined(MAC_OS_X_VERSION_10_4) || \
      (defined(R__AIX) && defined(_AIX43)) || \
      (defined(R__SOLARIS) && defined(_SOCKLEN_T))
#   define USE_SOCKLEN_T
#endif

#if defined(R__LYNXOS)
extern "C" {
   extern int putenv(const char *);
   extern int inet_aton(const char *, struct in_addr *);
};
#endif

#ifdef HAVE_UTMPX_H
#include <utmpx.h>
#define STRUCT_UTMP struct utmpx
#else
#include <utmp.h>
#define STRUCT_UTMP struct utmp
#endif
#if !defined(UTMP_FILE) && defined(_PATH_UTMP)      // 4.4BSD
#define UTMP_FILE _PATH_UTMP
#endif
#if defined(UTMPX_FILE)                             // Solaris, SysVr4
#undef  UTMP_FILE
#define UTMP_FILE UTMPX_FILE
#endif
#ifndef UTMP_FILE
#define UTMP_FILE "/etc/utmp"
#endif

// stack trace code
#if defined(R__HPUX) && !defined(R__GNU)
#   define HAVE_U_STACK_TRACE
#endif
#if (defined(R__LINUX) || defined(R__HURD)) && !defined(R__WINGCC)
#   if __GLIBC__ == 2 && __GLIBC_MINOR__ >= 1
#      define HAVE_BACKTRACE_SYMBOLS_FD
#   endif
#   define HAVE_DLADDR
#endif
#if defined(R__MACOSX)
#   if defined(MAC_OS_X_VERSION_10_5)
#      define HAVE_BACKTRACE_SYMBOLS_FD
#      define HAVE_DLADDR
#   else
#      define USE_GDB_STACK_TRACE
#   endif
#endif

#ifdef HAVE_U_STACK_TRACE
   // HP-UX stack walker (http://devresource.hp.com/STK/partner/unwind.pdf)
   extern "C" void U_STACK_TRACE(void);
#endif
#ifdef HAVE_BACKTRACE_SYMBOLS_FD
#   include <execinfo.h>
#endif
#ifdef HAVE_DLADDR
#   ifndef __USE_GNU
#      define __USE_GNU
#   endif
#   include <dlfcn.h>
#endif

#ifdef HAVE_BACKTRACE_SYMBOLS_FD
   // The maximum stack trace depth for systems where we request the
   // stack depth separately (currently glibc-based systems).
   static const int kMAX_BACKTRACE_DEPTH = 128;
#endif

// FPE handling includes
#if (defined(R__LINUX) && !defined(R__WINGCC))
#include <fpu_control.h>
#include <fenv.h>
#include <sys/prctl.h>    // for prctl() function used in StackTrace()
#endif

#if defined(R__MACOSX) && defined(__SSE2__)
#include <xmmintrin.h>
#endif

#if defined(R__MACOSX) && !defined(__SSE2__) && !defined(__xlC__) && \
   !defined(__i386__) && !defined(__x86_64__) && !defined(__arm__) && \
   !defined(__arm64__)
#include <fenv.h>
#include <signal.h>
#include <ucontext.h>
#include <stdlib.h>
#include <stdio.h>
#include <mach/thread_status.h>

#define fegetenvd(x) asm volatile("mffs %0" : "=f" (x));
#define fesetenvd(x) asm volatile("mtfsf 255,%0" : : "f" (x));

enum {
  FE_ENABLE_INEXACT    = 0x00000008,
  FE_ENABLE_DIVBYZERO  = 0x00000010,
  FE_ENABLE_UNDERFLOW  = 0x00000020,
  FE_ENABLE_OVERFLOW   = 0x00000040,
  FE_ENABLE_INVALID    = 0x00000080,
  FE_ENABLE_ALL_EXCEPT = 0x000000F8
};
#endif

#if defined(R__MACOSX) && !defined(__SSE2__) && \
    (defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__arm64__))
#include <fenv.h>
#endif
// End FPE handling includes


struct TUtmpContent {
   STRUCT_UTMP *fUtmpContents;
   UInt_t       fEntries; // Number of entries in utmp file.

   TUtmpContent() : fUtmpContents(0), fEntries(0) {}
   ~TUtmpContent() { free(fUtmpContents); }

   STRUCT_UTMP *SearchUtmpEntry(const char *tty)
   {
      // Look for utmp entry which is connected to terminal tty.

      STRUCT_UTMP *ue = fUtmpContents;

      UInt_t n = fEntries;
      while (n--) {
         if (ue->ut_name[0] && !strncmp(tty, ue->ut_line, sizeof(ue->ut_line)))
            return ue;
         ue++;
      }
      return 0;
   }

   int ReadUtmpFile()
   {
      // Read utmp file. Returns number of entries in utmp file.

      FILE  *utmp;
      struct stat file_stats;
      size_t n_read, size;

      fEntries = 0;

      R__LOCKGUARD2(gSystemMutex);

      utmp = fopen(UTMP_FILE, "r");
      if (!utmp)
         return 0;

      if (fstat(fileno(utmp), &file_stats) == -1) {
         fclose(utmp);
         return 0;
      }
      size = file_stats.st_size;
      if (size <= 0) {
         fclose(utmp);
         return 0;
      }

      fUtmpContents = (STRUCT_UTMP *) malloc(size);
      if (!fUtmpContents) {
         fclose(utmp);
         return 0;
      }

      n_read = fread(fUtmpContents, 1, size, utmp);
      if (!ferror(utmp)) {
         if (fclose(utmp) != EOF && n_read == size) {
            fEntries = size / sizeof(STRUCT_UTMP);
            return fEntries;
         }
      } else
         fclose(utmp);

      free(fUtmpContents);
      fUtmpContents = 0;
      return 0;
   }

};

const char *kServerPath     = "/tmp";
const char *kProtocolName   = "tcp";

//------------------- Unix TFdSet ----------------------------------------------
#ifndef HOWMANY
#   define HOWMANY(x, y)   (((x)+((y)-1))/(y))
#endif

const Int_t kNFDBITS = (sizeof(Long_t) * 8);  // 8 bits per byte
#ifdef FD_SETSIZE
const Int_t kFDSETSIZE = FD_SETSIZE;          // Linux = 1024 file descriptors
#else
const Int_t kFDSETSIZE = 256;                 // upto 256 file descriptors
#endif


class TFdSet {
private:
   ULong_t fds_bits[HOWMANY(kFDSETSIZE, kNFDBITS)];
public:
   TFdSet() { memset(fds_bits, 0, sizeof(fds_bits)); }
   TFdSet(const TFdSet &org) { memcpy(fds_bits, org.fds_bits, sizeof(org.fds_bits)); }
   TFdSet &operator=(const TFdSet &rhs) { if (this != &rhs) { memcpy(fds_bits, rhs.fds_bits, sizeof(rhs.fds_bits));} return *this; }
   void   Zero() { memset(fds_bits, 0, sizeof(fds_bits)); }
   void   Set(Int_t n)
   {
      if (n >= 0 && n < kFDSETSIZE) {
         fds_bits[n/kNFDBITS] |= (1UL << (n % kNFDBITS));
      } else {
         ::Fatal("TFdSet::Set","fd (%d) out of range [0..%d]", n, kFDSETSIZE-1);
      }
   }
   void   Clr(Int_t n)
   {
      if (n >= 0 && n < kFDSETSIZE) {
         fds_bits[n/kNFDBITS] &= ~(1UL << (n % kNFDBITS));
      } else {
         ::Fatal("TFdSet::Clr","fd (%d) out of range [0..%d]", n, kFDSETSIZE-1);
      }
   }
   Int_t  IsSet(Int_t n)
   {
      if (n >= 0 && n < kFDSETSIZE) {
         return (fds_bits[n/kNFDBITS] & (1UL << (n % kNFDBITS))) != 0;
      } else {
         ::Fatal("TFdSet::IsSet","fd (%d) out of range [0..%d]", n, kFDSETSIZE-1);
         return 0;
      }
   }
   ULong_t *GetBits() { return (ULong_t *)fds_bits; }
};

//______________________________________________________________________________
static void SigHandler(ESignals sig)
{
   // Unix signal handler.

   if (gSystem)
      ((TUnixSystem*)gSystem)->DispatchSignals(sig);
}

//______________________________________________________________________________
static const char *GetExePath()
{
#ifdef R__HAS_THREAD_LOCAL
   thread_local TString exepath;
#else
   TString &exepath( TTHREAD_TLS_INIT<3 /* must be unique */, TString>() );
#endif
   if (exepath == "") {
#if defined(R__MACOSX)
      exepath = _dyld_get_image_name(0);
#elif defined(R__LINUX) || defined(R__SOLARIS) || defined(R__FBSD)
      char buf[kMAXPATHLEN];  // exe path name

      // get the name from the link in /proc
#if defined(R__LINUX)
      int ret = readlink("/proc/self/exe", buf, kMAXPATHLEN);
#elif defined(R__SOLARIS)
      int ret = readlink("/proc/self/path/a.out", buf, kMAXPATHLEN);
#elif defined(R__FBSD)
      int ret = readlink("/proc/curproc/file", buf, kMAXPATHLEN);
#endif
      if (ret > 0 && ret < kMAXPATHLEN) {
         buf[ret] = 0;
         exepath = buf;
      }
#else
      if (!gApplication)
         return exepath;
      TString p = gApplication->Argv(0);
      if (p.BeginsWith("/"))
         exepath = p;
      else if (p.Contains("/")) {
         exepath = gSystem->WorkingDirectory();
         exepath += "/";
         exepath += p;
      } else {
         char *exe = gSystem->Which(gSystem->Getenv("PATH"), p, kExecutePermission);
         if (exe) {
            exepath = exe;
            delete [] exe;
         }
      }
#endif
   }
   return exepath;
}

#if defined(HAVE_DLADDR) && !defined(R__MACOSX)
//______________________________________________________________________________
static void SetRootSys()
{
#ifndef ROOTPREFIX
   void *addr = (void *)SetRootSys;
   Dl_info info;
   if (dladdr(addr, &info) && info.dli_fname && info.dli_fname[0]) {
      char respath[kMAXPATHLEN];
      if (!realpath(info.dli_fname, respath)) {
         if (!gSystem->Getenv("ROOTSYS"))
            ::SysError("TUnixSystem::SetRootSys", "error getting realpath of libCore, please set ROOTSYS in the shell");
      } else {
         TString rs = gSystem->DirName(respath);
         gSystem->Setenv("ROOTSYS", gSystem->DirName(rs));
      }
   }
#else
   return;
#endif
}
#endif

#if defined(R__MACOSX)
static TString gLinkedDylibs;

//______________________________________________________________________________
static void DylibAdded(const struct mach_header *mh, intptr_t /* vmaddr_slide */)
{
   static int i = 0;
   static Bool_t gotFirstSo = kFALSE;
   static TString linkedDylibs;

   // to copy the local linkedDylibs to the global gLinkedDylibs call this
   // function with mh==0
   if (!mh) {
      gLinkedDylibs = linkedDylibs;
      return;
   }

   TString lib = _dyld_get_image_name(i++);

   TRegexp sovers = "libCore\\.[0-9]+\\.*[0-9]*\\.so";
   TRegexp dyvers = "libCore\\.[0-9]+\\.*[0-9]*\\.dylib";

#ifndef ROOTPREFIX
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
   // first loaded is the app so set ROOTSYS to app bundle
   if (i == 1) {
      char respath[kMAXPATHLEN];
      if (!realpath(lib, respath)) {
         if (!gSystem->Getenv("ROOTSYS"))
            ::SysError("TUnixSystem::DylibAdded", "error getting realpath of %s", gSystem->BaseName(lib));
      } else {
         TString rs = gSystem->DirName(respath);
         gSystem->Setenv("ROOTSYS", rs);
      }
   }
#else
   if (lib.EndsWith("libCore.dylib") || lib.EndsWith("libCore.so") ||
       lib.Index(sovers) != kNPOS    || lib.Index(dyvers) != kNPOS) {
      char respath[kMAXPATHLEN];
      if (!realpath(lib, respath)) {
         if (!gSystem->Getenv("ROOTSYS"))
            ::SysError("TUnixSystem::DylibAdded", "error getting realpath of libCore, please set ROOTSYS in the shell");
      } else {
         TString rs = gSystem->DirName(respath);
         gSystem->Setenv("ROOTSYS", gSystem->DirName(rs));
      }
   }
#endif
#endif

   // when libSystem.B.dylib is loaded we have finished loading all dylibs
   // explicitly linked against the executable. Additional dylibs
   // come when they are explicitly linked against loaded so's, currently
   // we are not interested in these
   if (lib.EndsWith("/libSystem.B.dylib"))
      gotFirstSo = kTRUE;

   // add all libs loaded before libSystem.B.dylib
   if (!gotFirstSo && (lib.EndsWith(".dylib") || lib.EndsWith(".so"))) {
      sovers = "\\.[0-9]+\\.*[0-9]*\\.so";
      Ssiz_t idx = lib.Index(sovers);
      if (idx != kNPOS) {
         lib.Remove(idx);
         lib += ".so";
      }
      dyvers = "\\.[0-9]+\\.*[0-9]*\\.dylib";
      idx = lib.Index(dyvers);
      if (idx != kNPOS) {
         lib.Remove(idx);
         lib += ".dylib";
      }
      if (!gSystem->AccessPathName(lib, kReadPermission)) {
         if (linkedDylibs.Length())
            linkedDylibs += " ";
         linkedDylibs += lib;
      }
   }
}
#endif

ClassImp(TUnixSystem)

//______________________________________________________________________________
TUnixSystem::TUnixSystem() : TSystem("Unix", "Unix System")
{ }

//______________________________________________________________________________
TUnixSystem::~TUnixSystem()
{
   // Reset to original state.

   UnixResetSignals();

   delete fReadmask;
   delete fWritemask;
   delete fReadready;
   delete fWriteready;
   delete fSignals;
}

//______________________________________________________________________________
Bool_t TUnixSystem::Init()
{
   // Initialize Unix system interface.

   if (TSystem::Init())
      return kTRUE;

   fReadmask   = new TFdSet;
   fWritemask  = new TFdSet;
   fReadready  = new TFdSet;
   fWriteready = new TFdSet;
   fSignals    = new TFdSet;

   //--- install default handlers
   UnixSignal(kSigChild,                 SigHandler);
   UnixSignal(kSigBus,                   SigHandler);
   UnixSignal(kSigSegmentationViolation, SigHandler);
   UnixSignal(kSigIllegalInstruction,    SigHandler);
   UnixSignal(kSigSystem,                SigHandler);
   UnixSignal(kSigPipe,                  SigHandler);
   UnixSignal(kSigAlarm,                 SigHandler);
   UnixSignal(kSigUrgent,                SigHandler);
   UnixSignal(kSigFloatingException,     SigHandler);
   UnixSignal(kSigWindowChanged,         SigHandler);

#if defined(R__MACOSX)
   // trap loading of all dylibs to register dylib name,
   // sets also ROOTSYS if built without ROOTPREFIX
   _dyld_register_func_for_add_image(DylibAdded);
#elif defined(HAVE_DLADDR)
   SetRootSys();
#endif

#ifndef ROOTPREFIX
   gRootDir = Getenv("ROOTSYS");
   if (gRootDir == 0)
      gRootDir= "/usr/local/root";
#else
   gRootDir = ROOTPREFIX;
#endif

   return kFALSE;
}

//---- Misc --------------------------------------------------------------------

//______________________________________________________________________________
void TUnixSystem::SetProgname(const char *name)
{
   // Set the application name (from command line, argv[0]) and copy it in
   // gProgName. Copy the application pathname in gProgPath.
   // If name is 0 let the system set the actual executable name and path
   // (works on MacOS X and Linux).

   if (gProgName)
      delete [] gProgName;
   if (gProgPath)
      delete [] gProgPath;

   if (!name || !*name) {
      name = GetExePath();
      gProgName = StrDup(BaseName(name));
      gProgPath = StrDup(DirName(name));
   } else {
      gProgName = StrDup(BaseName(name));
      char *w   = Which(Getenv("PATH"), gProgName);
      gProgPath = StrDup(DirName(w));
      delete [] w;
   }
}

//______________________________________________________________________________
void TUnixSystem::SetDisplay()
{
   // Set DISPLAY environment variable based on utmp entry. Only for UNIX.

   if (!Getenv("DISPLAY")) {
      char *tty = ::ttyname(0);  // device user is logged in on
      if (tty) {
         tty += 5;               // remove "/dev/"

         TUtmpContent utmp;
         utmp.ReadUtmpFile();

         STRUCT_UTMP *utmp_entry = utmp.SearchUtmpEntry(tty);
         if (utmp_entry) {
            if (utmp_entry->ut_host[0]) {
               if (strchr(utmp_entry->ut_host, ':')) {
                  Setenv("DISPLAY", utmp_entry->ut_host);
                  Warning("SetDisplay", "DISPLAY not set, setting it to %s",
                          utmp_entry->ut_host);
               } else {
                  char disp[64];
                  snprintf(disp, sizeof(disp), "%s:0.0", utmp_entry->ut_host);
                  Setenv("DISPLAY", disp);
                  Warning("SetDisplay", "DISPLAY not set, setting it to %s",
                          disp);
               }
            }
#ifndef UTMP_NO_ADDR
            else if (utmp_entry->ut_addr) {
               struct hostent *he;
               if ((he = gethostbyaddr((const char*)&utmp_entry->ut_addr,
                                       sizeof(utmp_entry->ut_addr), AF_INET))) {
                  char disp[64];
                  snprintf(disp, sizeof(disp), "%s:0.0", he->h_name);
                  Setenv("DISPLAY", disp);
                  Warning("SetDisplay", "DISPLAY not set, setting it to %s",
                          disp);
               }
            }
#endif
         }
      }
   }
}

//______________________________________________________________________________
const char *TUnixSystem::GetError()
{
   // Return system error string.

   Int_t err = GetErrno();
   if (err == 0 && GetLastErrorString() != "")
      return GetLastErrorString();

#if defined(R__SOLARIS) || defined (R__LINUX) || defined(R__AIX) || \
    defined(R__FBSD) || defined(R__OBSD) || defined(R__HURD)
   return strerror(err);
#else
   if (err < 0 || err >= sys_nerr)
      return Form("errno out of range %d", err);
   return sys_errlist[err];
#endif
}

//______________________________________________________________________________
const char *TUnixSystem::HostName()
{
   // Return the system's host name.

   if (fHostname == "") {
      char hn[64];
#if defined(R__SOLARIS)
      sysinfo(SI_HOSTNAME, hn, sizeof(hn));
#else
      gethostname(hn, sizeof(hn));
#endif
      fHostname = hn;
   }
   return (const char *)fHostname;
}

//---- EventLoop ---------------------------------------------------------------

//______________________________________________________________________________
void TUnixSystem::AddFileHandler(TFileHandler *h)
{
   // Add a file handler to the list of system file handlers. Only adds
   // the handler if it is not already in the list of file handlers.

   R__LOCKGUARD2(gSystemMutex);

   TSystem::AddFileHandler(h);
   if (h) {
      int fd = h->GetFd();
      if (h->HasReadInterest()) {
         fReadmask->Set(fd);
         fMaxrfd = TMath::Max(fMaxrfd, fd);
      }
      if (h->HasWriteInterest()) {
         fWritemask->Set(fd);
         fMaxwfd = TMath::Max(fMaxwfd, fd);
      }
   }
}

//______________________________________________________________________________
TFileHandler *TUnixSystem::RemoveFileHandler(TFileHandler *h)
{
   // Remove a file handler from the list of file handlers. Returns
   // the handler or 0 if the handler was not in the list of file handlers.

   if (!h) return 0;

   R__LOCKGUARD2(gSystemMutex);

   TFileHandler *oh = TSystem::RemoveFileHandler(h);
   if (oh) {       // found
      TFileHandler *th;
      TIter next(fFileHandler);
      fMaxrfd = -1;
      fMaxwfd = -1;
      fReadmask->Zero();
      fWritemask->Zero();
      while ((th = (TFileHandler *) next())) {
         int fd = th->GetFd();
         if (th->HasReadInterest()) {
            fReadmask->Set(fd);
            fMaxrfd = TMath::Max(fMaxrfd, fd);
         }
         if (th->HasWriteInterest()) {
            fWritemask->Set(fd);
            fMaxwfd = TMath::Max(fMaxwfd, fd);
         }
      }
   }
   return oh;
}

//______________________________________________________________________________
void TUnixSystem::AddSignalHandler(TSignalHandler *h)
{
   // Add a signal handler to list of system signal handlers. Only adds
   // the handler if it is not already in the list of signal handlers.

   R__LOCKGUARD2(gSystemMutex);

   TSystem::AddSignalHandler(h);
   UnixSignal(h->GetSignal(), SigHandler);
}

//______________________________________________________________________________
TSignalHandler *TUnixSystem::RemoveSignalHandler(TSignalHandler *h)
{
   // Remove a signal handler from list of signal handlers. Returns
   // the handler or 0 if the handler was not in the list of signal handlers.

   if (!h) return 0;

   R__LOCKGUARD2(gSystemMutex);

   TSignalHandler *oh = TSystem::RemoveSignalHandler(h);

   Bool_t last = kTRUE;
   TSignalHandler *hs;
   TIter next(fSignalHandler);

   while ((hs = (TSignalHandler*) next())) {
      if (hs->GetSignal() == h->GetSignal())
         last = kFALSE;
   }
   if (last)
      ResetSignal(h->GetSignal(), kTRUE);

   return oh;
}

//______________________________________________________________________________
void TUnixSystem::ResetSignal(ESignals sig, Bool_t reset)
{
   // If reset is true reset the signal handler for the specified signal
   // to the default handler, else restore previous behaviour.

   if (reset)
      UnixResetSignal(sig);
   else
      UnixSignal(sig, SigHandler);
}

//______________________________________________________________________________
void TUnixSystem::ResetSignals()
{
   // Reset signals handlers to previous behaviour.

   UnixResetSignals();
}

//______________________________________________________________________________
void TUnixSystem::IgnoreSignal(ESignals sig, Bool_t ignr)
{
   // If ignr is true ignore the specified signal, else restore previous
   // behaviour.

   UnixIgnoreSignal(sig, ignr);
}

//______________________________________________________________________________
void TUnixSystem::SigAlarmInterruptsSyscalls(Bool_t set)
{
   // When the argument is true the SIGALRM signal handler is set so that
   // interrupted syscalls will not be restarted by the kernel. This is
   // typically used in case one wants to put a timeout on an I/O operation.
   // By default interrupted syscalls will always be restarted (for all
   // signals). This can be controlled for each a-synchronous TTimer via
   // the method TTimer::SetInterruptSyscalls().

   UnixSigAlarmInterruptsSyscalls(set);
}

//______________________________________________________________________________
Int_t TUnixSystem::GetFPEMask()
{
   // Return the bitmap of conditions that trigger a floating point exception.

   Int_t mask = 0;

#if defined(R__LINUX) && !defined(__powerpc__)
#if defined(__GLIBC__) && (__GLIBC__>2 || __GLIBC__==2 && __GLIBC_MINOR__>=1)

#if __GLIBC_MINOR__>=3

   Int_t oldmask = fegetexcept();

#else
   fenv_t oldenv;
   fegetenv(&oldenv);
   fesetenv(&oldenv);
#ifdef __alpha__
   ULong_t oldmask = ~oldenv;
#elif __ia64__
   Int_t oldmask = ~oldenv;
#else
   Int_t oldmask = ~oldenv.__control_word;
#endif
#endif

   if (oldmask & FE_INVALID  )   mask |= kInvalid;
   if (oldmask & FE_DIVBYZERO)   mask |= kDivByZero;
   if (oldmask & FE_OVERFLOW )   mask |= kOverflow;
   if (oldmask & FE_UNDERFLOW)   mask |= kUnderflow;
# ifdef FE_INEXACT
   if (oldmask & FE_INEXACT  )   mask |= kInexact;
# endif
#endif
#endif

#if defined(R__MACOSX) && defined(__SSE2__)
   // OS X uses the SSE unit for all FP math by default, not the x87 FP unit
   Int_t oldmask = ~_MM_GET_EXCEPTION_MASK();

   if (oldmask & _MM_MASK_INVALID  )   mask |= kInvalid;
   if (oldmask & _MM_MASK_DIV_ZERO )   mask |= kDivByZero;
   if (oldmask & _MM_MASK_OVERFLOW )   mask |= kOverflow;
   if (oldmask & _MM_MASK_UNDERFLOW)   mask |= kUnderflow;
   if (oldmask & _MM_MASK_INEXACT  )   mask |= kInexact;
#endif

#if defined(R__MACOSX) && !defined(__SSE2__) && \
    (defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__arm64__))
   fenv_t oldenv;
   fegetenv(&oldenv);
   fesetenv(&oldenv);
#if defined(__arm__)
   Int_t oldmask = ~oldenv.__fpscr;
#elif defined(__arm64__)
   Int_t oldmask = ~oldenv.__fpcr;
#else
   Int_t oldmask = ~oldenv.__control;
#endif

   if (oldmask & FE_INVALID  )   mask |= kInvalid;
   if (oldmask & FE_DIVBYZERO)   mask |= kDivByZero;
   if (oldmask & FE_OVERFLOW )   mask |= kOverflow;
   if (oldmask & FE_UNDERFLOW)   mask |= kUnderflow;
   if (oldmask & FE_INEXACT  )   mask |= kInexact;
#endif

#if defined(R__MACOSX) && !defined(__SSE2__) && !defined(__xlC__) && \
    !defined(__i386__) && !defined(__x86_64__) && !defined(__arm__) && \
    !defined(__arm64__)
   Long64_t oldmask;
   fegetenvd(oldmask);

   if (oldmask & FE_ENABLE_INVALID  )   mask |= kInvalid;
   if (oldmask & FE_ENABLE_DIVBYZERO)   mask |= kDivByZero;
   if (oldmask & FE_ENABLE_OVERFLOW )   mask |= kOverflow;
   if (oldmask & FE_ENABLE_UNDERFLOW)   mask |= kUnderflow;
   if (oldmask & FE_ENABLE_INEXACT  )   mask |= kInexact;
#endif

   return mask;
}

//______________________________________________________________________________
Int_t TUnixSystem::SetFPEMask(Int_t mask)
{
   // Set which conditions trigger a floating point exception.
   // Return the previous set of conditions.

   if (mask) { }  // use mask to avoid warning

   Int_t old = GetFPEMask();

#if defined(R__LINUX) && !defined(__powerpc__)
#if defined(__GLIBC__) && (__GLIBC__>2 || __GLIBC__==2 && __GLIBC_MINOR__>=1)
   Int_t newm = 0;
   if (mask & kInvalid  )   newm |= FE_INVALID;
   if (mask & kDivByZero)   newm |= FE_DIVBYZERO;
   if (mask & kOverflow )   newm |= FE_OVERFLOW;
   if (mask & kUnderflow)   newm |= FE_UNDERFLOW;
# ifdef FE_INEXACT
   if (mask & kInexact  )   newm |= FE_INEXACT;
# endif

#if __GLIBC_MINOR__>=3

   // clear pending exceptions so feenableexcept does not trigger them
   feclearexcept(FE_ALL_EXCEPT);
   fedisableexcept(FE_ALL_EXCEPT);
   feenableexcept(newm);

#else

   fenv_t cur;
   fegetenv(&cur);
#if defined __ia64__ || defined __alpha__
   cur &= ~newm;
#else
   cur.__control_word &= ~newm;
#endif
   fesetenv(&cur);

#endif
#endif
#endif

#if defined(R__MACOSX) && defined(__SSE2__)
   // OS X uses the SSE unit for all FP math by default, not the x87 FP unit
   Int_t newm = 0;
   if (mask & kInvalid  )   newm |= _MM_MASK_INVALID;
   if (mask & kDivByZero)   newm |= _MM_MASK_DIV_ZERO;
   if (mask & kOverflow )   newm |= _MM_MASK_OVERFLOW;
   if (mask & kUnderflow)   newm |= _MM_MASK_UNDERFLOW;
   if (mask & kInexact  )   newm |= _MM_MASK_INEXACT;

   _MM_SET_EXCEPTION_MASK(_MM_GET_EXCEPTION_MASK() & ~newm);
#endif

#if defined(R__MACOSX) && !defined(__SSE2__) && \
    (defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__arm64__))
   Int_t newm = 0;
   if (mask & kInvalid  )   newm |= FE_INVALID;
   if (mask & kDivByZero)   newm |= FE_DIVBYZERO;
   if (mask & kOverflow )   newm |= FE_OVERFLOW;
   if (mask & kUnderflow)   newm |= FE_UNDERFLOW;
   if (mask & kInexact  )   newm |= FE_INEXACT;

   fenv_t cur;
   fegetenv(&cur);
#if defined(__arm__)
   cur.__fpscr &= ~newm;
#elif defined(__arm64__)
   cur.__fpcr &= ~newm;
#else
   cur.__control &= ~newm;
#endif
   fesetenv(&cur);
#endif

#if defined(R__MACOSX) && !defined(__SSE2__) && !defined(__xlC__) && \
    !defined(__i386__) && !defined(__x86_64__) && !defined(__arm__) && \
    !defined(__arm64__)
   Int_t newm = 0;
   if (mask & kInvalid  )   newm |= FE_ENABLE_INVALID;
   if (mask & kDivByZero)   newm |= FE_ENABLE_DIVBYZERO;
   if (mask & kOverflow )   newm |= FE_ENABLE_OVERFLOW;
   if (mask & kUnderflow)   newm |= FE_ENABLE_UNDERFLOW;
   if (mask & kInexact  )   newm |= FE_ENABLE_INEXACT;

   Long64_t curmask;
   fegetenvd(curmask);
   curmask = (curmask & ~FE_ENABLE_ALL_EXCEPT) | newm;
   fesetenvd(curmask);
#endif

   return old;
}

//______________________________________________________________________________
void TUnixSystem::DispatchOneEvent(Bool_t pendingOnly)
{
   // Dispatch a single event.

   Bool_t pollOnce = pendingOnly;

   while (1) {
      // first handle any X11 events
      if (gXDisplay && gXDisplay->Notify()) {
         if (fReadready->IsSet(gXDisplay->GetFd())) {
            fReadready->Clr(gXDisplay->GetFd());
            fNfd--;
         }
         if (!pendingOnly) return;
      }

      // check for file descriptors ready for reading/writing
      if (fNfd > 0 && fFileHandler && fFileHandler->GetSize() > 0)
         if (CheckDescriptors())
            if (!pendingOnly) return;
      fNfd = 0;
      fReadready->Zero();
      fWriteready->Zero();

      if (pendingOnly && !pollOnce)
         return;

      // check synchronous signals
      if (fSigcnt > 0 && fSignalHandler->GetSize() > 0)
         if (CheckSignals(kTRUE))
            if (!pendingOnly) return;
      fSigcnt = 0;
      fSignals->Zero();

      // check synchronous timers
      Long_t nextto;
      if (fTimers && fTimers->GetSize() > 0)
         if (DispatchTimers(kTRUE)) {
            // prevent timers from blocking file descriptor monitoring
            nextto = NextTimeOut(kTRUE);
            if (nextto > kItimerResolution || nextto == -1)
               return;
         }

      // if in pendingOnly mode poll once file descriptor activity
      nextto = NextTimeOut(kTRUE);
      if (pendingOnly) {
         if (fFileHandler && fFileHandler->GetSize() == 0)
            return;
         nextto = 0;
         pollOnce = kFALSE;
      }

      // nothing ready, so setup select call
      *fReadready  = *fReadmask;
      *fWriteready = *fWritemask;

      int mxfd = TMath::Max(fMaxrfd, fMaxwfd);
      mxfd++;

      // if nothing to select (socket or timer) return
      if (mxfd == 0 && nextto == -1)
         return;

      fNfd = UnixSelect(mxfd, fReadready, fWriteready, nextto);
      if (fNfd < 0 && fNfd != -2) {
         int fd, rc;
         TFdSet t;
         for (fd = 0; fd < mxfd; fd++) {
            t.Set(fd);
            if (fReadmask->IsSet(fd)) {
               rc = UnixSelect(fd+1, &t, 0, 0);
               if (rc < 0 && rc != -2) {
                  SysError("DispatchOneEvent", "select: read error on %d", fd);
                  fReadmask->Clr(fd);
               }
            }
            if (fWritemask->IsSet(fd)) {
               rc = UnixSelect(fd+1, 0, &t, 0);
               if (rc < 0 && rc != -2) {
                  SysError("DispatchOneEvent", "select: write error on %d", fd);
                  fWritemask->Clr(fd);
               }
            }
            t.Clr(fd);
         }
      }
   }
}

//______________________________________________________________________________
void TUnixSystem::Sleep(UInt_t milliSec)
{
   // Sleep milliSec milliseconds.

   struct timeval tv;

   tv.tv_sec  = milliSec / 1000;
   tv.tv_usec = (milliSec % 1000) * 1000;

   select(0, 0, 0, 0, &tv);
}

//______________________________________________________________________________
Int_t TUnixSystem::Select(TList *act, Long_t to)
{
   // Select on file descriptors. The timeout to is in millisec. Returns
   // the number of ready descriptors, or 0 in case of timeout, or < 0 in
   // case of an error, with -2 being EINTR and -3 EBADF. In case of EINTR
   // the errno has been reset and the method can be called again. Returns
   // -4 in case the list did not contain any file handlers or file handlers
   // with file descriptor >= 0.

   Int_t rc = -4;

   TFdSet rd, wr;
   Int_t mxfd = -1;
   TIter next(act);
   TFileHandler *h = 0;
   while ((h = (TFileHandler *) next())) {
      Int_t fd = h->GetFd();
      if (fd > -1) {
         if (h->HasReadInterest()) {
            rd.Set(fd);
            mxfd = TMath::Max(mxfd, fd);
         }
         if (h->HasWriteInterest()) {
            wr.Set(fd);
            mxfd = TMath::Max(mxfd, fd);
         }
         h->ResetReadyMask();
      }
   }
   if (mxfd > -1)
      rc = UnixSelect(mxfd+1, &rd, &wr, to);

   // Set readiness bits
   if (rc > 0) {
      next.Reset();
      while ((h = (TFileHandler *) next())) {
         Int_t fd = h->GetFd();
         if (rd.IsSet(fd))
            h->SetReadReady();
         if (wr.IsSet(fd))
            h->SetWriteReady();
      }
   }

   return rc;
}

//______________________________________________________________________________
Int_t TUnixSystem::Select(TFileHandler *h, Long_t to)
{
   // Select on the file descriptor related to file handler h.
   // The timeout to is in millisec. Returns the number of ready descriptors,
   // or 0 in case of timeout, or < 0 in case of an error, with -2 being EINTR
   // and -3 EBADF. In case of EINTR the errno has been reset and the method
   // can be called again. Returns -4 in case the file handler is 0 or does
   // not have a file descriptor >= 0.

   Int_t rc = -4;

   TFdSet rd, wr;
   Int_t mxfd = -1;
   Int_t fd = -1;
   if (h) {
      fd = h->GetFd();
      if (fd > -1) {
         if (h->HasReadInterest())
            rd.Set(fd);
         if (h->HasWriteInterest())
            wr.Set(fd);
         h->ResetReadyMask();
         mxfd = fd;
         rc = UnixSelect(mxfd+1, &rd, &wr, to);
      }
   }

   // Fill output lists, if required
   if (rc > 0) {
      if (rd.IsSet(fd))
         h->SetReadReady();
      if (wr.IsSet(fd))
         h->SetWriteReady();
   }

   return rc;
}

//---- handling of system events -----------------------------------------------

//______________________________________________________________________________
void TUnixSystem::DispatchSignals(ESignals sig)
{
   // Handle and dispatch signals.

   switch (sig) {
   case kSigAlarm:
      DispatchTimers(kFALSE);
      break;
   case kSigChild:
      CheckChilds();
      break;
   case kSigBus:
   case kSigSegmentationViolation:
   case kSigIllegalInstruction:
   case kSigFloatingException:
      Break("TUnixSystem::DispatchSignals", "%s", UnixSigname(sig));
      StackTrace();
      if (gApplication)
         gApplication->HandleException(sig);
      else
         Exit(sig);
      break;
   case kSigSystem:
   case kSigPipe:
      Break("TUnixSystem::DispatchSignals", "%s", UnixSigname(sig));
      break;
   case kSigWindowChanged:
      Gl_windowchanged();
      break;
   default:
      fSignals->Set(sig);
      fSigcnt++;
      break;
   }

   // check a-synchronous signals
   if (fSigcnt > 0 && fSignalHandler->GetSize() > 0)
      CheckSignals(kFALSE);
}

//______________________________________________________________________________
Bool_t TUnixSystem::CheckSignals(Bool_t sync)
{
   // Check if some signals were raised and call their Notify() member.

   TSignalHandler *sh;
   Int_t sigdone = -1;
   {
      TOrdCollectionIter it((TOrdCollection*)fSignalHandler);

      while ((sh = (TSignalHandler*)it.Next())) {
         if (sync == sh->IsSync()) {
            ESignals sig = sh->GetSignal();
            if ((fSignals->IsSet(sig) && sigdone == -1) || sigdone == sig) {
               if (sigdone == -1) {
                  fSignals->Clr(sig);
                  sigdone = sig;
                  fSigcnt--;
               }
               if (sh->IsActive())
                  sh->Notify();
            }
         }
      }
   }
   if (sigdone != -1)
      return kTRUE;

   return kFALSE;
}

//______________________________________________________________________________
void TUnixSystem::CheckChilds()
{
   // Check if children have finished.

#if 0  //rdm
   int pid;
   while ((pid = UnixWaitchild()) > 0) {
      TIter next(zombieHandler);
      register UnixPtty *pty;
      while ((pty = (UnixPtty*) next()))
         if (pty->GetPid() == pid) {
            zombieHandler->RemovePtr(pty);
            pty->DiedNotify();
         }
   }
#endif
}

//______________________________________________________________________________
Bool_t TUnixSystem::CheckDescriptors()
{
   // Check if there is activity on some file descriptors and call their
   // Notify() member.

   TFileHandler *fh;
   Int_t  fddone = -1;
   Bool_t read   = kFALSE;
#if defined(R__LINUX) && defined(__alpha__)
   // TOrdCollectionIter it(...) causes segv ?!?!? Also TIter fails.
   Int_t cursor = 0;
   while (cursor < fFileHandler->GetSize()) {
      fh = (TFileHandler*) fFileHandler->At(cursor++);
#else
   TOrdCollectionIter it((TOrdCollection*)fFileHandler);
   while ((fh = (TFileHandler*) it.Next())) {
#endif
      Int_t fd = fh->GetFd();
      if ((fd <= fMaxrfd && fReadready->IsSet(fd) && fddone == -1) ||
          (fddone == fd && read)) {
         if (fddone == -1) {
            fReadready->Clr(fd);
            fddone = fd;
            read = kTRUE;
            fNfd--;
         }
         if (fh->IsActive())
            fh->ReadNotify();
      }
      if ((fd <= fMaxwfd && fWriteready->IsSet(fd) && fddone == -1) ||
          (fddone == fd && !read)) {
         if (fddone == -1) {
            fWriteready->Clr(fd);
            fddone = fd;
            read = kFALSE;
            fNfd--;
         }
         if (fh->IsActive())
            fh->WriteNotify();
      }
   }
   if (fddone != -1)
      return kTRUE;

   return kFALSE;
}

//---- Directories -------------------------------------------------------------

//______________________________________________________________________________
int TUnixSystem::MakeDirectory(const char *name)
{
   // Make a Unix file system directory. Returns 0 in case of success and
   // -1 if the directory could not be created.

   TSystem *helper = FindHelper(name);
   if (helper)
      return helper->MakeDirectory(name);

   return UnixMakedir(name);
}

//______________________________________________________________________________
void *TUnixSystem::OpenDirectory(const char *name)
{
   // Open a Unix file system directory. Returns 0 if directory does not exist.

   TSystem *helper = FindHelper(name);
   if (helper)
      return helper->OpenDirectory(name);

   return UnixOpendir(name);
}

//______________________________________________________________________________
void TUnixSystem::FreeDirectory(void *dirp)
{
   // Close a Unix file system directory.

   TSystem *helper = FindHelper(0, dirp);
   if (helper) {
      helper->FreeDirectory(dirp);
      return;
   }

   if (dirp)
      ::closedir((DIR*)dirp);
}

//______________________________________________________________________________
const char *TUnixSystem::GetDirEntry(void *dirp)
{
   // Get next Unix file system directory entry. Returns 0 if no more entries.

   TSystem *helper = FindHelper(0, dirp);
   if (helper)
      return helper->GetDirEntry(dirp);

   if (dirp)
      return UnixGetdirentry(dirp);

   return 0;
}

//______________________________________________________________________________
Bool_t TUnixSystem::ChangeDirectory(const char *path)
{
   // Change directory. Returns kTRUE in case of success, kFALSE otherwise.

   Bool_t ret = (Bool_t) (::chdir(path) == 0);
   if (fWdpath != "")
      fWdpath = "";   // invalidate path cache
   return ret;
}

//______________________________________________________________________________
const char *TUnixSystem::WorkingDirectory()
{
   // Return working directory.

   // don't use cache as user can call chdir() directly somewhere else
   //if (fWdpath != "")
   //   return fWdpath.Data();

   R__LOCKGUARD2(gSystemMutex);

   static char cwd[kMAXPATHLEN];
   if (::getcwd(cwd, kMAXPATHLEN) == 0) {
      fWdpath = "/";
      Error("WorkingDirectory", "getcwd() failed");
   }
   fWdpath = cwd;
   return fWdpath.Data();
}

//______________________________________________________________________________
const char *TUnixSystem::HomeDirectory(const char *userName)
{
   // Return the user's home directory.

   return UnixHomedirectory(userName);
}

//______________________________________________________________________________
const char *TUnixSystem::TempDirectory() const
{
   // Return a user configured or systemwide directory to create
   // temporary files in.

   const char *dir = gSystem->Getenv("TMPDIR");
   if (!dir || gSystem->AccessPathName(dir, kWritePermission))
      dir = "/tmp";

   return dir;
}

//______________________________________________________________________________
FILE *TUnixSystem::TempFileName(TString &base, const char *dir)
{
   // Create a secure temporary file by appending a unique
   // 6 letter string to base. The file will be created in
   // a standard (system) directory or in the directory
   // provided in dir. The full filename is returned in base
   // and a filepointer is returned for safely writing to the file
   // (this avoids certain security problems). Returns 0 in case
   // of error.

   char *b = ConcatFileName(dir ? dir : TempDirectory(), base);
   base = b;
   base += "XXXXXX";
   delete [] b;

   char *arg = StrDup(base);
   int fd = mkstemp(arg);
   base = arg;
   delete [] arg;

   if (fd == -1) {
      SysError("TempFileName", "%s", base.Data());
      return 0;
   } else {
      FILE *fp = fdopen(fd, "w+");
      if (fp == 0)
         SysError("TempFileName", "converting filedescriptor (%d)", fd);
      return fp;
   }
}

//______________________________________________________________________________
const char *TUnixSystem::PrependPathName(const char *dir, TString& name)
{
   // Concatenate a directory and a file name.

   if (name.IsNull() || name == ".") {
      if (dir) {
         name = dir;
         if (dir[strlen(dir) - 1] != '/')
            name += '/';
      } else name = "";
      return name.Data();
   }

   if (!dir || !dir[0]) dir = "/";
   else if (dir[strlen(dir) - 1] != '/')
      name.Prepend('/');
   name.Prepend(dir);

   return name.Data();
}

//---- Paths & Files -----------------------------------------------------------

//______________________________________________________________________________
Bool_t TUnixSystem::AccessPathName(const char *path, EAccessMode mode)
{
   // Returns FALSE if one can access a file using the specified access mode.
   // Mode is the same as for the Unix access(2) function.
   // Attention, bizarre convention of return value!!

   TSystem *helper = FindHelper(path);
   if (helper)
      return helper->AccessPathName(path, mode);

   if (::access(StripOffProto(path, "file:"), mode) == 0)
      return kFALSE;
   GetLastErrorString() = GetError();

   return kTRUE;
}

//______________________________________________________________________________
int TUnixSystem::CopyFile(const char *f, const char *t, Bool_t overwrite)
{
   // Copy a file. If overwrite is true and file already exists the
   // file will be overwritten. Returns 0 when successful, -1 in case
   // of file open failure, -2 in case the file already exists and overwrite
   // was false and -3 in case of error during copy.

   if (!AccessPathName(t) && !overwrite)
      return -2;

   FILE *from = fopen(f, "r");
   if (!from)
      return -1;

   FILE *to   = fopen(t, "w");
   if (!to) {
      fclose(from);
      return -1;
   }

   const int bufsize = 1024;
   char buf[bufsize];
   int ret = 0;
   while (!ret && !feof(from)) {
      size_t numread    = fread (buf, sizeof(char), bufsize, from);
      size_t numwritten = fwrite(buf, sizeof(char), numread, to);
      if (numread != numwritten)
         ret = -3;
   }

   fclose(from);
   fclose(to);

   return ret;
}

//______________________________________________________________________________
int TUnixSystem::Rename(const char *f, const char *t)
{
   // Rename a file. Returns 0 when successful, -1 in case of failure.

   int ret = ::rename(f, t);
   GetLastErrorString() = GetError();
   return ret;
}

//______________________________________________________________________________
Bool_t TUnixSystem::IsPathLocal(const char *path)
{
   // Returns TRUE if the url in 'path' points to the local file system.
   // This is used to avoid going through the NIC card for local operations.

   TSystem *helper = FindHelper(path);
   if (helper)
      return helper->IsPathLocal(path);

   return TSystem::IsPathLocal(path);
}

//______________________________________________________________________________
int TUnixSystem::GetPathInfo(const char *path, FileStat_t &buf)
{
   // Get info about a file. Info is returned in the form of a FileStat_t
   // structure (see TSystem.h).
   // The function returns 0 in case of success and 1 if the file could
   // not be stat'ed.

   TSystem *helper = FindHelper(path);
   if (helper)
      return helper->GetPathInfo(path, buf);

   return UnixFilestat(path, buf);
}

//______________________________________________________________________________
int TUnixSystem::GetFsInfo(const char *path, Long_t *id, Long_t *bsize,
                           Long_t *blocks, Long_t *bfree)
{
   // Get info about a file system: id, bsize, bfree, blocks.
   // Id      is file system type (machine dependend, see statfs())
   // Bsize   is block size of file system
   // Blocks  is total number of blocks in file system
   // Bfree   is number of free blocks in file system
   // The function returns 0 in case of success and 1 if the file system could
   // not be stat'ed.

   return UnixFSstat(path, id, bsize, blocks, bfree);
}

//______________________________________________________________________________
int TUnixSystem::Link(const char *from, const char *to)
{
   // Create a link from file1 to file2. Returns 0 when successful,
   // -1 in case of failure.

   return ::link(from, to);
}

//______________________________________________________________________________
int TUnixSystem::Symlink(const char *from, const char *to)
{
   // Create a symlink from file1 to file2. Returns 0 when successful,
   // -1 in case of failure.

#if defined(R__AIX)
   return ::symlink((char*)from, (char*)to);
#else
   return ::symlink(from, to);
#endif
}

//______________________________________________________________________________
int TUnixSystem::Unlink(const char *name)
{
   // Unlink, i.e. remove, a file or directory. Returns 0 when successful,
   // -1 in case of failure.

   TSystem *helper = FindHelper(name);
   if (helper)
      return helper->Unlink(name);

#if defined(R__SEEK64)
   struct stat64 finfo;
   if (lstat64(name, &finfo) < 0)
#else
   struct stat finfo;
   if (lstat(name, &finfo) < 0)
#endif
      return -1;

   if (S_ISDIR(finfo.st_mode))
      return ::rmdir(name);
   else
      return ::unlink(name);
}

//---- expand the metacharacters as in the shell -------------------------------

// expand the metacharacters as in the shell

const char
#ifdef G__OLDEXPAND
   kShellEscape     = '\\',
   *kShellStuff     = "(){}<>\"'",
#endif
   *kShellMeta      = "~*[]{}?$";


#ifndef G__OLDEXPAND
//______________________________________________________________________________
Bool_t TUnixSystem::ExpandPathName(TString &path)
{
   // Expand a pathname getting rid of special shell characters like ~.$, etc.
   // For Unix/Win32 compatibility use $(XXX) instead of $XXX when using
   // environment variables in a pathname. If compatibility is not an issue
   // you can use on Unix directly $XXX. Returns kFALSE in case of success
   // or kTRUE in case of error.

   const char *p, *patbuf = (const char *)path;

   // skip leading blanks
   while (*patbuf == ' ')
      patbuf++;

   // any shell meta characters ?
   for (p = patbuf; *p; p++)
      if (strchr(kShellMeta, *p))
         goto expand;

   return kFALSE;

expand:
   // replace $(XXX) by $XXX
   path.ReplaceAll("$(","$");
   path.ReplaceAll(")","");

   if ((p = ExpandFileName(path))) {
      path = p;
      return kFALSE;
   }
   return kTRUE;
}
#endif

#ifdef G__OLDEXPAND
//______________________________________________________________________________
Bool_t TUnixSystem::ExpandPathName(TString &patbuf0)
{
   // Expand a pathname getting rid of special shell characters like ~.$, etc.
   // For Unix/Win32 compatibility use $(XXX) instead of $XXX when using
   // environment variables in a pathname. If compatibility is not an issue
   // you can use on Unix directly $XXX. Returns kFALSE in case of success
   // or kTRUE in case of error.

   const char *patbuf = (const char *)patbuf0;
   const char *hd, *p;
   //   char   cmd[kMAXPATHLEN],
   char stuffedPat[kMAXPATHLEN], name[70];
   char  *q;
   FILE  *pf;
   int    ch;

   // skip leading blanks
   while (*patbuf == ' ')
      patbuf++;

   // any shell meta characters ?
   for (p = patbuf; *p; p++)
      if (strchr(kShellMeta, *p))
         goto needshell;

   return kFALSE;

needshell:
   // replace $(XXX) by $XXX
   patbuf0.ReplaceAll("$(","$");
   patbuf0.ReplaceAll(")","");

   // escape shell quote characters
   EscChar(patbuf, stuffedPat, sizeof(stuffedPat), (char*)kShellStuff, kShellEscape);

#ifdef R__HPUX
   TString cmd("/bin/echo ");
#else
   TString cmd("echo ");
#endif

   // emulate csh -> popen executes sh
   if (stuffedPat[0] == '~') {
      if (stuffedPat[1] != '\0' && stuffedPat[1] != '/') {
         // extract user name
         for (p = &stuffedPat[1], q = name; *p && *p !='/';)
            *q++ = *p++;
         *q = '\0';
         hd = UnixHomedirectory(name);
         if (hd == 0)
            cmd += stuffedPat;
         else {
            cmd += hd;
            cmd += p;
         }
      } else {
         hd = UnixHomedirectory(0);
         if (hd == 0) {
            GetLastErrorString() = GetError();
            return kTRUE;
         }
         cmd += hd;
         cmd += &stuffedPat[1];
      }
   } else
      cmd += stuffedPat;

   if ((pf = ::popen(cmd.Data(), "r")) == 0) {
      GetLastErrorString() = GetError();
      return kTRUE;
   }

   // read first argument
   patbuf0 = "";
   int cnt = 0;
#if defined(R__ALPHA) || defined(R__AIX)
again:
#endif
   for (ch = fgetc(pf); ch != EOF && ch != ' ' && ch != '\n'; ch = fgetc(pf)) {
      patbuf0.Append(ch);
      cnt++;
   }
#if defined(R__ALPHA) || defined(R__AIX)
   // Work around bug timing problem due to delay in forking a large program
   if (cnt == 0 && ch == EOF) goto again;
#endif

   // skip rest of pipe
   while (ch != EOF) {
      ch = fgetc(pf);
      if (ch == ' ' || ch == '\t') {
         GetLastErrorString() = "expression ambigous";
         ::pclose(pf);
         return kTRUE;
      }
   }

   ::pclose(pf);

   return kFALSE;
}
#endif

//______________________________________________________________________________
char *TUnixSystem::ExpandPathName(const char *path)
{
   // Expand a pathname getting rid of special shell characaters like ~.$, etc.
   // For Unix/Win32 compatibility use $(XXX) instead of $XXX when using
   // environment variables in a pathname. If compatibility is not an issue
   // you can use on Unix directly $XXX. The user must delete returned string.
   // Returns the expanded pathname or 0 in case of error.
   // The user must delete returned string (delete []).

   TString patbuf = path;
   if (ExpandPathName(patbuf))
      return 0;
   return StrDup(patbuf.Data());
}

//______________________________________________________________________________
int TUnixSystem::Chmod(const char *file, UInt_t mode)
{
   // Set the file permission bits. Returns -1 in case or error, 0 otherwise.

   return ::chmod(file, mode);
}

//______________________________________________________________________________
int TUnixSystem::Umask(Int_t mask)
{
   // Set the process file creation mode mask.

   return ::umask(mask);
}

//______________________________________________________________________________
int TUnixSystem::Utime(const char *file, Long_t modtime, Long_t actime)
{
   // Set a files modification and access times. If actime = 0 it will be
   // set to the modtime. Returns 0 on success and -1 in case of error.

   if (!actime)
      actime = modtime;

   struct utimbuf t;
   t.actime  = (time_t)actime;
   t.modtime = (time_t)modtime;
   return ::utime(file, &t);
}

//______________________________________________________________________________
const char *TUnixSystem::FindFile(const char *search, TString& wfil, EAccessMode mode)
{
   // Find location of file "wfil" in a search path.
   // The search path is specified as a : separated list of directories.
   // Return value is pointing to wfile for compatibility with
   // Which(const char*,const char*,EAccessMode) version.

   TString show;
   if (gEnv->GetValue("Root.ShowPath", 0))
      show.Form("Which: %s =", wfil.Data());

   gSystem->ExpandPathName(wfil);

   if (wfil[0] == '/') {
#if defined(R__SEEK64)
      struct stat64 finfo;
      if (access(wfil.Data(), mode) == 0 &&
          stat64(wfil.Data(), &finfo) == 0 && S_ISREG(finfo.st_mode)) {
#else
      struct stat finfo;
      if (access(wfil.Data(), mode) == 0 &&
          stat(wfil.Data(), &finfo) == 0 && S_ISREG(finfo.st_mode)) {
#endif
         if (show != "")
            Printf("%s %s", show.Data(), wfil.Data());
         return wfil.Data();
      }
      if (show != "")
         Printf("%s <not found>", show.Data());
      wfil = "";
      return 0;
   }

   if (search == 0)
      search = ".";

   TString apwd(gSystem->WorkingDirectory());
   apwd += "/";
   for (const char* ptr = search; *ptr;) {
      TString name;
      if (*ptr != '/' && *ptr !='$' && *ptr != '~')
         name = apwd;
      const char* posEndOfPart = strchr(ptr, ':');
      if (posEndOfPart) {
         name.Append(ptr, posEndOfPart - ptr);
         ptr = posEndOfPart + 1; // skip ':'
      } else {
         name.Append(ptr);
         ptr += strlen(ptr);
      }

      if (!name.EndsWith("/"))
         name += '/';
      name += wfil;

      gSystem->ExpandPathName(name);
#if defined(R__SEEK64)
      struct stat64 finfo;
      if (access(name.Data(), mode) == 0 &&
          stat64(name.Data(), &finfo) == 0 && S_ISREG(finfo.st_mode)) {
#else
      struct stat finfo;
      if (access(name.Data(), mode) == 0 &&
          stat(name.Data(), &finfo) == 0 && S_ISREG(finfo.st_mode)) {
#endif
         if (show != "")
            Printf("%s %s", show.Data(), name.Data());
         wfil = name;
         return wfil.Data();
      }
   }

   if (show != "")
      Printf("%s <not found>", show.Data());
   wfil = "";
   return 0;
}

//---- Users & Groups ----------------------------------------------------------

//______________________________________________________________________________
Int_t TUnixSystem::GetUid(const char *user)
{
   // Returns the user's id. If user = 0, returns current user's id.

   if (!user || !user[0])
      return getuid();
   else {
      struct passwd *apwd = getpwnam(user);
      if (apwd)
         return apwd->pw_uid;
   }
   return 0;
}

//______________________________________________________________________________
Int_t TUnixSystem::GetEffectiveUid()
{
   // Returns the effective user id. The effective id corresponds to the
   // set id bit on the file being executed.

   return geteuid();
}

//______________________________________________________________________________
Int_t TUnixSystem::GetGid(const char *group)
{
   // Returns the group's id. If group = 0, returns current user's group.

   if (!group || !group[0])
      return getgid();
   else {
      struct group *grp = getgrnam(group);
      if (grp)
         return grp->gr_gid;
   }
   return 0;
}

//______________________________________________________________________________
Int_t TUnixSystem::GetEffectiveGid()
{
   // Returns the effective group id. The effective group id corresponds
   // to the set id bit on the file being executed.

   return getegid();
}

//______________________________________________________________________________
UserGroup_t *TUnixSystem::GetUserInfo(Int_t uid)
{
   // Returns all user info in the UserGroup_t structure. The returned
   // structure must be deleted by the user. In case of error 0 is returned.

   typedef std::map<Int_t /*uid*/, UserGroup_t> UserInfoCache_t;
   static UserInfoCache_t gUserInfo;

   UserInfoCache_t::const_iterator iUserInfo = gUserInfo.find(uid);
   if (iUserInfo != gUserInfo.end())
      return new UserGroup_t(iUserInfo->second);

   struct passwd *apwd = getpwuid(uid);
   if (apwd) {
      UserGroup_t *ug = new UserGroup_t;
      ug->fUid      = apwd->pw_uid;
      ug->fGid      = apwd->pw_gid;
      ug->fUser     = apwd->pw_name;
      ug->fPasswd   = apwd->pw_passwd;
      ug->fRealName = apwd->pw_gecos;
      ug->fShell    = apwd->pw_shell;
      UserGroup_t *gr = GetGroupInfo(apwd->pw_gid);
      if (gr) ug->fGroup = gr->fGroup;
      delete gr;

      gUserInfo[uid] = *ug;
      return ug;
   }
   return 0;
}

//______________________________________________________________________________
UserGroup_t *TUnixSystem::GetUserInfo(const char *user)
{
   // Returns all user info in the UserGroup_t structure. If user = 0, returns
   // current user's id info. The returned structure must be deleted by the
   // user. In case of error 0 is returned.

   return GetUserInfo(GetUid(user));
}

//______________________________________________________________________________
UserGroup_t *TUnixSystem::GetGroupInfo(Int_t gid)
{
   // Returns all group info in the UserGroup_t structure. The only active
   // fields in the UserGroup_t structure for this call are:
   //    fGid and fGroup
   // The returned structure must be deleted by the user. In case of
   // error 0 is returned.

   struct group *grp = getgrgid(gid);
   if (grp) {
      UserGroup_t *gr = new UserGroup_t;
      gr->fUid   = 0;
      gr->fGid   = grp->gr_gid;
      gr->fGroup = grp->gr_name;
      return gr;
   }
   return 0;
}

//______________________________________________________________________________
UserGroup_t *TUnixSystem::GetGroupInfo(const char *group)
{
   // Returns all group info in the UserGroup_t structure. The only active
   // fields in the UserGroup_t structure for this call are:
   //    fGid and fGroup
   // If group = 0, returns current user's group. The returned structure
   // must be deleted by the user. In case of error 0 is returned.

   return GetGroupInfo(GetGid(group));
}

//---- environment manipulation ------------------------------------------------

//______________________________________________________________________________
void TUnixSystem::Setenv(const char *name, const char *value)
{
   // Set environment variable.

   ::setenv(name, value, 1);
}

//______________________________________________________________________________
const char *TUnixSystem::Getenv(const char *name)
{
   // Get environment variable.

   return ::getenv(name);
}

//______________________________________________________________________________
void TUnixSystem::Unsetenv(const char *name)
{
   // Unset environment variable.

   ::unsetenv(name);
}

//---- Processes ---------------------------------------------------------------

//______________________________________________________________________________
int TUnixSystem::Exec(const char *shellcmd)
{
   // Execute a command.

   return ::system(shellcmd);
}

//______________________________________________________________________________
FILE *TUnixSystem::OpenPipe(const char *command, const char *mode)
{
   // Open a pipe.

   return ::popen(command, mode);
}

//______________________________________________________________________________
int TUnixSystem::ClosePipe(FILE *pipe)
{
   // Close the pipe.

   return ::pclose(pipe);
}

//______________________________________________________________________________
int TUnixSystem::GetPid()
{
   // Get process id.

   return ::getpid();
}

//______________________________________________________________________________
void TUnixSystem::Exit(int code, Bool_t mode)
{
   // Exit the application.

   // Insures that the files and sockets are closed before any library is unloaded
   // and before emptying CINT.
   if (gROOT) {
      gROOT->EndOfProcessCleanups();
   } else if (gInterpreter) {
      gInterpreter->ResetGlobals();
   }

   if (mode)
      ::exit(code);
   else
      ::_exit(code);
}

//______________________________________________________________________________
void TUnixSystem::Abort(int)
{
   // Abort the application.

   ::abort();
}

//______________________________________________________________________________
void TUnixSystem::StackTrace()
{
   // Print a stack trace.

   if (!gEnv->GetValue("Root.Stacktrace", 1))
      return;

   TString gdbscript = gEnv->GetValue("Root.StacktraceScript", "");
   gdbscript = gdbscript.Strip();
   if (gdbscript != "") {
      if (AccessPathName(gdbscript, kReadPermission)) {
         fprintf(stderr, "Root.StacktraceScript %s does not exist\n", gdbscript.Data());
         gdbscript = "";
      } else {
         gdbscript += " ";
      }
   }
   if (gdbscript == "") {
#ifdef ROOTETCDIR
      gdbscript.Form("%s/gdb-backtrace.sh", ROOTETCDIR);
#else
      gdbscript.Form("%s/etc/gdb-backtrace.sh", Getenv("ROOTSYS"));
#endif
      if (AccessPathName(gdbscript, kReadPermission)) {
         fprintf(stderr, "Error in <TUnixSystem::StackTrace> script %s is missing\n", gdbscript.Data());
         return;
      }
      gdbscript += " ";
   }

   TString gdbmess = gEnv->GetValue("Root.StacktraceMessage", "");
   gdbmess = gdbmess.Strip();

   std::cout.flush();
   fflush(stdout);

   std::cerr.flush();
   fflush(stderr);

   int fd = STDERR_FILENO;

   const char *message = " Generating stack trace...\n";

   if (fd && message) { }  // remove unused warning (remove later)

   if (gApplication && !strcmp(gApplication->GetName(), "TRint"))
      Getlinem(kCleanUp, 0);

#if defined(USE_GDB_STACK_TRACE)
   char *gdb = Which(Getenv("PATH"), "gdb", kExecutePermission);
   if (!gdb) {
      fprintf(stderr, "gdb not found, need it for stack trace\n");
      return;
   }

   // write custom message file
   TString gdbmessf = "gdb-message";
   if (gdbmess != "") {
      FILE *f = TempFileName(gdbmessf);
      fprintf(f, "%s\n", gdbmess.Data());
      fclose(f);
   }

   // use gdb to get stack trace
   gdbscript += GetExePath();
   gdbscript += " ";
   gdbscript += GetPid();
   if (gdbmess != "") {
      gdbscript += " ";
      gdbscript += gdbmessf;
   }
   gdbscript += " 1>&2";
   Exec(gdbscript);
   delete [] gdb;
   return;

#elif defined(R__AIX)
   TString script = "procstack ";
   script += GetPid();
   Exec(script);
   return;
#elif defined(R__SOLARIS)
   char *cppfilt = Which(Getenv("PATH"), "c++filt", kExecutePermission);
   TString script = "pstack ";
   script += GetPid();
   if (cppfilt) {
      script += " | ";
      script += cppfilt;
      delete [] cppfilt;
   }
   Exec(script);
   return;
#elif defined(HAVE_U_STACK_TRACE)  // hp-ux
/*
   // FIXME: deal with inability to duplicate the file handle
   int stderrfd = dup(STDERR_FILENO);
   if (stderrfd == -1)
      return;

   int newfd = dup2(fd, STDERR_FILENO);
   if (newfd == -1) {
      close (stderrfd);
      return;
   }
*/
   U_STACK_TRACE();
/*
   fflush(stderr);
   dup2(stderrfd, STDERR_FILENO);
   close(newfd);
*/
#elif defined(HAVE_BACKTRACE_SYMBOLS_FD) && defined(HAVE_DLADDR)  // linux + MacOS X >= 10.5
   // we could have used backtrace_symbols_fd, except its output
   // format is pretty bad, so recode that here :-(

   // take care of demangling
   Bool_t demangle = kTRUE;

   // check for c++filt
   const char *cppfilt = "c++filt";
   const char *cppfiltarg = "";
#ifdef R__B64
   const char *format1 = " 0x%016lx in %.200s %s 0x%lx from %.200s\n";
#ifdef R__MACOSX
   const char *format2 = " 0x%016lx in %.200s\n";
#else
   const char *format2 = " 0x%016lx in %.200s at %.200s from %.200s\n";
#endif
   const char *format3 = " 0x%016lx in %.200s from %.200s\n";
   const char *format4 = " 0x%016lx in <unknown function>\n";
#else
   const char *format1 = " 0x%08lx in %.200s %s 0x%lx from %.200s\n";
#ifdef R__MACOSX
   const char *format2 = " 0x%08lx in %.200s\n";
#else
   const char *format2 = " 0x%08lx in %.200s at %.200s from %.200s\n";
#endif
   const char *format3 = " 0x%08lx in %.200s from %.200s\n";
   const char *format4 = " 0x%08lx in <unknown function>\n";
#endif

   char *filter = Which(Getenv("PATH"), cppfilt, kExecutePermission);
   if (!filter)
      demangle = kFALSE;

#if (__GNUC__ >= 3)
   // try finding supported format option for g++ v3
   if (filter) {
      FILE *p = OpenPipe(TString::Format("%s --help 2>&1", filter), "r");
      TString help;
      while (help.Gets(p)) {
         if (help.Index("gnu-v3") != kNPOS) {
            cppfiltarg = "--format=gnu-v3";
            break;
         } else if (help.Index("gnu-new-abi") != kNPOS) {
            cppfiltarg = "--format=gnu-new-abi";
            break;
         }
      }
      ClosePipe(p);
   }
#endif
   // gdb-backtrace.sh uses gdb to produce a backtrace. See if it is available.
   // If it is, use it. If not proceed as before.
#if (defined(R__LINUX) && !defined(R__WINGCC))
   // Declare the process that will be generating the stacktrace
   // For more see: http://askubuntu.com/questions/41629/after-upgrade-gdb-wont-attach-to-process
#ifdef PR_SET_PTRACER
   prctl(PR_SET_PTRACER, getpid(), 0, 0, 0);
#endif
#endif
   char *gdb = Which(Getenv("PATH"), "gdb", kExecutePermission);
   if (gdb) {
      // write custom message file
      TString gdbmessf = "gdb-message";
      if (gdbmess != "") {
         FILE *f = TempFileName(gdbmessf);
         fprintf(f, "%s\n", gdbmess.Data());
         fclose(f);
      }

      // use gdb to get stack trace
#ifdef R__MACOSX
      gdbscript += GetExePath();
      gdbscript += " ";
#endif
      gdbscript += GetPid();
      if (gdbmess != "") {
         gdbscript += " ";
         gdbscript += gdbmessf;
      }
      gdbscript += " 1>&2";
      Exec(gdbscript);
      delete [] gdb;
   } else {
      // addr2line uses debug info to convert addresses into file names
      // and line numbers
#ifdef R__MACOSX
      char *addr2line = Which(Getenv("PATH"), "atos", kExecutePermission);
#else
      char *addr2line = Which(Getenv("PATH"), "addr2line", kExecutePermission);
#endif
      if (addr2line) {
         // might take some time so tell what we are doing...
         if (write(fd, message, strlen(message)) < 0)
            Warning("StackTrace", "problems writing line numbers (errno: %d)", TSystem::GetErrno());
      }

      // open tmp file for demangled stack trace
      TString tmpf1 = "gdb-backtrace";
      std::ofstream file1;
      if (demangle) {
         FILE *f = TempFileName(tmpf1);
         if (f) fclose(f);
         file1.open(tmpf1);
         if (!file1) {
            Error("StackTrace", "could not open file %s", tmpf1.Data());
            Unlink(tmpf1);
            demangle = kFALSE;
         }
      }

#ifdef R__MACOSX
      if (addr2line)
         demangle = kFALSE;  // atos always demangles
#endif

      char buffer[4096];
      void *trace[kMAX_BACKTRACE_DEPTH];
      int  depth = backtrace(trace, kMAX_BACKTRACE_DEPTH);
      for (int n = 5; n < depth; n++) {
         ULong_t addr = (ULong_t) trace[n];
         Dl_info info;

         if (dladdr(trace[n], &info) && info.dli_fname && info.dli_fname[0]) {
            const char *libname = info.dli_fname;
            const char *symname = (info.dli_sname && info.dli_sname[0]) ?
                                   info.dli_sname : "<unknown>";
            ULong_t libaddr = (ULong_t) info.dli_fbase;
            ULong_t symaddr = (ULong_t) info.dli_saddr;
            Bool_t  gte = (addr >= symaddr);
            ULong_t diff = (gte) ? addr - symaddr : symaddr - addr;
            if (addr2line && symaddr) {
               Bool_t nodebug = kTRUE;
#ifdef R__MACOSX
               if (libaddr) { }  // use libaddr
#if defined(MAC_OS_X_VERSION_10_10)
               snprintf(buffer, sizeof(buffer), "%s -p %d 0x%016lx", addr2line, GetPid(), addr);
#elif defined(MAC_OS_X_VERSION_10_9)
               // suppress deprecation warning with opti
               snprintf(buffer, sizeof(buffer), "%s -d -p %d 0x%016lx", addr2line, GetPid(), addr);
#else
               snprintf(buffer, sizeof(buffer), "%s -p %d 0x%016lx", addr2line, GetPid(), addr);
#endif
#else
               ULong_t offset = (addr >= libaddr) ? addr - libaddr :
                                                    libaddr - addr;
               TString name   = TString(libname);
               Bool_t noPath  = kFALSE;
               Bool_t noShare = kTRUE;
               if (name[0] != '/') noPath = kTRUE;
               if (name.Contains(".so") || name.Contains(".sl")) noShare = kFALSE;
               if (noShare) offset = addr;
               if (noPath)  name = "`which " + name + "`";
               snprintf(buffer, sizeof(buffer), "%s -e %s 0x%016lx", addr2line, name.Data(), offset);
#endif
               if (FILE *pf = ::popen(buffer, "r")) {
                  char buf[2048];
                  if (fgets(buf, 2048, pf)) {
                     buf[strlen(buf)-1] = 0;  // remove trailing \n
                     if (strncmp(buf, "??", 2)) {
#ifdef R__MACOSX
                        snprintf(buffer, sizeof(buffer), format2, addr, buf);
#else
                        snprintf(buffer, sizeof(buffer), format2, addr, symname, buf, libname);
#endif
                        nodebug = kFALSE;
                     }
                  }
                  ::pclose(pf);
               }
               if (nodebug)
                  snprintf(buffer, sizeof(buffer), format1, addr, symname,
                           gte ? "+" : "-", diff, libname);
            } else {
               if (symaddr)
                  snprintf(buffer, sizeof(buffer), format1, addr, symname,
                           gte ? "+" : "-", diff, libname);
               else
                  snprintf(buffer, sizeof(buffer), format3, addr, symname, libname);
            }
         } else {
            snprintf(buffer, sizeof(buffer), format4, addr);
         }

         if (demangle)
            file1 << buffer;
         else
            if (write(fd, buffer, ::strlen(buffer)) < 0)
               Warning("StackTrace", "problems writing buffer (errno: %d)", TSystem::GetErrno());
      }

      if (demangle) {
         TString tmpf2 = "gdb-backtrace";
         FILE *f = TempFileName(tmpf2);
         if (f) fclose(f);
         file1.close();
         snprintf(buffer, sizeof(buffer), "%s %s < %s > %s", filter, cppfiltarg, tmpf1.Data(), tmpf2.Data());
         Exec(buffer);
         std::ifstream file2(tmpf2);
         TString line;
         while (file2) {
            line = "";
            line.ReadString(file2);
            if (write(fd, line.Data(), line.Length()) < 0)
               Warning("StackTrace", "problems writing line (errno: %d)", TSystem::GetErrno());
         }
         file2.close();
         Unlink(tmpf1);
         Unlink(tmpf2);
      }

      delete [] addr2line;
   }
   delete [] filter;
#elif defined(HAVE_EXCPT_H) && defined(HAVE_PDSC_H) && \
                               defined(HAVE_RLD_INTERFACE_H) // tru64
   // Tru64 stack walk.  Uses the exception handling library and the
   // run-time linker's core functions (loader(5)).  FIXME: Tru64
   // should have _RLD_DLADDR like IRIX below.  Verify and update.

   char         buffer [128];
   sigcontext   context;
   int          rc = 0;

   exc_capture_context (&context);
   while (!rc && context.sc_pc) {
      // FIXME: Elf32?
      pdsc_crd *func, *base, *crd
         = exc_remote_lookup_function_entry(0, 0, context.sc_pc, 0, &func, &base);
      Elf32_Addr addr = PDSC_CRD_BEGIN_ADDRESS(base, func);
      // const char *name = _rld_address_to_name(addr);
      const char *name = "<unknown function>";
      sprintf(buffer, " 0x%012lx %.200s + 0x%lx\n",
              context.sc_pc, name, context.sc_pc - addr);
      write(fd, buffer, ::strlen(buffer));
      rc = exc_virtual_unwind(0, &context);
   }

#elif defined(HAVE_EXCEPTION_H) && defined(__sgi)     // irix
   // IRIX stack walk -- like Tru64 but with a little different names.
   // NB: The guard above is to protect against unrelated <exception.h>
   //   provided by some compilers (e.g. KCC 4.0f).
   // NB: libexc.h has trace_back_stack and trace_back_stack_and_print
   //   but their output isn't pretty and nowhere as complete as ours.
   char       buffer [340];
   sigcontext context;

   exc_setjmp(&context);
   while (context.sc_pc >= 4) {
      // Do two lookups, one using exception handling tables and
      // another using _RLD_DLADDR, and use the one with a smaller
      // offset.  For signal handlers we seem to get things wrong:
      // _sigtramp's exception range is huge while based on Dl_info
      // the offset is small -- but both supposedly describe the
      // same thing.  Go figure.
      char            *name = 0;
      const char      *libname = 0;
      const char      *symname = 0;
      Elf32_Addr      offset = ~0L;

      // Do the exception/dwarf lookup
      Elf32_Addr      pc = context.sc_pc;
      Dwarf_Fde       fde = find_fde_name(&pc, &name);
      Dwarf_Addr      low_pc = context.sc_pc;
      Dwarf_Unsigned  udummy;
      Dwarf_Signed    sdummy;
      Dwarf_Ptr       pdummy;
      Dwarf_Off       odummy;
      Dwarf_Error     err;

      symname = name;

      // Determine offset using exception descriptor range information.
      if (dwarf_get_fde_range(fde, &low_pc, &udummy, &pdummy, &udummy,
                              &odummy, &sdummy, &odummy, &err) == DW_DLV_OK)
         offset = context.sc_pc - low_pc;

      // Now do a dladdr() lookup.  If the found symbol has the same
      // address, trust the more accurate offset from dladdr();
      // ignore the looked up mangled symbol name and prefer the
      // demangled name produced by find_fde_name().  If we find a
      // smaller offset, trust the dynamic symbol as well.  Always
      // trust the library name even if we can't match it with an
      // exact symbol.
      Elf32_Addr      addr = context.sc_pc;
      Dl_info         info;

      if (_rld_new_interface (_RLD_DLADDR, addr, &info)) {
         if (info.dli_fname && info.dli_fname [0])
            libname = info.dli_fname;

         Elf32_Addr symaddr = (Elf32_Addr) info.dli_saddr;
         if (symaddr == low_pc)
            offset = addr - symaddr;
         else if (info.dli_sname
                  && info.dli_sname [0]
                  && addr - symaddr < offset) {
            offset = addr - symaddr;
            symname = info.dli_sname;
         }
      }

      // Print out the result
      if (libname && symname)
         write(fd, buffer, sprintf
               (buffer, " 0x%012lx %.200s + 0x%lx [%.200s]\n",
               addr, symname, offset, libname));
      else if (symname)
         write(fd, buffer, sprintf
               (buffer, " 0x%012lx %.200s + 0x%lx\n",
               addr, symname, offset));
      else
         write(fd, buffer, sprintf
               (buffer, " 0x%012lx <unknown function>\n", addr));

      // Free name from find_fde_name().
      free(name);

      // Check for termination.  exc_unwind() sets context.sc_pc to
      // 0 or an error (< 4).  However it seems we can't unwind
      // through signal stack frames though this is not mentioned in
      // the docs; it seems that for those we need to check for
      // changed pc after find_fde_name().  That seems to indicate
      // end of the post-signal stack frame.  (FIXME: Figure out how
      // to unwind through signal stack frame, e.g. perhaps using
      // sigcontext_t's old pc?  Or perhaps we can keep on going
      // down without doing the symbol lookup?)
      if (pc != context.sc_pc)
         break;

      exc_unwind(&context, fde);
   }
#endif
}

//---- System Logging ----------------------------------------------------------

//______________________________________________________________________________
void TUnixSystem::Openlog(const char *name, Int_t options, ELogFacility facility)
{
   // Open connection to system log daemon. For the use of the options and
   // facility see the Unix openlog man page.

   int fac = 0;

   switch (facility) {
      case kLogLocal0:
         fac = LOG_LOCAL0;
         break;
      case kLogLocal1:
         fac = LOG_LOCAL1;
         break;
      case kLogLocal2:
         fac = LOG_LOCAL2;
         break;
      case kLogLocal3:
         fac = LOG_LOCAL3;
         break;
      case kLogLocal4:
         fac = LOG_LOCAL4;
         break;
      case kLogLocal5:
         fac = LOG_LOCAL5;
         break;
      case kLogLocal6:
         fac = LOG_LOCAL6;
         break;
      case kLogLocal7:
         fac = LOG_LOCAL7;
         break;
   }

   ::openlog(name, options, fac);
}

//______________________________________________________________________________
void TUnixSystem::Syslog(ELogLevel level, const char *mess)
{
   // Send mess to syslog daemon. Level is the logging level and mess the
   // message that will be written on the log.

   // ELogLevel matches exactly the Unix values.
   ::syslog(level, "%s", mess);
}

//______________________________________________________________________________
void TUnixSystem::Closelog()
{
   // Close connection to system log daemon.

   ::closelog();
}

//---- Standard output redirection ---------------------------------------------

//______________________________________________________________________________
Int_t TUnixSystem::RedirectOutput(const char *file, const char *mode,
                                  RedirectHandle_t *h)
{
   // Redirect standard output (stdout, stderr) to the specified file.
   // If the file argument is 0 the output is set again to stderr, stdout.
   // The second argument specifies whether the output should be added to the
   // file ("a", default) or the file be truncated before ("w").
   // This function saves internally the current state into a static structure.
   // The call can be made reentrant by specifying the opaque structure pointed
   // by 'h', which is filled with the relevant information. The handle 'h'
   // obtained on the first call must then be used in any subsequent call,
   // included ShowOutput, to display the redirected output.
   // Returns 0 on success, -1 in case of error.

   // Instance to be used if the caller does not passes 'h'
   static RedirectHandle_t loch;

   Int_t rc = 0;

   // Which handle to use ?
   RedirectHandle_t *xh = (h) ? h : &loch;

   if (file) {
      // Save the paths
      Bool_t outdone = kFALSE;
      if (xh->fStdOutTty.IsNull()) {
         const char *tty = ttyname(STDOUT_FILENO);
         if (tty) {
            xh->fStdOutTty = tty;
         } else {
            if ((xh->fStdOutDup = dup(STDOUT_FILENO)) < 0) {
               SysError("RedirectOutput", "could not 'dup' stdout (errno: %d)", TSystem::GetErrno());
               return -1;
            }
            outdone = kTRUE;
         }
      }
      if (xh->fStdErrTty.IsNull()) {
         const char *tty = ttyname(STDERR_FILENO);
         if (tty) {
            xh->fStdErrTty = tty;
         } else {
            if ((xh->fStdErrDup = dup(STDERR_FILENO)) < 0) {
               SysError("RedirectOutput", "could not 'dup' stderr (errno: %d)", TSystem::GetErrno());
               if (outdone && dup2(xh->fStdOutDup, STDOUT_FILENO) < 0) {
                  Warning("RedirectOutput", "could not restore stdout (back to original redirected"
                          " file) (errno: %d)", TSystem::GetErrno());
               }
               return -1;
            }
         }
      }

      // Make sure mode makes sense; default "a"
      const char *m = (mode[0] == 'a' || mode[0] == 'w') ? mode : "a";

      // Current file size
      xh->fReadOffSet = 0;
      if (m[0] == 'a') {
         // If the file exists, save the current size
         FileStat_t st;
         if (!gSystem->GetPathInfo(file, st))
            xh->fReadOffSet = (st.fSize > 0) ? st.fSize : xh->fReadOffSet;
      }
      xh->fFile = file;

      // Redirect stdout & stderr
      if (freopen(file, m, stdout) == 0) {
         SysError("RedirectOutput", "could not freopen stdout (errno: %d)", TSystem::GetErrno());
         return -1;
      }
      if (freopen(file, m, stderr) == 0) {
         SysError("RedirectOutput", "could not freopen stderr (errno: %d)", TSystem::GetErrno());
         if (freopen(xh->fStdOutTty.Data(), "a", stdout) == 0)
            SysError("RedirectOutput", "could not restore stdout (errno: %d)", TSystem::GetErrno());
         return -1;
      }
   } else {
      // Restore stdout & stderr
      fflush(stdout);
      if (!(xh->fStdOutTty.IsNull())) {
         if (freopen(xh->fStdOutTty.Data(), "a", stdout) == 0) {
            SysError("RedirectOutput", "could not restore stdout (errno: %d)", TSystem::GetErrno());
            rc = -1;
         }
         xh->fStdOutTty = "";
      } else {
         if (close(STDOUT_FILENO) != 0) {
            SysError("RedirectOutput",
                     "problems closing STDOUT_FILENO (%d) before 'dup2' (errno: %d)",
                     STDOUT_FILENO, TSystem::GetErrno());
            rc = -1;
         }
         if (dup2(xh->fStdOutDup, STDOUT_FILENO) < 0) {
            SysError("RedirectOutput", "could not restore stdout (back to original redirected"
                     " file) (errno: %d)", TSystem::GetErrno());
            rc = -1;
         }
         if (close(xh->fStdOutDup) != 0) {
            SysError("RedirectOutput",
                     "problems closing temporary 'out' descriptor %d (errno: %d)",
                     TSystem::GetErrno(), xh->fStdOutDup);
            rc = -1;
         }
      }
      fflush(stderr);
      if (!(xh->fStdErrTty.IsNull())) {
         if (freopen(xh->fStdErrTty.Data(), "a", stderr) == 0) {
            SysError("RedirectOutput", "could not restore stderr (errno: %d)", TSystem::GetErrno());
            rc = -1;
         }
         xh->fStdErrTty = "";
      } else {
         if (close(STDERR_FILENO) != 0) {
            SysError("RedirectOutput",
                     "problems closing STDERR_FILENO (%d) before 'dup2' (errno: %d)",
                     STDERR_FILENO, TSystem::GetErrno());
            rc = -1;
         }
         if (dup2(xh->fStdErrDup, STDERR_FILENO) < 0) {
            SysError("RedirectOutput", "could not restore stderr (back to original redirected"
                     " file) (errno: %d)", TSystem::GetErrno());
            rc = -1;
         }
         if (close(xh->fStdErrDup) != 0) {
            SysError("RedirectOutput",
                     "problems closing temporary 'err' descriptor %d (errno: %d)",
                     TSystem::GetErrno(), xh->fStdErrDup);
            rc = -1;
         }
      }
      // Reset the static instance, if using that
      if (xh == &loch)
         xh->Reset();
   }
   return rc;
}

//---- dynamic loading and linking ---------------------------------------------

//______________________________________________________________________________
Func_t TUnixSystem::DynFindSymbol(const char *module, const char *entry)
{
   //dynamic linking of module
   #ifdef NOCINT
   return UnixDynFindSymbol(module,entry);
#else
   if (module) { }   // silence compiler about not using module
   return TSystem::DynFindSymbol("*", entry);
#endif
}

//______________________________________________________________________________
int TUnixSystem::Load(const char *module, const char *entry, Bool_t system)
{
   // Load a shared library. Returns 0 on successful loading, 1 in
   // case lib was already loaded and -1 in case lib does not exist
   // or in case of error.

#ifdef NOCINT
   int i = UnixDynLoad(module);
   if (!entry || !strlen(entry)) return i;

   Func_t f = UnixDynFindSymbol(module, entry);
   if (f) return 0;
   return -1;
#else
   return TSystem::Load(module, entry, system);
#endif
}

//______________________________________________________________________________
void TUnixSystem::Unload(const char *module)
{
   // Unload a shared library.

#ifdef NOCINT
   UnixDynUnload(module);
#else
   if (module) { TSystem::Unload(module); }
#endif
}

//______________________________________________________________________________
void TUnixSystem::ListSymbols(const char *module, const char *regexp)
{
   // List symbols in a shared library.

   UnixDynListSymbols(module, regexp);
}

//______________________________________________________________________________
void TUnixSystem::ListLibraries(const char *regexp)
{
   // List all loaded shared libraries.

#ifdef R__HPUX
   UnixDynListLibs(regexp);
#else
   TSystem::ListLibraries(regexp);
#endif
}

//______________________________________________________________________________
const char *TUnixSystem::GetLinkedLibraries()
{
   // Get list of shared libraries loaded at the start of the executable.
   // Returns 0 in case list cannot be obtained or in case of error.

   static TString linkedLibs;
   static Bool_t once = kFALSE;

   R__LOCKGUARD2(gSystemMutex);

   if (!linkedLibs.IsNull())
      return linkedLibs;

   if (once)
      return 0;

#if !defined(R__MACOSX)
   const char *exe = GetExePath();
   if (!exe || !*exe)
      return 0;
#endif

#if defined(R__MACOSX)
   DylibAdded(0, 0);
   linkedLibs = gLinkedDylibs;
#if 0
   FILE *p = OpenPipe(TString::Format("otool -L %s", exe), "r");
   TString otool;
   while (otool.Gets(p)) {
      TString delim(" \t");
      TObjArray *tok = otool.Tokenize(delim);
      TString dylib = ((TObjString*)tok->At(0))->String();
      if (dylib.EndsWith(".dylib") && !dylib.Contains("/libSystem.B.dylib")) {
         if (!linkedLibs.IsNull())
            linkedLibs += " ";
         linkedLibs += dylib;
      }
      delete tok;
   }
   if (p) {
      ClosePipe(p);
   }
#endif
#elif defined(R__LINUX) || defined(R__SOLARIS) || defined(R__AIX)
#if defined(R__WINGCC )
   const char *cLDD="cygcheck";
   const char *cSOEXT=".dll";
   size_t lenexe = strlen(exe);
   if (strcmp(exe + lenexe - 4, ".exe")
       && strcmp(exe + lenexe - 4, ".dll")) {
      // it's not a dll and exe doesn't end on ".exe";
      // need to add it for cygcheck to find it:
      char* longerexe = new char[lenexe + 5];
      strlcpy(longerexe, exe,lenexe+5);
      strlcat(longerexe, ".exe",lenexe+5);
      delete [] exe;
      exe = longerexe;
   }
   TRegexp sovers = "\\.so\\.[0-9]+";
#else
   const char *cLDD="ldd";
#if defined(R__AIX)
   const char *cSOEXT=".a";
   TRegexp sovers = "\\.a\\.[0-9]+";
#else
   const char *cSOEXT=".so";
   TRegexp sovers = "\\.so\\.[0-9]+";
#endif
#endif
   FILE *p = OpenPipe(TString::Format("%s %s", cLDD, exe), "r");
   if (p) {
      TString ldd;
      while (ldd.Gets(p)) {
         TString delim(" \t");
         TObjArray *tok = ldd.Tokenize(delim);

         // expected format:
         //    libCore.so => /home/rdm/root/lib/libCore.so (0x40017000)
         TObjString *solibName = (TObjString*)tok->At(2);
         if (!solibName) {
            // case where there is only one name of the list:
            //    /usr/platform/SUNW,UltraAX-i2/lib/libc_psr.so.1
            solibName = (TObjString*)tok->At(0);
         }
         if (solibName) {
            TString solib = solibName->String();
            Ssiz_t idx = solib.Index(sovers);
            if (solib.EndsWith(cSOEXT) || idx != kNPOS) {
               if (idx != kNPOS)
                  solib.Remove(idx+3);
               if (!AccessPathName(solib, kReadPermission)) {
                  if (!linkedLibs.IsNull())
                     linkedLibs += " ";
                  linkedLibs += solib;
               }
            }
         }
         delete tok;
      }
      ClosePipe(p);
   }
#endif

   once = kTRUE;

   if (linkedLibs.IsNull())
      return 0;

   return linkedLibs;
}

//---- Time & Date -------------------------------------------------------------

//______________________________________________________________________________
TTime TUnixSystem::Now()
{
   // Get current time in milliseconds since 0:00 Jan 1 1995.

   return UnixNow();
}

//______________________________________________________________________________
Bool_t TUnixSystem::DispatchTimers(Bool_t mode)
{
   // Handle and dispatch timers. If mode = kTRUE dispatch synchronous
   // timers else a-synchronous timers.

   if (!fTimers) return kFALSE;

   fInsideNotify = kTRUE;

   TOrdCollectionIter it((TOrdCollection*)fTimers);
   TTimer *t;
   Bool_t  timedout = kFALSE;

   while ((t = (TTimer *) it.Next())) {
      // NB: the timer resolution is added in TTimer::CheckTimer()
      Long64_t now = UnixNow();
      if (mode && t->IsSync()) {
         if (t->CheckTimer(now))
            timedout = kTRUE;
      } else if (!mode && t->IsAsync()) {
         if (t->CheckTimer(now)) {
            UnixSetitimer(NextTimeOut(kFALSE));
            timedout = kTRUE;
         }
      }
   }
   fInsideNotify = kFALSE;
   return timedout;
}

//______________________________________________________________________________
void TUnixSystem::AddTimer(TTimer *ti)
{
   // Add timer to list of system timers.

   TSystem::AddTimer(ti);
   ResetTimer(ti);
}

//______________________________________________________________________________
TTimer *TUnixSystem::RemoveTimer(TTimer *ti)
{
   // Remove timer from list of system timers.

   if (!ti) return 0;

   R__LOCKGUARD2(gSystemMutex);

   TTimer *t = TSystem::RemoveTimer(ti);
   if (ti->IsAsync())
      UnixSetitimer(NextTimeOut(kFALSE));
   return t;
}

//______________________________________________________________________________
void TUnixSystem::ResetTimer(TTimer *ti)
{
   // Reset a-sync timer.

   if (!fInsideNotify && ti && ti->IsAsync())
      UnixSetitimer(NextTimeOut(kFALSE));
}

//---- RPC ---------------------------------------------------------------------

//______________________________________________________________________________
TInetAddress TUnixSystem::GetHostByName(const char *hostname)
{
   // Get Internet Protocol (IP) address of host. Returns an TInetAddress
   // object. To see if the hostname lookup was successfull call
   // TInetAddress::IsValid().

   struct hostent *host_ptr;
   const char     *host;
   int             type;
   UInt_t          addr;    // good for 4 byte addresses

   // Note that http://linux.die.net/man/3/gethostbyaddr
   // claims:
   //   The gethostbyname*() and gethostbyaddr*() functions are obsolete.
   //   Applications should use getaddrinfo(3) and getnameinfo(3) instead.

   // gethostbyaddr return the address of static data, we need to insure
   // exclusive access ... the 'right' solution is to switch to getaddrinfo

   R__LOCKGUARD(gROOTMutex);

#ifdef HASNOT_INETATON
   if ((addr = (UInt_t)inet_addr(hostname)) != INADDR_NONE) {
#else
   struct in_addr ad;
   if (inet_aton(hostname, &ad)) {
      memcpy(&addr, &ad.s_addr, sizeof(ad.s_addr));
#endif
      type = AF_INET;
      if ((host_ptr = gethostbyaddr((const char *)&addr,
                                    sizeof(addr), AF_INET))) {
         host = host_ptr->h_name;
         TInetAddress a(host, ntohl(addr), type);
         UInt_t addr2;
         Int_t  i;
         for (i = 1; host_ptr->h_addr_list[i]; i++) {
            memcpy(&addr2, host_ptr->h_addr_list[i], host_ptr->h_length);
            a.AddAddress(ntohl(addr2));
         }
         for (i = 0; host_ptr->h_aliases[i]; i++)
            a.AddAlias(host_ptr->h_aliases[i]);
         return a;
      } else {
         host = "UnNamedHost";
      }
   } else if ((host_ptr = gethostbyname(hostname))) {
      // Check the address type for an internet host
      if (host_ptr->h_addrtype != AF_INET) {
         Error("GetHostByName", "%s is not an internet host\n", hostname);
         return TInetAddress();
      }
      memcpy(&addr, host_ptr->h_addr, host_ptr->h_length);
      host = host_ptr->h_name;
      type = host_ptr->h_addrtype;
      TInetAddress a(host, ntohl(addr), type);
      UInt_t addr2;
      Int_t  i;
      for (i = 1; host_ptr->h_addr_list[i]; i++) {
         memcpy(&addr2, host_ptr->h_addr_list[i], host_ptr->h_length);
         a.AddAddress(ntohl(addr2));
      }
      for (i = 0; host_ptr->h_aliases[i]; i++)
         a.AddAlias(host_ptr->h_aliases[i]);
      return a;
   } else {
      if (gDebug > 0) Error("GetHostByName", "unknown host %s", hostname);
      return TInetAddress(hostname, 0, -1);
   }

   return TInetAddress(host, ntohl(addr), type);
}

//______________________________________________________________________________
TInetAddress TUnixSystem::GetSockName(int sock)
{
   // Get Internet Protocol (IP) address of host and port #.

   struct sockaddr_in addr;
#if defined(USE_SIZE_T)
   size_t len = sizeof(addr);
#elif defined(USE_SOCKLEN_T)
   socklen_t len = sizeof(addr);
#else
   int len = sizeof(addr);
#endif

   if (getsockname(sock, (struct sockaddr *)&addr, &len) == -1) {
      SysError("GetSockName", "getsockname");
      return TInetAddress();
   }

   struct hostent *host_ptr;
   const char *hostname;
   int         family;
   UInt_t      iaddr;

   if ((host_ptr = gethostbyaddr((const char *)&addr.sin_addr,
                                 sizeof(addr.sin_addr), AF_INET))) {
      memcpy(&iaddr, host_ptr->h_addr, host_ptr->h_length);
      hostname = host_ptr->h_name;
      family   = host_ptr->h_addrtype;
   } else {
      memcpy(&iaddr, &addr.sin_addr, sizeof(addr.sin_addr));
      hostname = "????";
      family   = AF_INET;
   }

   return TInetAddress(hostname, ntohl(iaddr), family, ntohs(addr.sin_port));
}

//______________________________________________________________________________
TInetAddress TUnixSystem::GetPeerName(int sock)
{
   // Get Internet Protocol (IP) address of remote host and port #.

   struct sockaddr_in addr;
#if defined(USE_SIZE_T)
   size_t len = sizeof(addr);
#elif defined(USE_SOCKLEN_T)
   socklen_t len = sizeof(addr);
#else
   int len = sizeof(addr);
#endif

   if (getpeername(sock, (struct sockaddr *)&addr, &len) == -1) {
      SysError("GetPeerName", "getpeername");
      return TInetAddress();
   }

   struct hostent *host_ptr;
   const char *hostname;
   int         family;
   UInt_t      iaddr;

   if ((host_ptr = gethostbyaddr((const char *)&addr.sin_addr,
                                 sizeof(addr.sin_addr), AF_INET))) {
      memcpy(&iaddr, host_ptr->h_addr, host_ptr->h_length);
      hostname = host_ptr->h_name;
      family   = host_ptr->h_addrtype;
   } else {
      memcpy(&iaddr, &addr.sin_addr, sizeof(addr.sin_addr));
      hostname = "????";
      family   = AF_INET;
   }

   return TInetAddress(hostname, ntohl(iaddr), family, ntohs(addr.sin_port));
}

//______________________________________________________________________________
int TUnixSystem::GetServiceByName(const char *servicename)
{
   // Get port # of internet service.

   struct servent *sp;

   if ((sp = getservbyname(servicename, kProtocolName)) == 0) {
      Error("GetServiceByName", "no service \"%s\" with protocol \"%s\"\n",
              servicename, kProtocolName);
      return -1;
   }
   return ntohs(sp->s_port);
}

//______________________________________________________________________________
char *TUnixSystem::GetServiceByPort(int port)
{
   // Get name of internet service.

   struct servent *sp;

   if ((sp = getservbyport(htons(port), kProtocolName)) == 0) {
      //::Error("GetServiceByPort", "no service \"%d\" with protocol \"%s\"",
      //        port, kProtocolName);
      return Form("%d", port);
   }
   return sp->s_name;
}

//______________________________________________________________________________
int TUnixSystem::ConnectService(const char *servername, int port,
                                int tcpwindowsize, const char *protocol)
{
   // Connect to service servicename on server servername.

   if (!strcmp(servername, "unix")) {
      return UnixUnixConnect(port);
   } else if (!gSystem->AccessPathName(servername) || servername[0] == '/') {
      return UnixUnixConnect(servername);
   }

   if (!strcmp(protocol, "udp")){
      return UnixUdpConnect(servername, port);
   }

   return UnixTcpConnect(servername, port, tcpwindowsize);
}

//______________________________________________________________________________
int TUnixSystem::OpenConnection(const char *server, int port, int tcpwindowsize, const char *protocol)
{
   // Open a connection to a service on a server. Returns -1 in case
   // connection cannot be opened.
   // Use tcpwindowsize to specify the size of the receive buffer, it has
   // to be specified here to make sure the window scale option is set (for
   // tcpwindowsize > 65KB and for platforms supporting window scaling).
   // Is called via the TSocket constructor.

   return ConnectService(server, port, tcpwindowsize, protocol);
}

//______________________________________________________________________________
int TUnixSystem::AnnounceTcpService(int port, Bool_t reuse, int backlog,
                                    int tcpwindowsize)
{
   // Announce TCP/IP service.
   // Open a socket, bind to it and start listening for TCP/IP connections
   // on the port. If reuse is true reuse the address, backlog specifies
   // how many sockets can be waiting to be accepted.
   // Use tcpwindowsize to specify the size of the receive buffer, it has
   // to be specified here to make sure the window scale option is set (for
   // tcpwindowsize > 65KB and for platforms supporting window scaling).
   // Returns socket fd or -1 if socket() failed, -2 if bind() failed
   // or -3 if listen() failed.

   return UnixTcpService(port, reuse, backlog, tcpwindowsize);
}

//______________________________________________________________________________
int TUnixSystem::AnnounceUdpService(int port, int backlog)
{
   // Announce UDP service.

   return UnixUdpService(port, backlog);
}

//______________________________________________________________________________
int TUnixSystem::AnnounceUnixService(int port, int backlog)
{
   // Announce unix domain service on path "kServerPath/<port>"

   return UnixUnixService(port, backlog);
}

//______________________________________________________________________________
int TUnixSystem::AnnounceUnixService(const char *sockpath, int backlog)
{
   // Announce unix domain service on path 'sockpath'

   return UnixUnixService(sockpath, backlog);
}

//______________________________________________________________________________
int TUnixSystem::AcceptConnection(int sock)
{
   // Accept a connection. In case of an error return -1. In case
   // non-blocking I/O is enabled and no connections are available
   // return -2.

   int soc = -1;

   while ((soc = ::accept(sock, 0, 0)) == -1 && GetErrno() == EINTR)
      ResetErrno();

   if (soc == -1) {
      if (GetErrno() == EWOULDBLOCK)
         return -2;
      else {
         SysError("AcceptConnection", "accept");
         return -1;
      }
   }

   return soc;
}

//______________________________________________________________________________
void TUnixSystem::CloseConnection(int sock, Bool_t force)
{
   // Close socket.

   if (sock < 0) return;

#if !defined(R__AIX) || defined(_AIX41) || defined(_AIX43)
   if (force)
      ::shutdown(sock, 2);   // will also close connection of parent
#endif

   while (::close(sock) == -1 && GetErrno() == EINTR)
      ResetErrno();
}

//______________________________________________________________________________
int TUnixSystem::RecvBuf(int sock, void *buf, int length)
{
   // Receive a buffer headed by a length indicator. Length is the size of
   // the buffer. Returns the number of bytes received in buf or -1 in
   // case of error.

   Int_t header;

   if (UnixRecv(sock, &header, sizeof(header), 0) > 0) {
      int count = ntohl(header);

      if (count > length) {
         Error("RecvBuf", "record header exceeds buffer size");
         return -1;
      } else if (count > 0) {
         if (UnixRecv(sock, buf, count, 0) < 0) {
            Error("RecvBuf", "cannot receive buffer");
            return -1;
         }
      }
      return count;
   }
   return -1;
}

//______________________________________________________________________________
int TUnixSystem::SendBuf(int sock, const void *buf, int length)
{
   // Send a buffer headed by a length indicator. Returns length of sent buffer
   // or -1 in case of error.

   Int_t header = htonl(length);

   if (UnixSend(sock, &header, sizeof(header), 0) < 0) {
      Error("SendBuf", "cannot send header");
      return -1;
   }
   if (length > 0) {
      if (UnixSend(sock, buf, length, 0) < 0) {
         Error("SendBuf", "cannot send buffer");
         return -1;
      }
   }
   return length;
}

//______________________________________________________________________________
int TUnixSystem::RecvRaw(int sock, void *buf, int length, int opt)
{
   // Receive exactly length bytes into buffer. Use opt to receive out-of-band
   // data or to have a peek at what is in the buffer (see TSocket). Buffer
   // must be able to store at least length bytes. Returns the number of
   // bytes received (can be 0 if other side of connection was closed) or -1
   // in case of error, -2 in case of MSG_OOB and errno == EWOULDBLOCK, -3
   // in case of MSG_OOB and errno == EINVAL and -4 in case of kNoBlock and
   // errno == EWOULDBLOCK. Returns -5 if pipe broken or reset by peer
   // (EPIPE || ECONNRESET).

   int flag;

   switch (opt) {
   case kDefault:
      flag = 0;
      break;
   case kOob:
      flag = MSG_OOB;
      break;
   case kPeek:
      flag = MSG_PEEK;
      break;
   case kDontBlock:
      flag = -1;
      break;
   default:
      flag = 0;
      break;
   }

   int n;
   if ((n = UnixRecv(sock, buf, length, flag)) <= 0) {
      if (n == -1 && GetErrno() != EINTR)
         Error("RecvRaw", "cannot receive buffer");
      return n;
   }
   return n;
}

//______________________________________________________________________________
int TUnixSystem::SendRaw(int sock, const void *buf, int length, int opt)
{
   // Send exactly length bytes from buffer. Use opt to send out-of-band
   // data (see TSocket). Returns the number of bytes sent or -1 in case of
   // error. Returns -4 in case of kNoBlock and errno == EWOULDBLOCK.
   // Returns -5 if pipe broken or reset by peer (EPIPE || ECONNRESET).

   int flag;

   switch (opt) {
   case kDefault:
      flag = 0;
      break;
   case kOob:
      flag = MSG_OOB;
      break;
   case kDontBlock:
      flag = -1;
      break;
   case kPeek:            // receive only option (see RecvRaw)
   default:
      flag = 0;
      break;
   }

   int n;
   if ((n = UnixSend(sock, buf, length, flag)) <= 0) {
      if (n == -1 && GetErrno() != EINTR)
         Error("SendRaw", "cannot send buffer");
      return n;
   }
   return n;
}

//______________________________________________________________________________
int TUnixSystem::SetSockOpt(int sock, int opt, int val)
{
   // Set socket option.

   if (sock < 0) return -1;

   switch (opt) {
   case kSendBuffer:
      if (setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char*)&val, sizeof(val)) == -1) {
         SysError("SetSockOpt", "setsockopt(SO_SNDBUF)");
         return -1;
      }
      break;
   case kRecvBuffer:
      if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char*)&val, sizeof(val)) == -1) {
         SysError("SetSockOpt", "setsockopt(SO_RCVBUF)");
         return -1;
      }
      break;
   case kOobInline:
      if (setsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (char*)&val, sizeof(val)) == -1) {
         SysError("SetSockOpt", "setsockopt(SO_OOBINLINE)");
         return -1;
      }
      break;
   case kKeepAlive:
      if (setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (char*)&val, sizeof(val)) == -1) {
         SysError("SetSockOpt", "setsockopt(SO_KEEPALIVE)");
         return -1;
      }
      break;
   case kReuseAddr:
      if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)&val, sizeof(val)) == -1) {
         SysError("SetSockOpt", "setsockopt(SO_REUSEADDR)");
         return -1;
      }
      break;
   case kNoDelay:
      if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char*)&val, sizeof(val)) == -1) {
         SysError("SetSockOpt", "setsockopt(TCP_NODELAY)");
         return -1;
      }
      break;
   case kNoBlock:
      if (ioctl(sock, FIONBIO, (char*)&val) == -1) {
         SysError("SetSockOpt", "ioctl(FIONBIO)");
         return -1;
      }
      break;
   case kProcessGroup:
#ifndef R__WINGCC
      if (ioctl(sock, SIOCSPGRP, (char*)&val) == -1) {
         SysError("SetSockOpt", "ioctl(SIOCSPGRP)");
         return -1;
      }
#else
      Error("SetSockOpt", "ioctl(SIOCGPGRP) not supported on cygwin/gcc");
      return -1;
#endif
      break;
   case kAtMark:       // read-only option (see GetSockOpt)
   case kBytesToRead:  // read-only option
   default:
      Error("SetSockOpt", "illegal option (%d)", opt);
      return -1;
   }
   return 0;
}

//______________________________________________________________________________
int TUnixSystem::GetSockOpt(int sock, int opt, int *val)
{
   // Get socket option.

   if (sock < 0) return -1;

#if defined(USE_SOCKLEN_T) || defined(_AIX43)
   socklen_t optlen = sizeof(*val);
#elif defined(USE_SIZE_T)
   size_t optlen = sizeof(*val);
#else
   int optlen = sizeof(*val);
#endif

   switch (opt) {
   case kSendBuffer:
      if (getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char*)val, &optlen) == -1) {
         SysError("GetSockOpt", "getsockopt(SO_SNDBUF)");
         return -1;
      }
      break;
   case kRecvBuffer:
      if (getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char*)val, &optlen) == -1) {
         SysError("GetSockOpt", "getsockopt(SO_RCVBUF)");
         return -1;
      }
      break;
   case kOobInline:
      if (getsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (char*)val, &optlen) == -1) {
         SysError("GetSockOpt", "getsockopt(SO_OOBINLINE)");
         return -1;
      }
      break;
   case kKeepAlive:
      if (getsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (char*)val, &optlen) == -1) {
         SysError("GetSockOpt", "getsockopt(SO_KEEPALIVE)");
         return -1;
      }
      break;
   case kReuseAddr:
      if (getsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)val, &optlen) == -1) {
         SysError("GetSockOpt", "getsockopt(SO_REUSEADDR)");
         return -1;
      }
      break;
   case kNoDelay:
      if (getsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char*)val, &optlen) == -1) {
         SysError("GetSockOpt", "getsockopt(TCP_NODELAY)");
         return -1;
      }
      break;
   case kNoBlock:
      int flg;
      if ((flg = fcntl(sock, F_GETFL, 0)) == -1) {
         SysError("GetSockOpt", "fcntl(F_GETFL)");
         return -1;
      }
      *val = flg & O_NDELAY;
      break;
   case kProcessGroup:
#if !defined(R__LYNXOS) && !defined(R__WINGCC)
      if (ioctl(sock, SIOCGPGRP, (char*)val) == -1) {
         SysError("GetSockOpt", "ioctl(SIOCGPGRP)");
         return -1;
      }
#else
      Error("GetSockOpt", "ioctl(SIOCGPGRP) not supported on LynxOS and cygwin/gcc");
      return -1;
#endif
      break;
   case kAtMark:
#if !defined(R__LYNXOS)
      if (ioctl(sock, SIOCATMARK, (char*)val) == -1) {
         SysError("GetSockOpt", "ioctl(SIOCATMARK)");
         return -1;
      }
#else
      Error("GetSockOpt", "ioctl(SIOCATMARK) not supported on LynxOS");
      return -1;
#endif
      break;
   case kBytesToRead:
#if !defined(R__LYNXOS)
      if (ioctl(sock, FIONREAD, (char*)val) == -1) {
         SysError("GetSockOpt", "ioctl(FIONREAD)");
         return -1;
      }
#else
      Error("GetSockOpt", "ioctl(FIONREAD) not supported on LynxOS");
      return -1;
#endif
      break;
   default:
      Error("GetSockOpt", "illegal option (%d)", opt);
      *val = 0;
      return -1;
   }
   return 0;
}

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// Static Protected Unix Interface functions.                           //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

//---- signals -----------------------------------------------------------------

static struct Signalmap_t {
   int               fCode;
   SigHandler_t      fHandler;
   struct sigaction *fOldHandler;
   const char       *fSigName;
} gSignalMap[kMAXSIGNALS] = {       // the order of the signals should be identical
   { SIGBUS,   0, 0, "bus error" }, // to the one in TSysEvtHandler.h
   { SIGSEGV,  0, 0, "segmentation violation" },
   { SIGSYS,   0, 0, "bad argument to system call" },
   { SIGPIPE,  0, 0, "write on a pipe with no one to read it" },
   { SIGILL,   0, 0, "illegal instruction" },
   { SIGQUIT,  0, 0, "quit" },
   { SIGINT,   0, 0, "interrupt" },
   { SIGWINCH, 0, 0, "window size change" },
   { SIGALRM,  0, 0, "alarm clock" },
   { SIGCHLD,  0, 0, "death of a child" },
   { SIGURG,   0, 0, "urgent data arrived on an I/O channel" },
   { SIGFPE,   0, 0, "floating point exception" },
   { SIGTERM,  0, 0, "termination signal" },
   { SIGUSR1,  0, 0, "user-defined signal 1" },
   { SIGUSR2,  0, 0, "user-defined signal 2" }
};


//______________________________________________________________________________
static void sighandler(int sig)
{
   // Call the signal handler associated with the signal.

   for (int i= 0; i < kMAXSIGNALS; i++) {
      if (gSignalMap[i].fCode == sig) {
         (*gSignalMap[i].fHandler)((ESignals)i);
         return;
      }
   }
}

//______________________________________________________________________________
void TUnixSystem::UnixSignal(ESignals sig, SigHandler_t handler)
{
   // Set a signal handler for a signal.

   if (gEnv && !gEnv->GetValue("Root.ErrorHandlers", 1))
      return;

   if (gSignalMap[sig].fHandler != handler) {
      struct sigaction sigact;

      gSignalMap[sig].fHandler    = handler;
      gSignalMap[sig].fOldHandler = new struct sigaction();

#if defined(R__SUN)
      sigact.sa_handler = (void (*)())sighandler;
#elif defined(R__SOLARIS)
      sigact.sa_handler = sighandler;
#elif defined(R__SGI) || defined(R__LYNXOS)
#  if defined(R__SGI64) || (__GNUG__>=3)
      sigact.sa_handler = sighandler;
#  else
      sigact.sa_handler = (void (*)(...))sighandler;
#  endif
#else
      sigact.sa_handler = sighandler;
#endif
      sigemptyset(&sigact.sa_mask);
      sigact.sa_flags = 0;
#if defined(SA_RESTART)
      sigact.sa_flags |= SA_RESTART;
#endif
      if (sigaction(gSignalMap[sig].fCode, &sigact,
                    gSignalMap[sig].fOldHandler) < 0)
         ::SysError("TUnixSystem::UnixSignal", "sigaction");
   }
}

//______________________________________________________________________________
void TUnixSystem::UnixIgnoreSignal(ESignals sig, Bool_t ignr)
{
   // If ignr is true ignore the specified signal, else restore previous
   // behaviour.

   TTHREAD_TLS(Bool_t) ignoreSig[kMAXSIGNALS] = { kFALSE };
   TTHREAD_TLS_ARRAY(struct sigaction,kMAXSIGNALS,oldsigact);

   if (ignr != ignoreSig[sig]) {
      ignoreSig[sig] = ignr;
      if (ignr) {
         struct sigaction sigact;
#if defined(R__SUN)
         sigact.sa_handler = (void (*)())SIG_IGN;
#elif defined(R__SOLARIS)
         sigact.sa_handler = (void (*)(int))SIG_IGN;
#else
         sigact.sa_handler = SIG_IGN;
#endif
         sigemptyset(&sigact.sa_mask);
         sigact.sa_flags = 0;
         if (sigaction(gSignalMap[sig].fCode, &sigact, &oldsigact[sig]) < 0)
            ::SysError("TUnixSystem::UnixIgnoreSignal", "sigaction");
      } else {
         if (sigaction(gSignalMap[sig].fCode, &oldsigact[sig], 0) < 0)
            ::SysError("TUnixSystem::UnixIgnoreSignal", "sigaction");
      }
   }
}

//______________________________________________________________________________
void TUnixSystem::UnixSigAlarmInterruptsSyscalls(Bool_t set)
{
   // When the argument is true the SIGALRM signal handler is set so that
   // interrupted syscalls will not be restarted by the kernel. This is
   // typically used in case one wants to put a timeout on an I/O operation.
   // By default interrupted syscalls will always be restarted (for all
   // signals). This can be controlled for each a-synchronous TTimer via
   // the method TTimer::SetInterruptSyscalls().

   if (gSignalMap[kSigAlarm].fHandler) {
      struct sigaction sigact;
#if defined(R__SUN)
      sigact.sa_handler = (void (*)())sighandler;
#elif defined(R__SOLARIS)
      sigact.sa_handler = sighandler;
#elif defined(R__SGI) || defined(R__LYNXOS)
#  if defined(R__SGI64) || (__GNUG__>=3)
      sigact.sa_handler = sighandler;
#  else
      sigact.sa_handler = (void (*)(...))sighandler;
#  endif
#else
      sigact.sa_handler = sighandler;
#endif
      sigemptyset(&sigact.sa_mask);
      sigact.sa_flags = 0;
      if (set) {
#if defined(SA_INTERRUPT)       // SunOS
         sigact.sa_flags |= SA_INTERRUPT;
#endif
      } else {
#if defined(SA_RESTART)
         sigact.sa_flags |= SA_RESTART;
#endif
      }
      if (sigaction(gSignalMap[kSigAlarm].fCode, &sigact, 0) < 0)
         ::SysError("TUnixSystem::UnixSigAlarmInterruptsSyscalls", "sigaction");
   }
}

//______________________________________________________________________________
const char *TUnixSystem::UnixSigname(ESignals sig)
{
   // Return the signal name associated with a signal.

   return gSignalMap[sig].fSigName;
}

//______________________________________________________________________________
void TUnixSystem::UnixResetSignal(ESignals sig)
{
   // Restore old signal handler for specified signal.

   if (gSignalMap[sig].fOldHandler) {
      // restore old signal handler
      if (sigaction(gSignalMap[sig].fCode, gSignalMap[sig].fOldHandler, 0) < 0)
         ::SysError("TUnixSystem::UnixSignal", "sigaction");
      delete gSignalMap[sig].fOldHandler;
      gSignalMap[sig].fOldHandler = 0;
      gSignalMap[sig].fHandler    = 0;
   }
}

//______________________________________________________________________________
void TUnixSystem::UnixResetSignals()
{
   // Restore old signal handlers.

   for (int sig = 0; sig < kMAXSIGNALS; sig++)
      UnixResetSignal((ESignals)sig);
}

//---- time --------------------------------------------------------------------

//______________________________________________________________________________
Long64_t TUnixSystem::UnixNow()
{
   // Get current time in milliseconds since 0:00 Jan 1 1995.

#if __cplusplus >= 201103L
   static std::atomic<time_t> jan95{0};
#else
   static time_t jan95 = 0;
#endif
   if (!jan95) {
      struct tm tp;
      tp.tm_year  = 95;
      tp.tm_mon   = 0;
      tp.tm_mday  = 1;
      tp.tm_hour  = 0;
      tp.tm_min   = 0;
      tp.tm_sec   = 0;
      tp.tm_isdst = -1;

      jan95 = mktime(&tp);
      if ((int)jan95 == -1) {
         ::SysError("TUnixSystem::UnixNow", "error converting 950001 0:00 to time_t");
         return 0;
      }
   }

   struct timeval t;
   gettimeofday(&t, 0);
   return Long64_t(t.tv_sec-(Long_t)jan95)*1000 + t.tv_usec/1000;
}

//______________________________________________________________________________
int TUnixSystem::UnixSetitimer(Long_t ms)
{
   // Set interval timer to time-out in ms milliseconds.

   struct itimerval itv;
   itv.it_value.tv_sec     = 0;
   itv.it_value.tv_usec    = 0;
   itv.it_interval.tv_sec  = 0;
   itv.it_interval.tv_usec = 0;
   if (ms > 0) {
      itv.it_value.tv_sec  = time_t(ms / 1000);
      itv.it_value.tv_usec = time_t((ms % 1000) * 1000);
   }
   int st = setitimer(ITIMER_REAL, &itv, 0);
   if (st == -1)
      ::SysError("TUnixSystem::UnixSetitimer", "setitimer");
   return st;
}

//---- file descriptors --------------------------------------------------------

//______________________________________________________________________________
int TUnixSystem::UnixSelect(Int_t nfds, TFdSet *readready, TFdSet *writeready,
                            Long_t timeout)
{
   // Wait for events on the file descriptors specified in the readready and
   // writeready masks or for timeout (in milliseconds) to occur. Returns
   // the number of ready descriptors, or 0 in case of timeout, or < 0 in
   // case of an error, with -2 being EINTR and -3 EBADF. In case of EINTR
   // the errno has been reset and the method can be called again.

   int retcode;

#if defined(R__HPUX) && defined(R__B64)
   fd_set frd;
   fd_set fwr;
   FD_ZERO(&frd);
   FD_ZERO(&fwr);
   for (int i = 0; i < nfds; i++) {
      if (readready  && readready->IsSet(i))  FD_SET(i, &frd);
      if (writeready && writeready->IsSet(i)) FD_SET(i, &fwr);
   }
   fd_set *rd = (readready)  ? &frd : 0;
   fd_set *wr = (writeready) ? &fwr : 0;
#else
   fd_set *rd = (readready)  ? (fd_set*)readready->GetBits()  : 0;
   fd_set *wr = (writeready) ? (fd_set*)writeready->GetBits() : 0;
#endif

   if (timeout >= 0) {
      struct timeval tv;
      tv.tv_sec  = Int_t(timeout / 1000);
      tv.tv_usec = (timeout % 1000) * 1000;
      retcode = select(nfds, rd, wr, 0, &tv);
   } else {
      retcode = select(nfds, rd, wr, 0, 0);
   }
   if (retcode == -1) {
      if (GetErrno() == EINTR) {
         ResetErrno();  // errno is not self reseting
         return -2;
      }
      if (GetErrno() == EBADF)
         return -3;
      return -1;
   }

#if defined(R__HPUX) && defined(R__B64)
   if (rd) readready->Zero();
   if (wr) writeready->Zero();
   for (int i = 0; i < nfds; i++) {
      if (rd && FD_ISSET(i, rd)) readready->Set(i);
      if (wr && FD_ISSET(i, wr)) writeready->Set(i);
   }
#endif

   return retcode;
}

//---- directories -------------------------------------------------------------

//______________________________________________________________________________
const char *TUnixSystem::UnixHomedirectory(const char *name)
{
   // Returns the user's home directory.

   static char path[kMAXPATHLEN], mydir[kMAXPATHLEN] = { '\0' };
   struct passwd *pw;

   if (name) {
      pw = getpwnam(name);
      if (pw) {
         strncpy(path, pw->pw_dir, kMAXPATHLEN-1);
         path[sizeof(path)-1] = '\0';
         return path;
      }
   } else {
      if (mydir[0])
         return mydir;
      pw = getpwuid(getuid());
      if (pw && pw->pw_dir) {
         strncpy(mydir, pw->pw_dir, kMAXPATHLEN-1);
         mydir[sizeof(mydir)-1] = '\0';
         return mydir;
      } else if (gSystem->Getenv("HOME")) {
         strncpy(mydir, gSystem->Getenv("HOME"), kMAXPATHLEN-1);
         mydir[sizeof(mydir)-1] = '\0';
         return mydir;
      }
   }
   return 0;
}

//______________________________________________________________________________
int TUnixSystem::UnixMakedir(const char *dir)
{
   // Make a Unix file system directory. Returns 0 in case of success and
   // -1 if the directory could not be created (either already exists or
   // illegal path name).

   return ::mkdir(StripOffProto(dir, "file:"), 0755);
}

//______________________________________________________________________________
void *TUnixSystem::UnixOpendir(const char *dir)
{
   // Open a directory.

   struct stat finfo;

   const char *edir = StripOffProto(dir, "file:");

   if (stat(edir, &finfo) < 0)
      return 0;

   if (!S_ISDIR(finfo.st_mode))
      return 0;

   return (void*) opendir(edir);
}

#if defined(_POSIX_SOURCE)
// Posix does not require that the d_ino field be present, and some
// systems do not provide it.
#   define REAL_DIR_ENTRY(dp) 1
#else
#   define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
#endif

//______________________________________________________________________________
const char *TUnixSystem::UnixGetdirentry(void *dirp1)
{
   // Returns the next directory entry.

   DIR *dirp = (DIR*)dirp1;
#ifdef HAS_DIRENT
   struct dirent *dp;
#else
   struct direct *dp;
#endif

   if (dirp) {
      for (;;) {
         dp = readdir(dirp);
         if (dp == 0)
            return 0;
         if (REAL_DIR_ENTRY(dp))
            return dp->d_name;
      }
   }
   return 0;
}

//---- files -------------------------------------------------------------------

//______________________________________________________________________________
int TUnixSystem::UnixFilestat(const char *fpath, FileStat_t &buf)
{
   // Get info about a file. Info is returned in the form of a FileStat_t
   // structure (see TSystem.h).
   // The function returns 0 in case of success and 1 if the file could
   // not be stat'ed.

   const char *path = StripOffProto(fpath, "file:");
   buf.fIsLink = kFALSE;

#if defined(R__SEEK64)
   struct stat64 sbuf;
   if (path && lstat64(path, &sbuf) == 0) {
#else
   struct stat sbuf;
   if (path && lstat(path, &sbuf) == 0) {
#endif
      buf.fIsLink = S_ISLNK(sbuf.st_mode);
      if (buf.fIsLink) {
#if defined(R__SEEK64)
         if (stat64(path, &sbuf) == -1) {
#else
         if (stat(path, &sbuf) == -1) {
#endif
            return 1;
         }
      }
      buf.fDev   = sbuf.st_dev;
      buf.fIno   = sbuf.st_ino;
      buf.fMode  = sbuf.st_mode;
      buf.fUid   = sbuf.st_uid;
      buf.fGid   = sbuf.st_gid;
      buf.fSize  = sbuf.st_size;
      buf.fMtime = sbuf.st_mtime;

      return 0;
   }
   return 1;
}

//______________________________________________________________________________
int TUnixSystem::UnixFSstat(const char *path, Long_t *id, Long_t *bsize,
                            Long_t *blocks, Long_t *bfree)
{
   // Get info about a file system: id, bsize, bfree, blocks.
   // Id      is file system type (machine dependend, see statfs())
   // Bsize   is block size of file system
   // Blocks  is total number of blocks in file system
   // Bfree   is number of free blocks in file system
   // The function returns 0 in case of success and 1 if the file system could
   // not be stat'ed.

   struct statfs statfsbuf;
#if defined(R__SGI) || (defined(R__SOLARIS) && !defined(R__LINUX))
   if (statfs(path, &statfsbuf, sizeof(struct statfs), 0) == 0) {
      *id = statfsbuf.f_fstyp;
      *bsize = statfsbuf.f_bsize;
      *blocks = statfsbuf.f_blocks;
      *bfree = statfsbuf.f_bfree;
#else
   if (statfs((char*)path, &statfsbuf) == 0) {
#ifdef R__OBSD
      // Convert BSD filesystem names to Linux filesystem type numbers
      // where possible.  Linux statfs uses a value of -1 to indicate
      // an unsupported field.

      if (!strcmp(statfsbuf.f_fstypename, MOUNT_FFS) ||
          !strcmp(statfsbuf.f_fstypename, MOUNT_MFS))
         *id = 0x11954;
      else if (!strcmp(statfsbuf.f_fstypename, MOUNT_NFS))
         *id = 0x6969;
      else if (!strcmp(statfsbuf.f_fstypename, MOUNT_MSDOS))
         *id = 0x4d44;
      else if (!strcmp(statfsbuf.f_fstypename, MOUNT_PROCFS))
         *id = 0x9fa0;
      else if (!strcmp(statfsbuf.f_fstypename, MOUNT_EXT2FS))
         *id = 0xef53;
      else if (!strcmp(statfsbuf.f_fstypename, MOUNT_CD9660))
         *id = 0x9660;
      else if (!strcmp(statfsbuf.f_fstypename, MOUNT_NCPFS))
         *id = 0x6969;
      else
         *id = -1;
#else
      *id = statfsbuf.f_type;
#endif
      *bsize = statfsbuf.f_bsize;
      *blocks = statfsbuf.f_blocks;
      *bfree = statfsbuf.f_bavail;
#endif
      return 0;
   }
   return 1;
}

//______________________________________________________________________________
int TUnixSystem::UnixWaitchild()
{
   // Wait till child is finished.

   int status;
   return (int) waitpid(0, &status, WNOHANG);
}

//---- RPC -------------------------------------------------------------------

//______________________________________________________________________________
int TUnixSystem::UnixTcpConnect(const char *hostname, int port,
                                int tcpwindowsize)
{
   // Open a TCP/IP connection to server and connect to a service (i.e. port).
   // Use tcpwindowsize to specify the size of the receive buffer, it has
   // to be specified here to make sure the window scale option is set (for
   // tcpwindowsize > 65KB and for platforms supporting window scaling).
   // Is called via the TSocket constructor. Returns -1 in case of error.

   short  sport;
   struct servent *sp;

   if ((sp = getservbyport(htons(port), kProtocolName)))
      sport = sp->s_port;
   else
      sport = htons(port);

   TInetAddress addr = gSystem->GetHostByName(hostname);
   if (!addr.IsValid()) return -1;
   UInt_t adr = htonl(addr.GetAddress());

   struct sockaddr_in server;
   memset(&server, 0, sizeof(server));
   memcpy(&server.sin_addr, &adr, sizeof(adr));
   server.sin_family = addr.GetFamily();
   server.sin_port   = sport;

   // Create socket
   int sock;
   if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
      ::SysError("TUnixSystem::UnixTcpConnect", "socket (%s:%d)",
                 hostname, port);
      return -1;
   }

   if (tcpwindowsize > 0) {
      gSystem->SetSockOpt(sock, kRecvBuffer, tcpwindowsize);
      gSystem->SetSockOpt(sock, kSendBuffer, tcpwindowsize);
   }

   while (connect(sock, (struct sockaddr*) &server, sizeof(server)) == -1) {
      if (GetErrno() == EINTR)
         ResetErrno();
      else {
         ::SysError("TUnixSystem::UnixTcpConnect", "connect (%s:%d)",
                    hostname, port);
         close(sock);
         return -1;
      }
   }
   return sock;
}


//______________________________________________________________________________
int TUnixSystem::UnixUdpConnect(const char *hostname, int port)
{
   // Creates a UDP socket connection
   // Is called via the TSocket constructor. Returns -1 in case of error.

   short  sport;
   struct servent *sp;

   if ((sp = getservbyport(htons(port), kProtocolName)))
      sport = sp->s_port;
   else
      sport = htons(port);

   TInetAddress addr = gSystem->GetHostByName(hostname);
   if (!addr.IsValid()) return -1;
   UInt_t adr = htonl(addr.GetAddress());

   struct sockaddr_in server;
   memset(&server, 0, sizeof(server));
   memcpy(&server.sin_addr, &adr, sizeof(adr));
   server.sin_family = addr.GetFamily();
   server.sin_port   = sport;

   // Create socket
   int sock;
   if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
      ::SysError("TUnixSystem::UnixUdpConnect", "socket (%s:%d)",
                 hostname, port);
      return -1;
   }

   while (connect(sock, (struct sockaddr*) &server, sizeof(server)) == -1) {
      if (GetErrno() == EINTR)
         ResetErrno();
      else {
         ::SysError("TUnixSystem::UnixUdpConnect", "connect (%s:%d)",
                    hostname, port);
         close(sock);
         return -1;
      }
   }
   return sock;
}

//______________________________________________________________________________
int TUnixSystem::UnixUnixConnect(int port)
{
   // Connect to a Unix domain socket.

   return UnixUnixConnect(TString::Format("%s/%d", kServerPath, port));
}

//______________________________________________________________________________
int TUnixSystem::UnixUnixConnect(const char *sockpath)
{
   // Connect to a Unix domain socket. Returns -1 in case of error.

   if (!sockpath || strlen(sockpath) <= 0) {
      ::SysError("TUnixSystem::UnixUnixConnect", "socket path undefined");
      return -1;
   }

   int sock;
   struct sockaddr_un unserver;
   unserver.sun_family = AF_UNIX;

   if (strlen(sockpath) > sizeof(unserver.sun_path)-1) {
      ::Error("TUnixSystem::UnixUnixConnect", "socket path %s, longer than max allowed length (%u)",
              sockpath, (UInt_t)sizeof(unserver.sun_path)-1);
      return -1;
   }
   strcpy(unserver.sun_path, sockpath);

   // Open socket
   if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
      ::SysError("TUnixSystem::UnixUnixConnect", "socket");
      return -1;
   }

   while (connect(sock, (struct sockaddr*) &unserver, strlen(unserver.sun_path)+2) == -1) {
      if (GetErrno() == EINTR)
         ResetErrno();
      else {
         ::SysError("TUnixSystem::UnixUnixConnect", "connect");
         close(sock);
         return -1;
      }
   }
   return sock;
}

//______________________________________________________________________________
int TUnixSystem::UnixTcpService(int port, Bool_t reuse, int backlog,
                                int tcpwindowsize)
{
   // Open a socket, bind to it and start listening for TCP/IP connections
   // on the port. If reuse is true reuse the address, backlog specifies
   // how many sockets can be waiting to be accepted. If port is 0 a port
   // scan will be done to find a free port. This option is mutual exlusive
   // with the reuse option.
   // Use tcpwindowsize to specify the size of the receive buffer, it has
   // to be specified here to make sure the window scale option is set (for
   // tcpwindowsize > 65KB and for platforms supporting window scaling).
   // Returns socket fd or -1 if socket() failed, -2 if bind() failed
   // or -3 if listen() failed.

   const short kSOCKET_MINPORT = 5000, kSOCKET_MAXPORT = 15000;
   short  sport, tryport = kSOCKET_MINPORT;
   struct servent *sp;

   if (port == 0 && reuse) {
      ::Error("TUnixSystem::UnixTcpService", "cannot do a port scan while reuse is true");
      return -1;
   }

   if ((sp = getservbyport(htons(port), kProtocolName)))
      sport = sp->s_port;
   else
      sport = htons(port);

   // Create tcp socket
   int sock;
   if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
      ::SysError("TUnixSystem::UnixTcpService", "socket");
      return -1;
   }

   if (reuse)
      gSystem->SetSockOpt(sock, kReuseAddr, 1);

   if (tcpwindowsize > 0) {
      gSystem->SetSockOpt(sock, kRecvBuffer, tcpwindowsize);
      gSystem->SetSockOpt(sock, kSendBuffer, tcpwindowsize);
   }

   struct sockaddr_in inserver;
   memset(&inserver, 0, sizeof(inserver));
   inserver.sin_family = AF_INET;
   inserver.sin_addr.s_addr = htonl(INADDR_ANY);
   inserver.sin_port = sport;

   // Bind socket
   if (port > 0) {
      if (::bind(sock, (struct sockaddr*) &inserver, sizeof(inserver))) {
         ::SysError("TUnixSystem::UnixTcpService", "bind");
         close(sock);
         return -2;
      }
   } else {
      int bret;
      do {
         inserver.sin_port = htons(tryport++);
         bret = ::bind(sock, (struct sockaddr*) &inserver, sizeof(inserver));
      } while (bret < 0 && GetErrno() == EADDRINUSE && tryport < kSOCKET_MAXPORT);
      if (bret < 0) {
         ::SysError("TUnixSystem::UnixTcpService", "bind (port scan)");
         close(sock);
         return -2;
      }
   }

   // Start accepting connections
   if (::listen(sock, backlog)) {
      ::SysError("TUnixSystem::UnixTcpService", "listen");
      close(sock);
      return -3;
   }

   return sock;
}

//______________________________________________________________________________
int TUnixSystem::UnixUdpService(int port, int backlog)
{
   // Open a socket, bind to it and start listening for UDP connections
   // on the port. If reuse is true reuse the address, backlog specifies
   // how many sockets can be waiting to be accepted. If port is 0 a port
   // scan will be done to find a free port. This option is mutual exlusive
   // with the reuse option.

   const short kSOCKET_MINPORT = 5000, kSOCKET_MAXPORT = 15000;
   short  sport, tryport = kSOCKET_MINPORT;
   struct servent *sp;

   if ((sp = getservbyport(htons(port), kProtocolName)))
      sport = sp->s_port;
   else
      sport = htons(port);

   // Create udp socket
   int sock;
   if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
      ::SysError("TUnixSystem::UnixUdpService", "socket");
      return -1;
   }

   struct sockaddr_in inserver;
   memset(&inserver, 0, sizeof(inserver));
   inserver.sin_family = AF_INET;
   inserver.sin_addr.s_addr = htonl(INADDR_ANY);
   inserver.sin_port = sport;

   // Bind socket
   if (port > 0) {
      if (::bind(sock, (struct sockaddr*) &inserver, sizeof(inserver))) {
         ::SysError("TUnixSystem::UnixUdpService", "bind");
         close(sock);
         return -2;
      }
   } else {
      int bret;
      do {
         inserver.sin_port = htons(tryport++);
         bret = ::bind(sock, (struct sockaddr*) &inserver, sizeof(inserver));
      } while (bret < 0 && GetErrno() == EADDRINUSE && tryport < kSOCKET_MAXPORT);
      if (bret < 0) {
         ::SysError("TUnixSystem::UnixUdpService", "bind (port scan)");
         close(sock);
         return -2;
      }
   }

   // Start accepting connections
   if (::listen(sock, backlog)) {
      ::SysError("TUnixSystem::UnixUdpService", "listen");
      close(sock);
      return -3;
   }

   return sock;
}

//______________________________________________________________________________
int TUnixSystem::UnixUnixService(int port, int backlog)
{
   // Open a socket, bind to it and start listening for Unix domain connections
   // to it. Returns socket fd or -1.

   int oldumask;

   // Assure that socket directory exists
   oldumask = umask(0);
   int res = ::mkdir(kServerPath, 0777);
   umask(oldumask);

   if (res == -1)
      return -1;

   // Socket path
   TString sockpath;
   sockpath.Form("%s/%d", kServerPath, port);

   // Remove old socket
   unlink(sockpath.Data());

   return UnixUnixService(sockpath, backlog);
}

//______________________________________________________________________________
int TUnixSystem::UnixUnixService(const char *sockpath, int backlog)
{
   // Open a socket on path 'sockpath', bind to it and start listening for Unix
   // domain connections to it. Returns socket fd or -1.

   if (!sockpath || strlen(sockpath) <= 0) {
      ::SysError("TUnixSystem::UnixUnixService", "socket path undefined");
      return -1;
   }

   struct sockaddr_un unserver;
   int sock;

   // Prepare structure
   memset(&unserver, 0, sizeof(unserver));
   unserver.sun_family = AF_UNIX;

   if (strlen(sockpath) > sizeof(unserver.sun_path)-1) {
      ::Error("TUnixSystem::UnixUnixService", "socket path %s, longer than max allowed length (%u)",
              sockpath, (UInt_t)sizeof(unserver.sun_path)-1);
      return -1;
   }
   strcpy(unserver.sun_path, sockpath);

   // Create socket
   if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
      ::SysError("TUnixSystem::UnixUnixService", "socket");
      return -1;
   }

   if (::bind(sock, (struct sockaddr*) &unserver, strlen(unserver.sun_path)+2)) {
      ::SysError("TUnixSystem::UnixUnixService", "bind");
      close(sock);
      return -1;
   }

   // Start accepting connections
   if (::listen(sock, backlog)) {
      ::SysError("TUnixSystem::UnixUnixService", "listen");
      close(sock);
      return -1;
   }

   return sock;
}

//______________________________________________________________________________
int TUnixSystem::UnixRecv(int sock, void *buffer, int length, int flag)
{
   // Receive exactly length bytes into buffer. Returns number of bytes
   // received. Returns -1 in case of error, -2 in case of MSG_OOB
   // and errno == EWOULDBLOCK, -3 in case of MSG_OOB and errno == EINVAL
   // and -4 in case of kNoBlock and errno == EWOULDBLOCK.
   // Returns -5 if pipe broken or reset by peer (EPIPE || ECONNRESET).

   ResetErrno();

   if (sock < 0) return -1;

   int once = 0;
   if (flag == -1) {
      flag = 0;
      once = 1;
   }
   if (flag == MSG_PEEK)
      once = 1;

   int n, nrecv = 0;
   char *buf = (char *)buffer;

   for (n = 0; n < length; n += nrecv) {
      if ((nrecv = recv(sock, buf+n, length-n, flag)) <= 0) {
         if (nrecv == 0)
            break;        // EOF
         if (flag == MSG_OOB) {
            if (GetErrno() == EWOULDBLOCK)
               return -2;
            else if (GetErrno() == EINVAL)
               return -3;
         }
         if (GetErrno() == EWOULDBLOCK)
            return -4;
         else {
            if (GetErrno() != EINTR)
               ::SysError("TUnixSystem::UnixRecv", "recv");
            if (GetErrno() == EPIPE || GetErrno() == ECONNRESET)
               return -5;
            else
               return -1;
         }
      }
      if (once)
         return nrecv;
   }
   return n;
}

//______________________________________________________________________________
int TUnixSystem::UnixSend(int sock, const void *buffer, int length, int flag)
{
   // Send exactly length bytes from buffer. Returns -1 in case of error,
   // otherwise number of sent bytes. Returns -4 in case of kNoBlock and
   // errno == EWOULDBLOCK. Returns -5 if pipe broken or reset by peer
   // (EPIPE || ECONNRESET).

   if (sock < 0) return -1;

   int once = 0;
   if (flag == -1) {
      flag = 0;
      once = 1;
   }

   int n, nsent = 0;
   const char *buf = (const char *)buffer;

   for (n = 0; n < length; n += nsent) {
      if ((nsent = send(sock, buf+n, length-n, flag)) <= 0) {
         if (nsent == 0)
            break;
         if (GetErrno() == EWOULDBLOCK)
            return -4;
         else {
            if (GetErrno() != EINTR)
               ::SysError("TUnixSystem::UnixSend", "send");
            if (GetErrno() == EPIPE || GetErrno() == ECONNRESET)
               return -5;
            else
               return -1;
         }
      }
      if (once)
         return nsent;
   }
   return n;
}

//---- Dynamic Loading ---------------------------------------------------------

//______________________________________________________________________________
static const char *DynamicPath(const char *newpath = 0, Bool_t reset = kFALSE)
{
   // Get shared library search path. Static utility function.

   static TString dynpath;
   static Bool_t initialized = kFALSE;

   if (newpath) {
      dynpath = newpath;
   } else if (reset || !initialized) {
      initialized = kTRUE;
      TString rdynpath = gEnv->GetValue("Root.DynamicPath", (char*)0);
      rdynpath.ReplaceAll(": ", ":");  // in case DynamicPath was extended
      if (rdynpath.IsNull()) {
#ifdef ROOTLIBDIR
         rdynpath = ".:"; rdynpath += ROOTLIBDIR;
#else
         rdynpath = ".:"; rdynpath += gRootDir; rdynpath += "/lib";
#endif
      }
      TString ldpath;
#if defined (R__AIX)
      ldpath = gSystem->Getenv("LIBPATH");
#elif defined(R__HPUX)
      ldpath = gSystem->Getenv("SHLIB_PATH");
#elif defined(R__MACOSX)
      ldpath = gSystem->Getenv("DYLD_LIBRARY_PATH");
      if (!ldpath.IsNull())
         ldpath += ":";
      ldpath += gSystem->Getenv("LD_LIBRARY_PATH");
      if (!ldpath.IsNull())
         ldpath += ":";
      ldpath += gSystem->Getenv("DYLD_FALLBACK_LIBRARY_PATH");
#else
      ldpath = gSystem->Getenv("LD_LIBRARY_PATH");
#endif
      if (ldpath.IsNull())
         dynpath = rdynpath;
      else {
         dynpath = ldpath; dynpath += ":"; dynpath += rdynpath;
      }

#ifdef ROOTLIBDIR
      if (!dynpath.Contains(ROOTLIBDIR)) {
         dynpath += ":"; dynpath += ROOTLIBDIR;
      }
#else
      if (!dynpath.Contains(TString::Format("%s/lib", gRootDir))) {
         dynpath += ":"; dynpath += gRootDir; dynpath += "/lib";
      }
#endif
      dynpath += ":"; dynpath += gInterpreter->GetSTLIncludePath();
   }
   return dynpath;
}

//______________________________________________________________________________
void TUnixSystem::AddDynamicPath(const char *path)
{
   // Add a new directory to the dynamic path.

   if (path) {
      TString oldpath = DynamicPath(0, kFALSE);
      oldpath.Append(":");
      oldpath.Append(path);
      DynamicPath(oldpath);
   }
}

//______________________________________________________________________________
const char *TUnixSystem::GetDynamicPath()
{
   // Return the dynamic path (used to find shared libraries).

   return DynamicPath(0, kFALSE);
}

//______________________________________________________________________________
void TUnixSystem::SetDynamicPath(const char *path)
{
   // Set the dynamic path to a new value.
   // If the value of 'path' is zero, the dynamic path is reset to its
   // default value.

   if (!path)
      DynamicPath(0, kTRUE);
   else
      DynamicPath(path);
}

//______________________________________________________________________________
char *TUnixSystem::DynamicPathName(const char *lib, Bool_t quiet)
{
   // Returns the path of a shared library (searches for library in the
   // shared library search path). If no file name extension is provided
   // it first tries .so, .sl, .dl and then .a (for AIX). The returned string
   // must be deleted.

   char *name;

   int ext = 0, len = strlen(lib);
#ifdef __APPLE__
   // On a MAC, a library might not have any extensions, so let's try the raw
   // name first.
   name = gSystem->Which(GetDynamicPath(), lib, kReadPermission);
   if (name) {
      return name;
   }
#endif
   if (len > 3 && (!strcmp(lib+len-3, ".so")    ||
                   !strcmp(lib+len-3, ".dl")    ||
                   !strcmp(lib+len-4, ".dll")   ||
                   !strcmp(lib+len-4, ".DLL")   ||
                   !strcmp(lib+len-6, ".dylib") ||
                   !strcmp(lib+len-3, ".sl")    ||
                   !strcmp(lib+len-2, ".a"))) {
      name = gSystem->Which(GetDynamicPath(), lib, kReadPermission);
      ext  = 1;
   } else {
      TString fname;
      fname.Form("%s.so", lib);
      name = gSystem->Which(GetDynamicPath(), fname, kReadPermission);
      if (!name) {
         fname.Form("%s.dll", lib);
         name = gSystem->Which(GetDynamicPath(), fname, kReadPermission);
         if (!name) {
            fname.Form("%s.dylib", lib);
            name = gSystem->Which(GetDynamicPath(), fname, kReadPermission);
            if (!name) {
               fname.Form("%s.sl", lib);
               name = gSystem->Which(GetDynamicPath(), fname, kReadPermission);
               if (!name) {
                  fname.Form("%s.dl", lib);
                  name = gSystem->Which(GetDynamicPath(), fname, kReadPermission);
                  if (!name) {
                     fname.Form("%s.a", lib);
                     name = gSystem->Which(GetDynamicPath(), fname, kReadPermission);
                  }
               }
            }
         }
      }
   }

   if (!name && !quiet) {
      if (ext)
         Error("DynamicPathName",
               "%s does not exist in %s", lib, GetDynamicPath());
      else
         Error("DynamicPathName",
               "%s[.so | .dll | .dylib | .sl | .dl | .a] does not exist in %s", lib, GetDynamicPath());
   }

   return name;
}

//______________________________________________________________________________
void *TUnixSystem::FindDynLib(const char *lib)
{
   // Returns the handle to a loaded shared library. Returns 0 when library
   // not loaded.

#ifdef R__HPUX
   const char *path;

   if ((path = gSystem->DynamicPathName(lib))) {
      // find handle of shared library using its name
      struct shl_descriptor *desc;
      int index = 0;
      while (shl_get(index++, &desc) == 0)
         if (!strcmp(path, desc->filename))
            return desc->handle;
   }
#endif

   if (lib) { }  // avoid warning, use lib

   return 0;
}

//______________________________________________________________________________
int TUnixSystem::UnixDynLoad(const char *lib)
{
   // Load a shared library. Returns 0 on successful loading, 1 in
   // case lib was already loaded and -1 in case lib does not exist
   // or in case of error.

   const char *path;

   if ((path = gSystem->DynamicPathName(lib))) {
#if defined(R__HPUX)
#if !defined(__STDCPP__)
      shl_t handle = cxxshl_load(path, BIND_IMMEDIATE | BIND_NONFATAL, 0L);
#else
      shl_t handle = shl_load(path, BIND_IMMEDIATE | BIND_NONFATAL, 0L);
#endif
      if (handle != 0) return 0;
#else
      if (path) { }  // use path remove warning
      ::Error("TUnixSystem::UnixDynLoad", "not yet implemented for this platform");
      return -1;
#endif
   }
   return -1;
}

//______________________________________________________________________________
Func_t TUnixSystem::UnixDynFindSymbol(const char *lib, const char *entry)
{
   // Finds and returns a function pointer to a symbol in the shared library.
   // Returns 0 when symbol not found.

#if defined(R__HPUX) && !defined(R__GNU)
   shl_t handle;

   if (handle = (shl_t)FindDynLib(lib)) {
      Func_t addr = 0;
      if (shl_findsym(&handle, entry, TYPE_PROCEDURE, addr) == -1)
         ::SysError("TUnixSystem::UnixDynFindSymbol", "shl_findsym");
      return addr;
   }
   return 0;
#else
   if (lib || entry) { }

   // Always assume symbol not found
   return 0;
#endif
}

//______________________________________________________________________________
void TUnixSystem::UnixDynListSymbols(const char *lib, const char *regexp)
{
   // List symbols in a shared library. One can use wildcards to list only
   // the interesting symbols.

#if defined(R__HPUX) && !defined(R__GNU)
   shl_t handle;

   if (handle = (shl_t)FindDynLib(lib)) {
      struct shl_symbol *symbols;
      int nsym = shl_getsymbols(handle, TYPE_PROCEDURE,
                                EXPORT_SYMBOLS|NO_VALUES, (void *(*)())malloc,
                                &symbols);
      if (nsym != -1) {
         if (nsym > 0) {
            int cnt = 0;
            TRegexp *re = 0;
            if (regexp && strlen(regexp)) re = new TRegexp(regexp, kTRUE);
            Printf("");
            Printf("Functions exported by library %s", gSystem->DynamicPathName(lib));
            Printf("=========================================================");
            for (int i = 0; i < nsym; i++)
               if (symbols[i].type == TYPE_PROCEDURE) {
                  cnt++;
                  char *dsym = cplus_demangle(symbols[i].name,
                                              DMGL_PARAMS|DMGL_ANSI|DMGL_ARM);
                  if (re) {
                     TString s = dsym;
                     if (s.Index(*re) != kNPOS) Printf("%s", dsym);
                  } else
                     Printf("%s", dsym);
                  free(dsym);
               }
            Printf("---------------------------------------------------------");
            Printf("%d exported functions", cnt);
            Printf("=========================================================");
            delete re;
         }
         free(symbols);
      }
   }
#endif
   if (lib || regexp) { }
}

//______________________________________________________________________________
void TUnixSystem::UnixDynListLibs(const char *lib)
{
   // List all loaded shared libraries.

#if defined(R__HPUX) && !defined(R__GNU)
   TRegexp *re = 0;
   if (lib && strlen(lib)) re = new TRegexp(lib, kTRUE);
   struct shl_descriptor *desc;
   int index = 0;

   Printf("");
   Printf("Loaded shared libraries");
   Printf("=======================");

   while (shl_get(index++, &desc) == 0)
      if (re) {
         TString s = desc->filename;
         if (s.Index(*re) != kNPOS) Printf("%s", desc->filename);
      } else
         Printf("%s", desc->filename);
   Printf("-----------------------");
   Printf("%d libraries loaded", index-1);
   Printf("=======================");
   delete re;
#else
   if (lib) { }
#endif
}

//______________________________________________________________________________
void TUnixSystem::UnixDynUnload(const char *lib)
{
   // Unload a shared library.

#if defined(R__HPUX)
   shl_t handle;

   if (handle = (shl_t)FindDynLib(lib))
#if !defined(__STDCPP__)
      if (cxxshl_unload(handle) == -1)
#else
      if (shl_unload(handle) == -1)
#endif
         ::SysError("TUnixSystem::UnixDynUnload", "could not unload library %s", lib);
#else
   if (lib) { }
   // should call CINT unload file here, but does not work for sl's yet.
   ::Error("TUnixSystem::UnixDynUnload", "not yet implemented for this platform");
#endif
}

//---- System, CPU and Memory info ---------------------------------------------

#if defined(R__MACOSX)
#include <sys/resource.h>
#include <mach/mach.h>
#include <mach/mach_error.h>

//______________________________________________________________________________
static void GetDarwinSysInfo(SysInfo_t *sysinfo)
{
   // Get system info for Mac OS X.

   FILE *p = gSystem->OpenPipe("sysctl -n kern.ostype hw.model hw.ncpu hw.cpufrequency "
                               "hw.busfrequency hw.l2cachesize hw.memsize", "r");
   TString s;
   s.Gets(p);
   sysinfo->fOS = s;
   s.Gets(p);
   sysinfo->fModel = s;
   s.Gets(p);
   sysinfo->fCpus = s.Atoi();
   s.Gets(p);
   Long64_t t = s.Atoll();
   sysinfo->fCpuSpeed = Int_t(t / 1000000);
   s.Gets(p);
   t = s.Atoll();
   sysinfo->fBusSpeed = Int_t(t / 1000000);
   s.Gets(p);
   sysinfo->fL2Cache = s.Atoi() / 1024;
   s.Gets(p);
   t = s.Atoll();
   sysinfo->fPhysRam = Int_t(t / 1024 / 1024);
   gSystem->ClosePipe(p);
   p = gSystem->OpenPipe("hostinfo", "r");
   while (s.Gets(p)) {
      if (s.BeginsWith("Processor type: ")) {
         TPRegexp("Processor type: ([^ ]+).*").Substitute(s, "$1");
         sysinfo->fCpuType = s;
      }
   }
   gSystem->ClosePipe(p);
}

//______________________________________________________________________________
static void ReadDarwinCpu(long *ticks)
{
   // Get CPU load on Mac OS X.

   mach_msg_type_number_t count;
   kern_return_t kr;
   host_cpu_load_info_data_t cpu;

   ticks[0] = ticks[1] = ticks[2] = ticks[3] = 0;

   count = HOST_CPU_LOAD_INFO_COUNT;
   kr = host_statistics(mach_host_self(), HOST_CPU_LOAD_INFO, (host_info_t)&cpu, &count);
   if (kr != KERN_SUCCESS) {
      ::Error("TUnixSystem::ReadDarwinCpu", "host_statistics: %s", mach_error_string(kr));
   } else {
      ticks[0] = cpu.cpu_ticks[CPU_STATE_USER];
      ticks[1] = cpu.cpu_ticks[CPU_STATE_SYSTEM];
      ticks[2] = cpu.cpu_ticks[CPU_STATE_IDLE];
      ticks[3] = cpu.cpu_ticks[CPU_STATE_NICE];
   }
}

//______________________________________________________________________________
static void GetDarwinCpuInfo(CpuInfo_t *cpuinfo, Int_t sampleTime)
{
   // Get CPU stat for Mac OS X. Use sampleTime to set the interval over which
   // the CPU load will be measured, in ms (default 1000).

   Double_t avg[3];
   if (getloadavg(avg, sizeof(avg)) < 0) {
      ::Error("TUnixSystem::GetDarwinCpuInfo", "getloadavg failed");
   } else {
      cpuinfo->fLoad1m  = (Float_t)avg[0];
      cpuinfo->fLoad5m  = (Float_t)avg[1];
      cpuinfo->fLoad15m = (Float_t)avg[2];
   }

   Long_t cpu_ticks1[4], cpu_ticks2[4];
   ReadDarwinCpu(cpu_ticks1);
   gSystem->Sleep(sampleTime);
   ReadDarwinCpu(cpu_ticks2);

   Long_t userticks = (cpu_ticks2[0] + cpu_ticks2[3]) -
                      (cpu_ticks1[0] + cpu_ticks1[3]);
   Long_t systicks  = cpu_ticks2[1] - cpu_ticks1[1];
   Long_t idleticks = cpu_ticks2[2] - cpu_ticks1[2];
   if (userticks < 0) userticks = 0;
   if (systicks < 0)  systicks = 0;
   if (idleticks < 0) idleticks = 0;
   Long_t totalticks = userticks + systicks + idleticks;
   if (totalticks) {
      cpuinfo->fUser  = ((Float_t)(100 * userticks)) / ((Float_t)totalticks);
      cpuinfo->fSys   = ((Float_t)(100 * systicks))  / ((Float_t)totalticks);
      cpuinfo->fTotal = cpuinfo->fUser + cpuinfo->fSys;
      cpuinfo->fIdle  = ((Float_t)(100 * idleticks)) / ((Float_t)totalticks);
   }
}

//______________________________________________________________________________
static void GetDarwinMemInfo(MemInfo_t *meminfo)
{
   // Get VM stat for Mac OS X.

   static Int_t pshift = 0;
   static DIR *dirp;
   vm_statistics_data_t vm_info;
   mach_msg_type_number_t count;
   kern_return_t kr;
   struct dirent *dp;
   Long64_t total, used, free, swap_total, swap_used;

   count = HOST_VM_INFO_COUNT;
   kr = host_statistics(mach_host_self(), HOST_VM_INFO, (host_info_t)&vm_info, &count);
   if (kr != KERN_SUCCESS) {
      ::Error("TUnixSystem::GetDarwinMemInfo", "host_statistics: %s", mach_error_string(kr));
      return;
   }
   if (pshift == 0) {
      for (int psize = getpagesize(); psize > 1; psize >>= 1)
         pshift++;
   }

   used =  (Long64_t)(vm_info.active_count + vm_info.inactive_count + vm_info.wire_count) << pshift;
   free =  (Long64_t)(vm_info.free_count) << pshift;
   total = (Long64_t)(vm_info.active_count + vm_info.inactive_count + vm_info.free_count + vm_info.wire_count) << pshift;

   // Swap is available at same time as mem, so grab values here.
   swap_used = vm_info.pageouts << pshift;

   // Figure out total swap. This adds up the size of the swapfiles */
   dirp = opendir("/private/var/vm");
   if (!dirp)
       return;

   swap_total = 0;
   while ((dp = readdir(dirp)) != 0) {
      struct stat sb;
      char fname [MAXNAMLEN];
      if (strncmp(dp->d_name, "swapfile", 8))
         continue;
      strlcpy(fname, "/private/var/vm/",MAXNAMLEN);
      strlcat (fname, dp->d_name,MAXNAMLEN);
      if (stat(fname, &sb) < 0)
         continue;
      swap_total += sb.st_size;
   }
   closedir(dirp);

   meminfo->fMemTotal  = (Int_t) (total >> 20);       // divide by 1024 * 1024
   meminfo->fMemUsed   = (Int_t) (used >> 20);
   meminfo->fMemFree   = (Int_t) (free >> 20);
   meminfo->fSwapTotal = (Int_t) (swap_total >> 20);
   meminfo->fSwapUsed  = (Int_t) (swap_used >> 20);
   meminfo->fSwapFree  = meminfo->fSwapTotal - meminfo->fSwapUsed;
}

//______________________________________________________________________________
static void GetDarwinProcInfo(ProcInfo_t *procinfo)
{
   // Get process info for this process on Mac OS X.
   // Code largely taken from:
   // http://www.opensource.apple.com/source/top/top-15/libtop.c
   // The virtual memory usage is slightly over estimated as we don't
   // subtract shared regions, but the value makes more sense
   // then pure vsize, which is useless on 64-bit machines.

#ifdef _LP64
#define vm_region vm_region_64
#endif

// taken from <mach/shared_memory_server.h> which is obsoleted in 10.5
#define GLOBAL_SHARED_TEXT_SEGMENT      0x90000000U
#define GLOBAL_SHARED_DATA_SEGMENT      0xA0000000U
#define SHARED_TEXT_REGION_SIZE         0x10000000
#define SHARED_DATA_REGION_SIZE         0x10000000

   struct rusage ru;
   if (getrusage(RUSAGE_SELF, &ru) < 0) {
      ::SysError("TUnixSystem::GetDarwinProcInfo", "getrusage failed");
   } else {
      procinfo->fCpuUser = (Float_t)(ru.ru_utime.tv_sec) +
                           ((Float_t)(ru.ru_utime.tv_usec) / 1000000.);
      procinfo->fCpuSys  = (Float_t)(ru.ru_stime.tv_sec) +
                           ((Float_t)(ru.ru_stime.tv_usec) / 1000000.);
   }

   task_basic_info_data_t ti;
   mach_msg_type_number_t count;
   kern_return_t kr;

   task_t a_task = mach_task_self();

   count = TASK_BASIC_INFO_COUNT;
   kr = task_info(a_task, TASK_BASIC_INFO, (task_info_t)&ti, &count);
   if (kr != KERN_SUCCESS) {
      ::Error("TUnixSystem::GetDarwinProcInfo", "task_info: %s", mach_error_string(kr));
   } else {
      // resident size does not require any calculation. Virtual size
      // needs to be adjusted if traversing memory objects do not include the
      // globally shared text and data regions
      mach_port_t object_name;
      vm_address_t address;
      vm_region_top_info_data_t info;
      vm_size_t vsize, vprvt, rsize, size;
      rsize = ti.resident_size;
      vsize = ti.virtual_size;
      vprvt = 0;
      for (address = 0; ; address += size) {
         // get memory region
         count = VM_REGION_TOP_INFO_COUNT;
         if (vm_region(a_task, &address, &size,
                       VM_REGION_TOP_INFO, (vm_region_info_t)&info, &count,
                       &object_name) != KERN_SUCCESS) {
            // no more memory regions.
            break;
         }

         if (address >= GLOBAL_SHARED_TEXT_SEGMENT &&
             address < (GLOBAL_SHARED_DATA_SEGMENT + SHARED_DATA_REGION_SIZE)) {
            // This region is private shared.
            // Check if this process has the globally shared
            // text and data regions mapped in. If so, adjust
            // virtual memory size and exit loop.
            if (info.share_mode == SM_EMPTY) {
               vm_region_basic_info_data_64_t b_info;
               count = VM_REGION_BASIC_INFO_COUNT_64;
               if (vm_region_64(a_task, &address,
                                &size, VM_REGION_BASIC_INFO,
                                (vm_region_info_t)&b_info, &count,
                                &object_name) != KERN_SUCCESS) {
                  break;
               }

               if (b_info.reserved) {
                  vsize -= (SHARED_TEXT_REGION_SIZE + SHARED_DATA_REGION_SIZE);
                  //break;  // only for vsize
               }
            }
            // Short circuit the loop if this isn't a shared
            // private region, since that's the only region
            // type we care about within the current address range.
            if (info.share_mode != SM_PRIVATE) {
               continue;
            }
         }
         switch (info.share_mode) {
            case SM_COW: {
               if (info.ref_count == 1) {
                  vprvt += size;
               } else {
                  vprvt += info.private_pages_resident * getpagesize();
               }
               break;
            }
            case SM_PRIVATE: {
               vprvt += size;
               break;
            }
            default:
               break;
         }
      }

      procinfo->fMemResident = (Long_t)(rsize / 1024);
      //procinfo->fMemVirtual  = (Long_t)(vsize / 1024);
      procinfo->fMemVirtual  = (Long_t)(vprvt / 1024);
   }
}
#endif

#if defined(R__LINUX)
//______________________________________________________________________________
static void GetLinuxSysInfo(SysInfo_t *sysinfo)
{
   // Get system info for Linux. Only fBusSpeed is not set.

   TString s;
   FILE *f = fopen("/proc/cpuinfo", "r");
   if (f) {
      while (s.Gets(f)) {
         if (s.BeginsWith("model name")) {
            TPRegexp("^.+: *(.*$)").Substitute(s, "$1");
            sysinfo->fModel = s;
         }
         if (s.BeginsWith("cpu MHz")) {
            TPRegexp("^.+: *([^ ]+).*").Substitute(s, "$1");
            sysinfo->fCpuSpeed = s.Atoi();
         }
         if (s.BeginsWith("cache size")) {
            TPRegexp("^.+: *([^ ]+).*").Substitute(s, "$1");
            sysinfo->fL2Cache = s.Atoi();
         }
         if (s.BeginsWith("processor")) {
            TPRegexp("^.+: *([^ ]+).*").Substitute(s, "$1");
            sysinfo->fCpus = s.Atoi();
            sysinfo->fCpus++;
         }
      }
      fclose(f);
   }

   f = fopen("/proc/meminfo", "r");
   if (f) {
      while (s.Gets(f)) {
         if (s.BeginsWith("MemTotal")) {
            TPRegexp("^.+: *([^ ]+).*").Substitute(s, "$1");
            sysinfo->fPhysRam = (s.Atoi() / 1024);
            break;
         }
      }
      fclose(f);
   }

   f = gSystem->OpenPipe("uname -s -p", "r");
   if (f) {
      s.Gets(f);
      Ssiz_t from = 0;
      s.Tokenize(sysinfo->fOS, from);
      s.Tokenize(sysinfo->fCpuType, from);
      gSystem->ClosePipe(f);
   }
}

//______________________________________________________________________________
static void ReadLinuxCpu(long *ticks)
{
   // Get CPU load on Linux.

   ticks[0] = ticks[1] = ticks[2] = ticks[3] = 0;

   TString s;
   FILE *f = fopen("/proc/stat", "r");
   if (!f) return;
   s.Gets(f);
   // user, user nice, sys, idle
   sscanf(s.Data(), "%*s %ld %ld %ld %ld", &ticks[0], &ticks[3], &ticks[1], &ticks[2]);
   fclose(f);
}

//______________________________________________________________________________
static void GetLinuxCpuInfo(CpuInfo_t *cpuinfo, Int_t sampleTime)
{
   // Get CPU stat for Linux. Use sampleTime to set the interval over which
   // the CPU load will be measured, in ms (default 1000).

   Double_t avg[3] = { -1., -1., -1. };
#ifndef R__WINGCC
   if (getloadavg(avg, sizeof(avg)) < 0) {
      ::Error("TUnixSystem::GetLinuxCpuInfo", "getloadavg failed");
   } else
#endif
   {
      cpuinfo->fLoad1m  = (Float_t)avg[0];
      cpuinfo->fLoad5m  = (Float_t)avg[1];
      cpuinfo->fLoad15m = (Float_t)avg[2];
   }

   Long_t cpu_ticks1[4], cpu_ticks2[4];
   ReadLinuxCpu(cpu_ticks1);
   gSystem->Sleep(sampleTime);
   ReadLinuxCpu(cpu_ticks2);

   Long_t userticks = (cpu_ticks2[0] + cpu_ticks2[3]) -
                      (cpu_ticks1[0] + cpu_ticks1[3]);
   Long_t systicks  = cpu_ticks2[1] - cpu_ticks1[1];
   Long_t idleticks = cpu_ticks2[2] - cpu_ticks1[2];
   if (userticks < 0) userticks = 0;
   if (systicks < 0)  systicks = 0;
   if (idleticks < 0) idleticks = 0;
   Long_t totalticks = userticks + systicks + idleticks;
   if (totalticks) {
      cpuinfo->fUser  = ((Float_t)(100 * userticks)) / ((Float_t)totalticks);
      cpuinfo->fSys   = ((Float_t)(100 * systicks))  / ((Float_t)totalticks);
      cpuinfo->fTotal = cpuinfo->fUser + cpuinfo->fSys;
      cpuinfo->fIdle  = ((Float_t)(100 * idleticks)) / ((Float_t)totalticks);
   }
}

//______________________________________________________________________________
static void GetLinuxMemInfo(MemInfo_t *meminfo)
{
   // Get VM stat for Linux.

   TString s;
   FILE *f = fopen("/proc/meminfo", "r");
   if (!f) return;
   while (s.Gets(f)) {
      if (s.BeginsWith("MemTotal")) {
         TPRegexp("^.+: *([^ ]+).*").Substitute(s, "$1");
         meminfo->fMemTotal = (s.Atoi() / 1024);
      }
      if (s.BeginsWith("MemFree")) {
         TPRegexp("^.+: *([^ ]+).*").Substitute(s, "$1");
         meminfo->fMemFree = (s.Atoi() / 1024);
      }
      if (s.BeginsWith("SwapTotal")) {
         TPRegexp("^.+: *([^ ]+).*").Substitute(s, "$1");
         meminfo->fSwapTotal = (s.Atoi() / 1024);
      }
      if (s.BeginsWith("SwapFree")) {
         TPRegexp("^.+: *([^ ]+).*").Substitute(s, "$1");
         meminfo->fSwapFree = (s.Atoi() / 1024);
      }
   }
   fclose(f);

   meminfo->fMemUsed  = meminfo->fMemTotal - meminfo->fMemFree;
   meminfo->fSwapUsed = meminfo->fSwapTotal - meminfo->fSwapFree;
}

//______________________________________________________________________________
static void GetLinuxProcInfo(ProcInfo_t *procinfo)
{
   // Get process info for this process on Linux.

   struct rusage ru;
   if (getrusage(RUSAGE_SELF, &ru) < 0) {
      ::SysError("TUnixSystem::GetLinuxProcInfo", "getrusage failed");
   } else {
      procinfo->fCpuUser = (Float_t)(ru.ru_utime.tv_sec) +
                           ((Float_t)(ru.ru_utime.tv_usec) / 1000000.);
      procinfo->fCpuSys  = (Float_t)(ru.ru_stime.tv_sec) +
                           ((Float_t)(ru.ru_stime.tv_usec) / 1000000.);
   }

   procinfo->fMemVirtual  = -1;
   procinfo->fMemResident = -1;
   TString s;
   FILE *f = fopen(TString::Format("/proc/%d/statm", gSystem->GetPid()), "r");
   if (f) {
      s.Gets(f);
      fclose(f);
      Long_t total, rss;
      sscanf(s.Data(), "%ld %ld", &total, &rss);
      procinfo->fMemVirtual  = total * (getpagesize() / 1024);
      procinfo->fMemResident = rss * (getpagesize() / 1024);
   }
}
#endif

//______________________________________________________________________________
int TUnixSystem::GetSysInfo(SysInfo_t *info) const
{
   // Returns static system info, like OS type, CPU type, number of CPUs
   // RAM size, etc into the SysInfo_t structure. Returns -1 in case of error,
   // 0 otherwise.

   if (!info) return -1;

   static SysInfo_t sysinfo;

   if (!sysinfo.fCpus) {
#if defined(R__MACOSX)
      GetDarwinSysInfo(&sysinfo);
#elif defined(R__LINUX)
      GetLinuxSysInfo(&sysinfo);
#endif
   }

   *info = sysinfo;

   return 0;
}

//______________________________________________________________________________
int TUnixSystem::GetCpuInfo(CpuInfo_t *info, Int_t sampleTime) const
{
   // Returns cpu load average and load info into the CpuInfo_t structure.
   // Returns -1 in case of error, 0 otherwise. Use sampleTime to set the
   // interval over which the CPU load will be measured, in ms (default 1000).

   if (!info) return -1;

#if defined(R__MACOSX)
   GetDarwinCpuInfo(info, sampleTime);
#elif defined(R__LINUX)
   GetLinuxCpuInfo(info, sampleTime);
#endif

   return 0;
}

//______________________________________________________________________________
int TUnixSystem::GetMemInfo(MemInfo_t *info) const
{
   // Returns ram and swap memory usage info into the MemInfo_t structure.
   // Returns -1 in case of error, 0 otherwise.

   if (!info) return -1;

#if defined(R__MACOSX)
   GetDarwinMemInfo(info);
#elif defined(R__LINUX)
   GetLinuxMemInfo(info);
#endif

   return 0;
}

//______________________________________________________________________________
int TUnixSystem::GetProcInfo(ProcInfo_t *info) const
{
   // Returns cpu and memory used by this process into the ProcInfo_t structure.
   // Returns -1 in case of error, 0 otherwise.

   if (!info) return -1;

#if defined(R__MACOSX)
   GetDarwinProcInfo(info);
#elif defined(R__LINUX)
   GetLinuxProcInfo(info);
#endif

   return 0;
}
 TUnixSystem.cxx:1
 TUnixSystem.cxx:2
 TUnixSystem.cxx:3
 TUnixSystem.cxx:4
 TUnixSystem.cxx:5
 TUnixSystem.cxx:6
 TUnixSystem.cxx:7
 TUnixSystem.cxx:8
 TUnixSystem.cxx:9
 TUnixSystem.cxx:10
 TUnixSystem.cxx:11
 TUnixSystem.cxx:12
 TUnixSystem.cxx:13
 TUnixSystem.cxx:14
 TUnixSystem.cxx:15
 TUnixSystem.cxx:16
 TUnixSystem.cxx:17
 TUnixSystem.cxx:18
 TUnixSystem.cxx:19
 TUnixSystem.cxx:20
 TUnixSystem.cxx:21
 TUnixSystem.cxx:22
 TUnixSystem.cxx:23
 TUnixSystem.cxx:24
 TUnixSystem.cxx:25
 TUnixSystem.cxx:26
 TUnixSystem.cxx:27
 TUnixSystem.cxx:28
 TUnixSystem.cxx:29
 TUnixSystem.cxx:30
 TUnixSystem.cxx:31
 TUnixSystem.cxx:32
 TUnixSystem.cxx:33
 TUnixSystem.cxx:34
 TUnixSystem.cxx:35
 TUnixSystem.cxx:36
 TUnixSystem.cxx:37
 TUnixSystem.cxx:38
 TUnixSystem.cxx:39
 TUnixSystem.cxx:40
 TUnixSystem.cxx:41
 TUnixSystem.cxx:42
 TUnixSystem.cxx:43
 TUnixSystem.cxx:44
 TUnixSystem.cxx:45
 TUnixSystem.cxx:46
 TUnixSystem.cxx:47
 TUnixSystem.cxx:48
 TUnixSystem.cxx:49
 TUnixSystem.cxx:50
 TUnixSystem.cxx:51
 TUnixSystem.cxx:52
 TUnixSystem.cxx:53
 TUnixSystem.cxx:54
 TUnixSystem.cxx:55
 TUnixSystem.cxx:56
 TUnixSystem.cxx:57
 TUnixSystem.cxx:58
 TUnixSystem.cxx:59
 TUnixSystem.cxx:60
 TUnixSystem.cxx:61
 TUnixSystem.cxx:62
 TUnixSystem.cxx:63
 TUnixSystem.cxx:64
 TUnixSystem.cxx:65
 TUnixSystem.cxx:66
 TUnixSystem.cxx:67
 TUnixSystem.cxx:68
 TUnixSystem.cxx:69
 TUnixSystem.cxx:70
 TUnixSystem.cxx:71
 TUnixSystem.cxx:72
 TUnixSystem.cxx:73
 TUnixSystem.cxx:74
 TUnixSystem.cxx:75
 TUnixSystem.cxx:76
 TUnixSystem.cxx:77
 TUnixSystem.cxx:78
 TUnixSystem.cxx:79
 TUnixSystem.cxx:80
 TUnixSystem.cxx:81
 TUnixSystem.cxx:82
 TUnixSystem.cxx:83
 TUnixSystem.cxx:84
 TUnixSystem.cxx:85
 TUnixSystem.cxx:86
 TUnixSystem.cxx:87
 TUnixSystem.cxx:88
 TUnixSystem.cxx:89
 TUnixSystem.cxx:90
 TUnixSystem.cxx:91
 TUnixSystem.cxx:92
 TUnixSystem.cxx:93
 TUnixSystem.cxx:94
 TUnixSystem.cxx:95
 TUnixSystem.cxx:96
 TUnixSystem.cxx:97
 TUnixSystem.cxx:98
 TUnixSystem.cxx:99
 TUnixSystem.cxx:100
 TUnixSystem.cxx:101
 TUnixSystem.cxx:102
 TUnixSystem.cxx:103
 TUnixSystem.cxx:104
 TUnixSystem.cxx:105
 TUnixSystem.cxx:106
 TUnixSystem.cxx:107
 TUnixSystem.cxx:108
 TUnixSystem.cxx:109
 TUnixSystem.cxx:110
 TUnixSystem.cxx:111
 TUnixSystem.cxx:112
 TUnixSystem.cxx:113
 TUnixSystem.cxx:114
 TUnixSystem.cxx:115
 TUnixSystem.cxx:116
 TUnixSystem.cxx:117
 TUnixSystem.cxx:118
 TUnixSystem.cxx:119
 TUnixSystem.cxx:120
 TUnixSystem.cxx:121
 TUnixSystem.cxx:122
 TUnixSystem.cxx:123
 TUnixSystem.cxx:124
 TUnixSystem.cxx:125
 TUnixSystem.cxx:126
 TUnixSystem.cxx:127
 TUnixSystem.cxx:128
 TUnixSystem.cxx:129
 TUnixSystem.cxx:130
 TUnixSystem.cxx:131
 TUnixSystem.cxx:132
 TUnixSystem.cxx:133
 TUnixSystem.cxx:134
 TUnixSystem.cxx:135
 TUnixSystem.cxx:136
 TUnixSystem.cxx:137
 TUnixSystem.cxx:138
 TUnixSystem.cxx:139
 TUnixSystem.cxx:140
 TUnixSystem.cxx:141
 TUnixSystem.cxx:142
 TUnixSystem.cxx:143
 TUnixSystem.cxx:144
 TUnixSystem.cxx:145
 TUnixSystem.cxx:146
 TUnixSystem.cxx:147
 TUnixSystem.cxx:148
 TUnixSystem.cxx:149
 TUnixSystem.cxx:150
 TUnixSystem.cxx:151
 TUnixSystem.cxx:152
 TUnixSystem.cxx:153
 TUnixSystem.cxx:154
 TUnixSystem.cxx:155
 TUnixSystem.cxx:156
 TUnixSystem.cxx:157
 TUnixSystem.cxx:158
 TUnixSystem.cxx:159
 TUnixSystem.cxx:160
 TUnixSystem.cxx:161
 TUnixSystem.cxx:162
 TUnixSystem.cxx:163
 TUnixSystem.cxx:164
 TUnixSystem.cxx:165
 TUnixSystem.cxx:166
 TUnixSystem.cxx:167
 TUnixSystem.cxx:168
 TUnixSystem.cxx:169
 TUnixSystem.cxx:170
 TUnixSystem.cxx:171
 TUnixSystem.cxx:172
 TUnixSystem.cxx:173
 TUnixSystem.cxx:174
 TUnixSystem.cxx:175
 TUnixSystem.cxx:176
 TUnixSystem.cxx:177
 TUnixSystem.cxx:178
 TUnixSystem.cxx:179
 TUnixSystem.cxx:180
 TUnixSystem.cxx:181
 TUnixSystem.cxx:182
 TUnixSystem.cxx:183
 TUnixSystem.cxx:184
 TUnixSystem.cxx:185
 TUnixSystem.cxx:186
 TUnixSystem.cxx:187
 TUnixSystem.cxx:188
 TUnixSystem.cxx:189
 TUnixSystem.cxx:190
 TUnixSystem.cxx:191
 TUnixSystem.cxx:192
 TUnixSystem.cxx:193
 TUnixSystem.cxx:194
 TUnixSystem.cxx:195
 TUnixSystem.cxx:196
 TUnixSystem.cxx:197
 TUnixSystem.cxx:198
 TUnixSystem.cxx:199
 TUnixSystem.cxx:200
 TUnixSystem.cxx:201
 TUnixSystem.cxx:202
 TUnixSystem.cxx:203
 TUnixSystem.cxx:204
 TUnixSystem.cxx:205
 TUnixSystem.cxx:206
 TUnixSystem.cxx:207
 TUnixSystem.cxx:208
 TUnixSystem.cxx:209
 TUnixSystem.cxx:210
 TUnixSystem.cxx:211
 TUnixSystem.cxx:212
 TUnixSystem.cxx:213
 TUnixSystem.cxx:214
 TUnixSystem.cxx:215
 TUnixSystem.cxx:216
 TUnixSystem.cxx:217
 TUnixSystem.cxx:218
 TUnixSystem.cxx:219
 TUnixSystem.cxx:220
 TUnixSystem.cxx:221
 TUnixSystem.cxx:222
 TUnixSystem.cxx:223
 TUnixSystem.cxx:224
 TUnixSystem.cxx:225
 TUnixSystem.cxx:226
 TUnixSystem.cxx:227
 TUnixSystem.cxx:228
 TUnixSystem.cxx:229
 TUnixSystem.cxx:230
 TUnixSystem.cxx:231
 TUnixSystem.cxx:232
 TUnixSystem.cxx:233
 TUnixSystem.cxx:234
 TUnixSystem.cxx:235
 TUnixSystem.cxx:236
 TUnixSystem.cxx:237
 TUnixSystem.cxx:238
 TUnixSystem.cxx:239
 TUnixSystem.cxx:240
 TUnixSystem.cxx:241
 TUnixSystem.cxx:242
 TUnixSystem.cxx:243
 TUnixSystem.cxx:244
 TUnixSystem.cxx:245
 TUnixSystem.cxx:246
 TUnixSystem.cxx:247
 TUnixSystem.cxx:248
 TUnixSystem.cxx:249
 TUnixSystem.cxx:250
 TUnixSystem.cxx:251
 TUnixSystem.cxx:252
 TUnixSystem.cxx:253
 TUnixSystem.cxx:254
 TUnixSystem.cxx:255
 TUnixSystem.cxx:256
 TUnixSystem.cxx:257
 TUnixSystem.cxx:258
 TUnixSystem.cxx:259
 TUnixSystem.cxx:260
 TUnixSystem.cxx:261
 TUnixSystem.cxx:262
 TUnixSystem.cxx:263
 TUnixSystem.cxx:264
 TUnixSystem.cxx:265
 TUnixSystem.cxx:266
 TUnixSystem.cxx:267
 TUnixSystem.cxx:268
 TUnixSystem.cxx:269
 TUnixSystem.cxx:270
 TUnixSystem.cxx:271
 TUnixSystem.cxx:272
 TUnixSystem.cxx:273
 TUnixSystem.cxx:274
 TUnixSystem.cxx:275
 TUnixSystem.cxx:276
 TUnixSystem.cxx:277
 TUnixSystem.cxx:278
 TUnixSystem.cxx:279
 TUnixSystem.cxx:280
 TUnixSystem.cxx:281
 TUnixSystem.cxx:282
 TUnixSystem.cxx:283
 TUnixSystem.cxx:284
 TUnixSystem.cxx:285
 TUnixSystem.cxx:286
 TUnixSystem.cxx:287
 TUnixSystem.cxx:288
 TUnixSystem.cxx:289
 TUnixSystem.cxx:290
 TUnixSystem.cxx:291
 TUnixSystem.cxx:292
 TUnixSystem.cxx:293
 TUnixSystem.cxx:294
 TUnixSystem.cxx:295
 TUnixSystem.cxx:296
 TUnixSystem.cxx:297
 TUnixSystem.cxx:298
 TUnixSystem.cxx:299
 TUnixSystem.cxx:300
 TUnixSystem.cxx:301
 TUnixSystem.cxx:302
 TUnixSystem.cxx:303
 TUnixSystem.cxx:304
 TUnixSystem.cxx:305
 TUnixSystem.cxx:306
 TUnixSystem.cxx:307
 TUnixSystem.cxx:308
 TUnixSystem.cxx:309
 TUnixSystem.cxx:310
 TUnixSystem.cxx:311
 TUnixSystem.cxx:312
 TUnixSystem.cxx:313
 TUnixSystem.cxx:314
 TUnixSystem.cxx:315
 TUnixSystem.cxx:316
 TUnixSystem.cxx:317
 TUnixSystem.cxx:318
 TUnixSystem.cxx:319
 TUnixSystem.cxx:320
 TUnixSystem.cxx:321
 TUnixSystem.cxx:322
 TUnixSystem.cxx:323
 TUnixSystem.cxx:324
 TUnixSystem.cxx:325
 TUnixSystem.cxx:326
 TUnixSystem.cxx:327
 TUnixSystem.cxx:328
 TUnixSystem.cxx:329
 TUnixSystem.cxx:330
 TUnixSystem.cxx:331
 TUnixSystem.cxx:332
 TUnixSystem.cxx:333
 TUnixSystem.cxx:334
 TUnixSystem.cxx:335
 TUnixSystem.cxx:336
 TUnixSystem.cxx:337
 TUnixSystem.cxx:338
 TUnixSystem.cxx:339
 TUnixSystem.cxx:340
 TUnixSystem.cxx:341
 TUnixSystem.cxx:342
 TUnixSystem.cxx:343
 TUnixSystem.cxx:344
 TUnixSystem.cxx:345
 TUnixSystem.cxx:346
 TUnixSystem.cxx:347
 TUnixSystem.cxx:348
 TUnixSystem.cxx:349
 TUnixSystem.cxx:350
 TUnixSystem.cxx:351
 TUnixSystem.cxx:352
 TUnixSystem.cxx:353
 TUnixSystem.cxx:354
 TUnixSystem.cxx:355
 TUnixSystem.cxx:356
 TUnixSystem.cxx:357
 TUnixSystem.cxx:358
 TUnixSystem.cxx:359
 TUnixSystem.cxx:360
 TUnixSystem.cxx:361
 TUnixSystem.cxx:362
 TUnixSystem.cxx:363
 TUnixSystem.cxx:364
 TUnixSystem.cxx:365
 TUnixSystem.cxx:366
 TUnixSystem.cxx:367
 TUnixSystem.cxx:368
 TUnixSystem.cxx:369
 TUnixSystem.cxx:370
 TUnixSystem.cxx:371
 TUnixSystem.cxx:372
 TUnixSystem.cxx:373
 TUnixSystem.cxx:374
 TUnixSystem.cxx:375
 TUnixSystem.cxx:376
 TUnixSystem.cxx:377
 TUnixSystem.cxx:378
 TUnixSystem.cxx:379
 TUnixSystem.cxx:380
 TUnixSystem.cxx:381
 TUnixSystem.cxx:382
 TUnixSystem.cxx:383
 TUnixSystem.cxx:384
 TUnixSystem.cxx:385
 TUnixSystem.cxx:386
 TUnixSystem.cxx:387
 TUnixSystem.cxx:388
 TUnixSystem.cxx:389
 TUnixSystem.cxx:390
 TUnixSystem.cxx:391
 TUnixSystem.cxx:392
 TUnixSystem.cxx:393
 TUnixSystem.cxx:394
 TUnixSystem.cxx:395
 TUnixSystem.cxx:396
 TUnixSystem.cxx:397
 TUnixSystem.cxx:398
 TUnixSystem.cxx:399
 TUnixSystem.cxx:400
 TUnixSystem.cxx:401
 TUnixSystem.cxx:402
 TUnixSystem.cxx:403
 TUnixSystem.cxx:404
 TUnixSystem.cxx:405
 TUnixSystem.cxx:406
 TUnixSystem.cxx:407
 TUnixSystem.cxx:408
 TUnixSystem.cxx:409
 TUnixSystem.cxx:410
 TUnixSystem.cxx:411
 TUnixSystem.cxx:412
 TUnixSystem.cxx:413
 TUnixSystem.cxx:414
 TUnixSystem.cxx:415
 TUnixSystem.cxx:416
 TUnixSystem.cxx:417
 TUnixSystem.cxx:418
 TUnixSystem.cxx:419
 TUnixSystem.cxx:420
 TUnixSystem.cxx:421
 TUnixSystem.cxx:422
 TUnixSystem.cxx:423
 TUnixSystem.cxx:424
 TUnixSystem.cxx:425
 TUnixSystem.cxx:426
 TUnixSystem.cxx:427
 TUnixSystem.cxx:428
 TUnixSystem.cxx:429
 TUnixSystem.cxx:430
 TUnixSystem.cxx:431
 TUnixSystem.cxx:432
 TUnixSystem.cxx:433
 TUnixSystem.cxx:434
 TUnixSystem.cxx:435
 TUnixSystem.cxx:436
 TUnixSystem.cxx:437
 TUnixSystem.cxx:438
 TUnixSystem.cxx:439
 TUnixSystem.cxx:440
 TUnixSystem.cxx:441
 TUnixSystem.cxx:442
 TUnixSystem.cxx:443
 TUnixSystem.cxx:444
 TUnixSystem.cxx:445
 TUnixSystem.cxx:446
 TUnixSystem.cxx:447
 TUnixSystem.cxx:448
 TUnixSystem.cxx:449
 TUnixSystem.cxx:450
 TUnixSystem.cxx:451
 TUnixSystem.cxx:452
 TUnixSystem.cxx:453
 TUnixSystem.cxx:454
 TUnixSystem.cxx:455
 TUnixSystem.cxx:456
 TUnixSystem.cxx:457
 TUnixSystem.cxx:458
 TUnixSystem.cxx:459
 TUnixSystem.cxx:460
 TUnixSystem.cxx:461
 TUnixSystem.cxx:462
 TUnixSystem.cxx:463
 TUnixSystem.cxx:464
 TUnixSystem.cxx:465
 TUnixSystem.cxx:466
 TUnixSystem.cxx:467
 TUnixSystem.cxx:468
 TUnixSystem.cxx:469
 TUnixSystem.cxx:470
 TUnixSystem.cxx:471
 TUnixSystem.cxx:472
 TUnixSystem.cxx:473
 TUnixSystem.cxx:474
 TUnixSystem.cxx:475
 TUnixSystem.cxx:476
 TUnixSystem.cxx:477
 TUnixSystem.cxx:478
 TUnixSystem.cxx:479
 TUnixSystem.cxx:480
 TUnixSystem.cxx:481
 TUnixSystem.cxx:482
 TUnixSystem.cxx:483
 TUnixSystem.cxx:484
 TUnixSystem.cxx:485
 TUnixSystem.cxx:486
 TUnixSystem.cxx:487
 TUnixSystem.cxx:488
 TUnixSystem.cxx:489
 TUnixSystem.cxx:490
 TUnixSystem.cxx:491
 TUnixSystem.cxx:492
 TUnixSystem.cxx:493
 TUnixSystem.cxx:494
 TUnixSystem.cxx:495
 TUnixSystem.cxx:496
 TUnixSystem.cxx:497
 TUnixSystem.cxx:498
 TUnixSystem.cxx:499
 TUnixSystem.cxx:500
 TUnixSystem.cxx:501
 TUnixSystem.cxx:502
 TUnixSystem.cxx:503
 TUnixSystem.cxx:504
 TUnixSystem.cxx:505
 TUnixSystem.cxx:506
 TUnixSystem.cxx:507
 TUnixSystem.cxx:508
 TUnixSystem.cxx:509
 TUnixSystem.cxx:510
 TUnixSystem.cxx:511
 TUnixSystem.cxx:512
 TUnixSystem.cxx:513
 TUnixSystem.cxx:514
 TUnixSystem.cxx:515
 TUnixSystem.cxx:516
 TUnixSystem.cxx:517
 TUnixSystem.cxx:518
 TUnixSystem.cxx:519
 TUnixSystem.cxx:520
 TUnixSystem.cxx:521
 TUnixSystem.cxx:522
 TUnixSystem.cxx:523
 TUnixSystem.cxx:524
 TUnixSystem.cxx:525
 TUnixSystem.cxx:526
 TUnixSystem.cxx:527
 TUnixSystem.cxx:528
 TUnixSystem.cxx:529
 TUnixSystem.cxx:530
 TUnixSystem.cxx:531
 TUnixSystem.cxx:532
 TUnixSystem.cxx:533
 TUnixSystem.cxx:534
 TUnixSystem.cxx:535
 TUnixSystem.cxx:536
 TUnixSystem.cxx:537
 TUnixSystem.cxx:538
 TUnixSystem.cxx:539
 TUnixSystem.cxx:540
 TUnixSystem.cxx:541
 TUnixSystem.cxx:542
 TUnixSystem.cxx:543
 TUnixSystem.cxx:544
 TUnixSystem.cxx:545
 TUnixSystem.cxx:546
 TUnixSystem.cxx:547
 TUnixSystem.cxx:548
 TUnixSystem.cxx:549
 TUnixSystem.cxx:550
 TUnixSystem.cxx:551
 TUnixSystem.cxx:552
 TUnixSystem.cxx:553
 TUnixSystem.cxx:554
 TUnixSystem.cxx:555
 TUnixSystem.cxx:556
 TUnixSystem.cxx:557
 TUnixSystem.cxx:558
 TUnixSystem.cxx:559
 TUnixSystem.cxx:560
 TUnixSystem.cxx:561
 TUnixSystem.cxx:562
 TUnixSystem.cxx:563
 TUnixSystem.cxx:564
 TUnixSystem.cxx:565
 TUnixSystem.cxx:566
 TUnixSystem.cxx:567
 TUnixSystem.cxx:568
 TUnixSystem.cxx:569
 TUnixSystem.cxx:570
 TUnixSystem.cxx:571
 TUnixSystem.cxx:572
 TUnixSystem.cxx:573
 TUnixSystem.cxx:574
 TUnixSystem.cxx:575
 TUnixSystem.cxx:576
 TUnixSystem.cxx:577
 TUnixSystem.cxx:578
 TUnixSystem.cxx:579
 TUnixSystem.cxx:580
 TUnixSystem.cxx:581
 TUnixSystem.cxx:582
 TUnixSystem.cxx:583
 TUnixSystem.cxx:584
 TUnixSystem.cxx:585
 TUnixSystem.cxx:586
 TUnixSystem.cxx:587
 TUnixSystem.cxx:588
 TUnixSystem.cxx:589
 TUnixSystem.cxx:590
 TUnixSystem.cxx:591
 TUnixSystem.cxx:592
 TUnixSystem.cxx:593
 TUnixSystem.cxx:594
 TUnixSystem.cxx:595
 TUnixSystem.cxx:596
 TUnixSystem.cxx:597
 TUnixSystem.cxx:598
 TUnixSystem.cxx:599
 TUnixSystem.cxx:600
 TUnixSystem.cxx:601
 TUnixSystem.cxx:602
 TUnixSystem.cxx:603
 TUnixSystem.cxx:604
 TUnixSystem.cxx:605
 TUnixSystem.cxx:606
 TUnixSystem.cxx:607
 TUnixSystem.cxx:608
 TUnixSystem.cxx:609
 TUnixSystem.cxx:610
 TUnixSystem.cxx:611
 TUnixSystem.cxx:612
 TUnixSystem.cxx:613
 TUnixSystem.cxx:614
 TUnixSystem.cxx:615
 TUnixSystem.cxx:616
 TUnixSystem.cxx:617
 TUnixSystem.cxx:618
 TUnixSystem.cxx:619
 TUnixSystem.cxx:620
 TUnixSystem.cxx:621
 TUnixSystem.cxx:622
 TUnixSystem.cxx:623
 TUnixSystem.cxx:624
 TUnixSystem.cxx:625
 TUnixSystem.cxx:626
 TUnixSystem.cxx:627
 TUnixSystem.cxx:628
 TUnixSystem.cxx:629
 TUnixSystem.cxx:630
 TUnixSystem.cxx:631
 TUnixSystem.cxx:632
 TUnixSystem.cxx:633
 TUnixSystem.cxx:634
 TUnixSystem.cxx:635
 TUnixSystem.cxx:636
 TUnixSystem.cxx:637
 TUnixSystem.cxx:638
 TUnixSystem.cxx:639
 TUnixSystem.cxx:640
 TUnixSystem.cxx:641
 TUnixSystem.cxx:642
 TUnixSystem.cxx:643
 TUnixSystem.cxx:644
 TUnixSystem.cxx:645
 TUnixSystem.cxx:646
 TUnixSystem.cxx:647
 TUnixSystem.cxx:648
 TUnixSystem.cxx:649
 TUnixSystem.cxx:650
 TUnixSystem.cxx:651
 TUnixSystem.cxx:652
 TUnixSystem.cxx:653
 TUnixSystem.cxx:654
 TUnixSystem.cxx:655
 TUnixSystem.cxx:656
 TUnixSystem.cxx:657
 TUnixSystem.cxx:658
 TUnixSystem.cxx:659
 TUnixSystem.cxx:660
 TUnixSystem.cxx:661
 TUnixSystem.cxx:662
 TUnixSystem.cxx:663
 TUnixSystem.cxx:664
 TUnixSystem.cxx:665
 TUnixSystem.cxx:666
 TUnixSystem.cxx:667
 TUnixSystem.cxx:668
 TUnixSystem.cxx:669
 TUnixSystem.cxx:670
 TUnixSystem.cxx:671
 TUnixSystem.cxx:672
 TUnixSystem.cxx:673
 TUnixSystem.cxx:674
 TUnixSystem.cxx:675
 TUnixSystem.cxx:676
 TUnixSystem.cxx:677
 TUnixSystem.cxx:678
 TUnixSystem.cxx:679
 TUnixSystem.cxx:680
 TUnixSystem.cxx:681
 TUnixSystem.cxx:682
 TUnixSystem.cxx:683
 TUnixSystem.cxx:684
 TUnixSystem.cxx:685
 TUnixSystem.cxx:686
 TUnixSystem.cxx:687
 TUnixSystem.cxx:688
 TUnixSystem.cxx:689
 TUnixSystem.cxx:690
 TUnixSystem.cxx:691
 TUnixSystem.cxx:692
 TUnixSystem.cxx:693
 TUnixSystem.cxx:694
 TUnixSystem.cxx:695
 TUnixSystem.cxx:696
 TUnixSystem.cxx:697
 TUnixSystem.cxx:698
 TUnixSystem.cxx:699
 TUnixSystem.cxx:700
 TUnixSystem.cxx:701
 TUnixSystem.cxx:702
 TUnixSystem.cxx:703
 TUnixSystem.cxx:704
 TUnixSystem.cxx:705
 TUnixSystem.cxx:706
 TUnixSystem.cxx:707
 TUnixSystem.cxx:708
 TUnixSystem.cxx:709
 TUnixSystem.cxx:710
 TUnixSystem.cxx:711
 TUnixSystem.cxx:712
 TUnixSystem.cxx:713
 TUnixSystem.cxx:714
 TUnixSystem.cxx:715
 TUnixSystem.cxx:716
 TUnixSystem.cxx:717
 TUnixSystem.cxx:718
 TUnixSystem.cxx:719
 TUnixSystem.cxx:720
 TUnixSystem.cxx:721
 TUnixSystem.cxx:722
 TUnixSystem.cxx:723
 TUnixSystem.cxx:724
 TUnixSystem.cxx:725
 TUnixSystem.cxx:726
 TUnixSystem.cxx:727
 TUnixSystem.cxx:728
 TUnixSystem.cxx:729
 TUnixSystem.cxx:730
 TUnixSystem.cxx:731
 TUnixSystem.cxx:732
 TUnixSystem.cxx:733
 TUnixSystem.cxx:734
 TUnixSystem.cxx:735
 TUnixSystem.cxx:736
 TUnixSystem.cxx:737
 TUnixSystem.cxx:738
 TUnixSystem.cxx:739
 TUnixSystem.cxx:740
 TUnixSystem.cxx:741
 TUnixSystem.cxx:742
 TUnixSystem.cxx:743
 TUnixSystem.cxx:744
 TUnixSystem.cxx:745
 TUnixSystem.cxx:746
 TUnixSystem.cxx:747
 TUnixSystem.cxx:748
 TUnixSystem.cxx:749
 TUnixSystem.cxx:750
 TUnixSystem.cxx:751
 TUnixSystem.cxx:752
 TUnixSystem.cxx:753
 TUnixSystem.cxx:754
 TUnixSystem.cxx:755
 TUnixSystem.cxx:756
 TUnixSystem.cxx:757
 TUnixSystem.cxx:758
 TUnixSystem.cxx:759
 TUnixSystem.cxx:760
 TUnixSystem.cxx:761
 TUnixSystem.cxx:762
 TUnixSystem.cxx:763
 TUnixSystem.cxx:764
 TUnixSystem.cxx:765
 TUnixSystem.cxx:766
 TUnixSystem.cxx:767
 TUnixSystem.cxx:768
 TUnixSystem.cxx:769
 TUnixSystem.cxx:770
 TUnixSystem.cxx:771
 TUnixSystem.cxx:772
 TUnixSystem.cxx:773
 TUnixSystem.cxx:774
 TUnixSystem.cxx:775
 TUnixSystem.cxx:776
 TUnixSystem.cxx:777
 TUnixSystem.cxx:778
 TUnixSystem.cxx:779
 TUnixSystem.cxx:780
 TUnixSystem.cxx:781
 TUnixSystem.cxx:782
 TUnixSystem.cxx:783
 TUnixSystem.cxx:784
 TUnixSystem.cxx:785
 TUnixSystem.cxx:786
 TUnixSystem.cxx:787
 TUnixSystem.cxx:788
 TUnixSystem.cxx:789
 TUnixSystem.cxx:790
 TUnixSystem.cxx:791
 TUnixSystem.cxx:792
 TUnixSystem.cxx:793
 TUnixSystem.cxx:794
 TUnixSystem.cxx:795
 TUnixSystem.cxx:796
 TUnixSystem.cxx:797
 TUnixSystem.cxx:798
 TUnixSystem.cxx:799
 TUnixSystem.cxx:800
 TUnixSystem.cxx:801
 TUnixSystem.cxx:802
 TUnixSystem.cxx:803
 TUnixSystem.cxx:804
 TUnixSystem.cxx:805
 TUnixSystem.cxx:806
 TUnixSystem.cxx:807
 TUnixSystem.cxx:808
 TUnixSystem.cxx:809
 TUnixSystem.cxx:810
 TUnixSystem.cxx:811
 TUnixSystem.cxx:812
 TUnixSystem.cxx:813
 TUnixSystem.cxx:814
 TUnixSystem.cxx:815
 TUnixSystem.cxx:816
 TUnixSystem.cxx:817
 TUnixSystem.cxx:818
 TUnixSystem.cxx:819
 TUnixSystem.cxx:820
 TUnixSystem.cxx:821
 TUnixSystem.cxx:822
 TUnixSystem.cxx:823
 TUnixSystem.cxx:824
 TUnixSystem.cxx:825
 TUnixSystem.cxx:826
 TUnixSystem.cxx:827
 TUnixSystem.cxx:828
 TUnixSystem.cxx:829
 TUnixSystem.cxx:830
 TUnixSystem.cxx:831
 TUnixSystem.cxx:832
 TUnixSystem.cxx:833
 TUnixSystem.cxx:834
 TUnixSystem.cxx:835
 TUnixSystem.cxx:836
 TUnixSystem.cxx:837
 TUnixSystem.cxx:838
 TUnixSystem.cxx:839
 TUnixSystem.cxx:840
 TUnixSystem.cxx:841
 TUnixSystem.cxx:842
 TUnixSystem.cxx:843
 TUnixSystem.cxx:844
 TUnixSystem.cxx:845
 TUnixSystem.cxx:846
 TUnixSystem.cxx:847
 TUnixSystem.cxx:848
 TUnixSystem.cxx:849
 TUnixSystem.cxx:850
 TUnixSystem.cxx:851
 TUnixSystem.cxx:852
 TUnixSystem.cxx:853
 TUnixSystem.cxx:854
 TUnixSystem.cxx:855
 TUnixSystem.cxx:856
 TUnixSystem.cxx:857
 TUnixSystem.cxx:858
 TUnixSystem.cxx:859
 TUnixSystem.cxx:860
 TUnixSystem.cxx:861
 TUnixSystem.cxx:862
 TUnixSystem.cxx:863
 TUnixSystem.cxx:864
 TUnixSystem.cxx:865
 TUnixSystem.cxx:866
 TUnixSystem.cxx:867
 TUnixSystem.cxx:868
 TUnixSystem.cxx:869
 TUnixSystem.cxx:870
 TUnixSystem.cxx:871
 TUnixSystem.cxx:872
 TUnixSystem.cxx:873
 TUnixSystem.cxx:874
 TUnixSystem.cxx:875
 TUnixSystem.cxx:876
 TUnixSystem.cxx:877
 TUnixSystem.cxx:878
 TUnixSystem.cxx:879
 TUnixSystem.cxx:880
 TUnixSystem.cxx:881
 TUnixSystem.cxx:882
 TUnixSystem.cxx:883
 TUnixSystem.cxx:884
 TUnixSystem.cxx:885
 TUnixSystem.cxx:886
 TUnixSystem.cxx:887
 TUnixSystem.cxx:888
 TUnixSystem.cxx:889
 TUnixSystem.cxx:890
 TUnixSystem.cxx:891
 TUnixSystem.cxx:892
 TUnixSystem.cxx:893
 TUnixSystem.cxx:894
 TUnixSystem.cxx:895
 TUnixSystem.cxx:896
 TUnixSystem.cxx:897
 TUnixSystem.cxx:898
 TUnixSystem.cxx:899
 TUnixSystem.cxx:900
 TUnixSystem.cxx:901
 TUnixSystem.cxx:902
 TUnixSystem.cxx:903
 TUnixSystem.cxx:904
 TUnixSystem.cxx:905
 TUnixSystem.cxx:906
 TUnixSystem.cxx:907
 TUnixSystem.cxx:908
 TUnixSystem.cxx:909
 TUnixSystem.cxx:910
 TUnixSystem.cxx:911
 TUnixSystem.cxx:912
 TUnixSystem.cxx:913
 TUnixSystem.cxx:914
 TUnixSystem.cxx:915
 TUnixSystem.cxx:916
 TUnixSystem.cxx:917
 TUnixSystem.cxx:918
 TUnixSystem.cxx:919
 TUnixSystem.cxx:920
 TUnixSystem.cxx:921
 TUnixSystem.cxx:922
 TUnixSystem.cxx:923
 TUnixSystem.cxx:924
 TUnixSystem.cxx:925
 TUnixSystem.cxx:926
 TUnixSystem.cxx:927
 TUnixSystem.cxx:928
 TUnixSystem.cxx:929
 TUnixSystem.cxx:930
 TUnixSystem.cxx:931
 TUnixSystem.cxx:932
 TUnixSystem.cxx:933
 TUnixSystem.cxx:934
 TUnixSystem.cxx:935
 TUnixSystem.cxx:936
 TUnixSystem.cxx:937
 TUnixSystem.cxx:938
 TUnixSystem.cxx:939
 TUnixSystem.cxx:940
 TUnixSystem.cxx:941
 TUnixSystem.cxx:942
 TUnixSystem.cxx:943
 TUnixSystem.cxx:944
 TUnixSystem.cxx:945
 TUnixSystem.cxx:946
 TUnixSystem.cxx:947
 TUnixSystem.cxx:948
 TUnixSystem.cxx:949
 TUnixSystem.cxx:950
 TUnixSystem.cxx:951
 TUnixSystem.cxx:952
 TUnixSystem.cxx:953
 TUnixSystem.cxx:954
 TUnixSystem.cxx:955
 TUnixSystem.cxx:956
 TUnixSystem.cxx:957
 TUnixSystem.cxx:958
 TUnixSystem.cxx:959
 TUnixSystem.cxx:960
 TUnixSystem.cxx:961
 TUnixSystem.cxx:962
 TUnixSystem.cxx:963
 TUnixSystem.cxx:964
 TUnixSystem.cxx:965
 TUnixSystem.cxx:966
 TUnixSystem.cxx:967
 TUnixSystem.cxx:968
 TUnixSystem.cxx:969
 TUnixSystem.cxx:970
 TUnixSystem.cxx:971
 TUnixSystem.cxx:972
 TUnixSystem.cxx:973
 TUnixSystem.cxx:974
 TUnixSystem.cxx:975
 TUnixSystem.cxx:976
 TUnixSystem.cxx:977
 TUnixSystem.cxx:978
 TUnixSystem.cxx:979
 TUnixSystem.cxx:980
 TUnixSystem.cxx:981
 TUnixSystem.cxx:982
 TUnixSystem.cxx:983
 TUnixSystem.cxx:984
 TUnixSystem.cxx:985
 TUnixSystem.cxx:986
 TUnixSystem.cxx:987
 TUnixSystem.cxx:988
 TUnixSystem.cxx:989
 TUnixSystem.cxx:990
 TUnixSystem.cxx:991
 TUnixSystem.cxx:992
 TUnixSystem.cxx:993
 TUnixSystem.cxx:994
 TUnixSystem.cxx:995
 TUnixSystem.cxx:996
 TUnixSystem.cxx:997
 TUnixSystem.cxx:998
 TUnixSystem.cxx:999
 TUnixSystem.cxx:1000
 TUnixSystem.cxx:1001
 TUnixSystem.cxx:1002
 TUnixSystem.cxx:1003
 TUnixSystem.cxx:1004
 TUnixSystem.cxx:1005
 TUnixSystem.cxx:1006
 TUnixSystem.cxx:1007
 TUnixSystem.cxx:1008
 TUnixSystem.cxx:1009
 TUnixSystem.cxx:1010
 TUnixSystem.cxx:1011
 TUnixSystem.cxx:1012
 TUnixSystem.cxx:1013
 TUnixSystem.cxx:1014
 TUnixSystem.cxx:1015
 TUnixSystem.cxx:1016
 TUnixSystem.cxx:1017
 TUnixSystem.cxx:1018
 TUnixSystem.cxx:1019
 TUnixSystem.cxx:1020
 TUnixSystem.cxx:1021
 TUnixSystem.cxx:1022
 TUnixSystem.cxx:1023
 TUnixSystem.cxx:1024
 TUnixSystem.cxx:1025
 TUnixSystem.cxx:1026
 TUnixSystem.cxx:1027
 TUnixSystem.cxx:1028
 TUnixSystem.cxx:1029
 TUnixSystem.cxx:1030
 TUnixSystem.cxx:1031
 TUnixSystem.cxx:1032
 TUnixSystem.cxx:1033
 TUnixSystem.cxx:1034
 TUnixSystem.cxx:1035
 TUnixSystem.cxx:1036
 TUnixSystem.cxx:1037
 TUnixSystem.cxx:1038
 TUnixSystem.cxx:1039
 TUnixSystem.cxx:1040
 TUnixSystem.cxx:1041
 TUnixSystem.cxx:1042
 TUnixSystem.cxx:1043
 TUnixSystem.cxx:1044
 TUnixSystem.cxx:1045
 TUnixSystem.cxx:1046
 TUnixSystem.cxx:1047
 TUnixSystem.cxx:1048
 TUnixSystem.cxx:1049
 TUnixSystem.cxx:1050
 TUnixSystem.cxx:1051
 TUnixSystem.cxx:1052
 TUnixSystem.cxx:1053
 TUnixSystem.cxx:1054
 TUnixSystem.cxx:1055
 TUnixSystem.cxx:1056
 TUnixSystem.cxx:1057
 TUnixSystem.cxx:1058
 TUnixSystem.cxx:1059
 TUnixSystem.cxx:1060
 TUnixSystem.cxx:1061
 TUnixSystem.cxx:1062
 TUnixSystem.cxx:1063
 TUnixSystem.cxx:1064
 TUnixSystem.cxx:1065
 TUnixSystem.cxx:1066
 TUnixSystem.cxx:1067
 TUnixSystem.cxx:1068
 TUnixSystem.cxx:1069
 TUnixSystem.cxx:1070
 TUnixSystem.cxx:1071
 TUnixSystem.cxx:1072
 TUnixSystem.cxx:1073
 TUnixSystem.cxx:1074
 TUnixSystem.cxx:1075
 TUnixSystem.cxx:1076
 TUnixSystem.cxx:1077
 TUnixSystem.cxx:1078
 TUnixSystem.cxx:1079
 TUnixSystem.cxx:1080
 TUnixSystem.cxx:1081
 TUnixSystem.cxx:1082
 TUnixSystem.cxx:1083
 TUnixSystem.cxx:1084
 TUnixSystem.cxx:1085
 TUnixSystem.cxx:1086
 TUnixSystem.cxx:1087
 TUnixSystem.cxx:1088
 TUnixSystem.cxx:1089
 TUnixSystem.cxx:1090
 TUnixSystem.cxx:1091
 TUnixSystem.cxx:1092
 TUnixSystem.cxx:1093
 TUnixSystem.cxx:1094
 TUnixSystem.cxx:1095
 TUnixSystem.cxx:1096
 TUnixSystem.cxx:1097
 TUnixSystem.cxx:1098
 TUnixSystem.cxx:1099
 TUnixSystem.cxx:1100
 TUnixSystem.cxx:1101
 TUnixSystem.cxx:1102
 TUnixSystem.cxx:1103
 TUnixSystem.cxx:1104
 TUnixSystem.cxx:1105
 TUnixSystem.cxx:1106
 TUnixSystem.cxx:1107
 TUnixSystem.cxx:1108
 TUnixSystem.cxx:1109
 TUnixSystem.cxx:1110
 TUnixSystem.cxx:1111
 TUnixSystem.cxx:1112
 TUnixSystem.cxx:1113
 TUnixSystem.cxx:1114
 TUnixSystem.cxx:1115
 TUnixSystem.cxx:1116
 TUnixSystem.cxx:1117
 TUnixSystem.cxx:1118
 TUnixSystem.cxx:1119
 TUnixSystem.cxx:1120
 TUnixSystem.cxx:1121
 TUnixSystem.cxx:1122
 TUnixSystem.cxx:1123
 TUnixSystem.cxx:1124
 TUnixSystem.cxx:1125
 TUnixSystem.cxx:1126
 TUnixSystem.cxx:1127
 TUnixSystem.cxx:1128
 TUnixSystem.cxx:1129
 TUnixSystem.cxx:1130
 TUnixSystem.cxx:1131
 TUnixSystem.cxx:1132
 TUnixSystem.cxx:1133
 TUnixSystem.cxx:1134
 TUnixSystem.cxx:1135
 TUnixSystem.cxx:1136
 TUnixSystem.cxx:1137
 TUnixSystem.cxx:1138
 TUnixSystem.cxx:1139
 TUnixSystem.cxx:1140
 TUnixSystem.cxx:1141
 TUnixSystem.cxx:1142
 TUnixSystem.cxx:1143
 TUnixSystem.cxx:1144
 TUnixSystem.cxx:1145
 TUnixSystem.cxx:1146
 TUnixSystem.cxx:1147
 TUnixSystem.cxx:1148
 TUnixSystem.cxx:1149
 TUnixSystem.cxx:1150
 TUnixSystem.cxx:1151
 TUnixSystem.cxx:1152
 TUnixSystem.cxx:1153
 TUnixSystem.cxx:1154
 TUnixSystem.cxx:1155
 TUnixSystem.cxx:1156
 TUnixSystem.cxx:1157
 TUnixSystem.cxx:1158
 TUnixSystem.cxx:1159
 TUnixSystem.cxx:1160
 TUnixSystem.cxx:1161
 TUnixSystem.cxx:1162
 TUnixSystem.cxx:1163
 TUnixSystem.cxx:1164
 TUnixSystem.cxx:1165
 TUnixSystem.cxx:1166
 TUnixSystem.cxx:1167
 TUnixSystem.cxx:1168
 TUnixSystem.cxx:1169
 TUnixSystem.cxx:1170
 TUnixSystem.cxx:1171
 TUnixSystem.cxx:1172
 TUnixSystem.cxx:1173
 TUnixSystem.cxx:1174
 TUnixSystem.cxx:1175
 TUnixSystem.cxx:1176
 TUnixSystem.cxx:1177
 TUnixSystem.cxx:1178
 TUnixSystem.cxx:1179
 TUnixSystem.cxx:1180
 TUnixSystem.cxx:1181
 TUnixSystem.cxx:1182
 TUnixSystem.cxx:1183
 TUnixSystem.cxx:1184
 TUnixSystem.cxx:1185
 TUnixSystem.cxx:1186
 TUnixSystem.cxx:1187
 TUnixSystem.cxx:1188
 TUnixSystem.cxx:1189
 TUnixSystem.cxx:1190
 TUnixSystem.cxx:1191
 TUnixSystem.cxx:1192
 TUnixSystem.cxx:1193
 TUnixSystem.cxx:1194
 TUnixSystem.cxx:1195
 TUnixSystem.cxx:1196
 TUnixSystem.cxx:1197
 TUnixSystem.cxx:1198
 TUnixSystem.cxx:1199
 TUnixSystem.cxx:1200
 TUnixSystem.cxx:1201
 TUnixSystem.cxx:1202
 TUnixSystem.cxx:1203
 TUnixSystem.cxx:1204
 TUnixSystem.cxx:1205
 TUnixSystem.cxx:1206
 TUnixSystem.cxx:1207
 TUnixSystem.cxx:1208
 TUnixSystem.cxx:1209
 TUnixSystem.cxx:1210
 TUnixSystem.cxx:1211
 TUnixSystem.cxx:1212
 TUnixSystem.cxx:1213
 TUnixSystem.cxx:1214
 TUnixSystem.cxx:1215
 TUnixSystem.cxx:1216
 TUnixSystem.cxx:1217
 TUnixSystem.cxx:1218
 TUnixSystem.cxx:1219
 TUnixSystem.cxx:1220
 TUnixSystem.cxx:1221
 TUnixSystem.cxx:1222
 TUnixSystem.cxx:1223
 TUnixSystem.cxx:1224
 TUnixSystem.cxx:1225
 TUnixSystem.cxx:1226
 TUnixSystem.cxx:1227
 TUnixSystem.cxx:1228
 TUnixSystem.cxx:1229
 TUnixSystem.cxx:1230
 TUnixSystem.cxx:1231
 TUnixSystem.cxx:1232
 TUnixSystem.cxx:1233
 TUnixSystem.cxx:1234
 TUnixSystem.cxx:1235
 TUnixSystem.cxx:1236
 TUnixSystem.cxx:1237
 TUnixSystem.cxx:1238
 TUnixSystem.cxx:1239
 TUnixSystem.cxx:1240
 TUnixSystem.cxx:1241
 TUnixSystem.cxx:1242
 TUnixSystem.cxx:1243
 TUnixSystem.cxx:1244
 TUnixSystem.cxx:1245
 TUnixSystem.cxx:1246
 TUnixSystem.cxx:1247
 TUnixSystem.cxx:1248
 TUnixSystem.cxx:1249
 TUnixSystem.cxx:1250
 TUnixSystem.cxx:1251
 TUnixSystem.cxx:1252
 TUnixSystem.cxx:1253
 TUnixSystem.cxx:1254
 TUnixSystem.cxx:1255
 TUnixSystem.cxx:1256
 TUnixSystem.cxx:1257
 TUnixSystem.cxx:1258
 TUnixSystem.cxx:1259
 TUnixSystem.cxx:1260
 TUnixSystem.cxx:1261
 TUnixSystem.cxx:1262
 TUnixSystem.cxx:1263
 TUnixSystem.cxx:1264
 TUnixSystem.cxx:1265
 TUnixSystem.cxx:1266
 TUnixSystem.cxx:1267
 TUnixSystem.cxx:1268
 TUnixSystem.cxx:1269
 TUnixSystem.cxx:1270
 TUnixSystem.cxx:1271
 TUnixSystem.cxx:1272
 TUnixSystem.cxx:1273
 TUnixSystem.cxx:1274
 TUnixSystem.cxx:1275
 TUnixSystem.cxx:1276
 TUnixSystem.cxx:1277
 TUnixSystem.cxx:1278
 TUnixSystem.cxx:1279
 TUnixSystem.cxx:1280
 TUnixSystem.cxx:1281
 TUnixSystem.cxx:1282
 TUnixSystem.cxx:1283
 TUnixSystem.cxx:1284
 TUnixSystem.cxx:1285
 TUnixSystem.cxx:1286
 TUnixSystem.cxx:1287
 TUnixSystem.cxx:1288
 TUnixSystem.cxx:1289
 TUnixSystem.cxx:1290
 TUnixSystem.cxx:1291
 TUnixSystem.cxx:1292
 TUnixSystem.cxx:1293
 TUnixSystem.cxx:1294
 TUnixSystem.cxx:1295
 TUnixSystem.cxx:1296
 TUnixSystem.cxx:1297
 TUnixSystem.cxx:1298
 TUnixSystem.cxx:1299
 TUnixSystem.cxx:1300
 TUnixSystem.cxx:1301
 TUnixSystem.cxx:1302
 TUnixSystem.cxx:1303
 TUnixSystem.cxx:1304
 TUnixSystem.cxx:1305
 TUnixSystem.cxx:1306
 TUnixSystem.cxx:1307
 TUnixSystem.cxx:1308
 TUnixSystem.cxx:1309
 TUnixSystem.cxx:1310
 TUnixSystem.cxx:1311
 TUnixSystem.cxx:1312
 TUnixSystem.cxx:1313
 TUnixSystem.cxx:1314
 TUnixSystem.cxx:1315
 TUnixSystem.cxx:1316
 TUnixSystem.cxx:1317
 TUnixSystem.cxx:1318
 TUnixSystem.cxx:1319
 TUnixSystem.cxx:1320
 TUnixSystem.cxx:1321
 TUnixSystem.cxx:1322
 TUnixSystem.cxx:1323
 TUnixSystem.cxx:1324
 TUnixSystem.cxx:1325
 TUnixSystem.cxx:1326
 TUnixSystem.cxx:1327
 TUnixSystem.cxx:1328
 TUnixSystem.cxx:1329
 TUnixSystem.cxx:1330
 TUnixSystem.cxx:1331
 TUnixSystem.cxx:1332
 TUnixSystem.cxx:1333
 TUnixSystem.cxx:1334
 TUnixSystem.cxx:1335
 TUnixSystem.cxx:1336
 TUnixSystem.cxx:1337
 TUnixSystem.cxx:1338
 TUnixSystem.cxx:1339
 TUnixSystem.cxx:1340
 TUnixSystem.cxx:1341
 TUnixSystem.cxx:1342
 TUnixSystem.cxx:1343
 TUnixSystem.cxx:1344
 TUnixSystem.cxx:1345
 TUnixSystem.cxx:1346
 TUnixSystem.cxx:1347
 TUnixSystem.cxx:1348
 TUnixSystem.cxx:1349
 TUnixSystem.cxx:1350
 TUnixSystem.cxx:1351
 TUnixSystem.cxx:1352
 TUnixSystem.cxx:1353
 TUnixSystem.cxx:1354
 TUnixSystem.cxx:1355
 TUnixSystem.cxx:1356
 TUnixSystem.cxx:1357
 TUnixSystem.cxx:1358
 TUnixSystem.cxx:1359
 TUnixSystem.cxx:1360
 TUnixSystem.cxx:1361
 TUnixSystem.cxx:1362
 TUnixSystem.cxx:1363
 TUnixSystem.cxx:1364
 TUnixSystem.cxx:1365
 TUnixSystem.cxx:1366
 TUnixSystem.cxx:1367
 TUnixSystem.cxx:1368
 TUnixSystem.cxx:1369
 TUnixSystem.cxx:1370
 TUnixSystem.cxx:1371
 TUnixSystem.cxx:1372
 TUnixSystem.cxx:1373
 TUnixSystem.cxx:1374
 TUnixSystem.cxx:1375
 TUnixSystem.cxx:1376
 TUnixSystem.cxx:1377
 TUnixSystem.cxx:1378
 TUnixSystem.cxx:1379
 TUnixSystem.cxx:1380
 TUnixSystem.cxx:1381
 TUnixSystem.cxx:1382
 TUnixSystem.cxx:1383
 TUnixSystem.cxx:1384
 TUnixSystem.cxx:1385
 TUnixSystem.cxx:1386
 TUnixSystem.cxx:1387
 TUnixSystem.cxx:1388
 TUnixSystem.cxx:1389
 TUnixSystem.cxx:1390
 TUnixSystem.cxx:1391
 TUnixSystem.cxx:1392
 TUnixSystem.cxx:1393
 TUnixSystem.cxx:1394
 TUnixSystem.cxx:1395
 TUnixSystem.cxx:1396
 TUnixSystem.cxx:1397
 TUnixSystem.cxx:1398
 TUnixSystem.cxx:1399
 TUnixSystem.cxx:1400
 TUnixSystem.cxx:1401
 TUnixSystem.cxx:1402
 TUnixSystem.cxx:1403
 TUnixSystem.cxx:1404
 TUnixSystem.cxx:1405
 TUnixSystem.cxx:1406
 TUnixSystem.cxx:1407
 TUnixSystem.cxx:1408
 TUnixSystem.cxx:1409
 TUnixSystem.cxx:1410
 TUnixSystem.cxx:1411
 TUnixSystem.cxx:1412
 TUnixSystem.cxx:1413
 TUnixSystem.cxx:1414
 TUnixSystem.cxx:1415
 TUnixSystem.cxx:1416
 TUnixSystem.cxx:1417
 TUnixSystem.cxx:1418
 TUnixSystem.cxx:1419
 TUnixSystem.cxx:1420
 TUnixSystem.cxx:1421
 TUnixSystem.cxx:1422
 TUnixSystem.cxx:1423
 TUnixSystem.cxx:1424
 TUnixSystem.cxx:1425
 TUnixSystem.cxx:1426
 TUnixSystem.cxx:1427
 TUnixSystem.cxx:1428
 TUnixSystem.cxx:1429
 TUnixSystem.cxx:1430
 TUnixSystem.cxx:1431
 TUnixSystem.cxx:1432
 TUnixSystem.cxx:1433
 TUnixSystem.cxx:1434
 TUnixSystem.cxx:1435
 TUnixSystem.cxx:1436
 TUnixSystem.cxx:1437
 TUnixSystem.cxx:1438
 TUnixSystem.cxx:1439
 TUnixSystem.cxx:1440
 TUnixSystem.cxx:1441
 TUnixSystem.cxx:1442
 TUnixSystem.cxx:1443
 TUnixSystem.cxx:1444
 TUnixSystem.cxx:1445
 TUnixSystem.cxx:1446
 TUnixSystem.cxx:1447
 TUnixSystem.cxx:1448
 TUnixSystem.cxx:1449
 TUnixSystem.cxx:1450
 TUnixSystem.cxx:1451
 TUnixSystem.cxx:1452
 TUnixSystem.cxx:1453
 TUnixSystem.cxx:1454
 TUnixSystem.cxx:1455
 TUnixSystem.cxx:1456
 TUnixSystem.cxx:1457
 TUnixSystem.cxx:1458
 TUnixSystem.cxx:1459
 TUnixSystem.cxx:1460
 TUnixSystem.cxx:1461
 TUnixSystem.cxx:1462
 TUnixSystem.cxx:1463
 TUnixSystem.cxx:1464
 TUnixSystem.cxx:1465
 TUnixSystem.cxx:1466
 TUnixSystem.cxx:1467
 TUnixSystem.cxx:1468
 TUnixSystem.cxx:1469
 TUnixSystem.cxx:1470
 TUnixSystem.cxx:1471
 TUnixSystem.cxx:1472
 TUnixSystem.cxx:1473
 TUnixSystem.cxx:1474
 TUnixSystem.cxx:1475
 TUnixSystem.cxx:1476
 TUnixSystem.cxx:1477
 TUnixSystem.cxx:1478
 TUnixSystem.cxx:1479
 TUnixSystem.cxx:1480
 TUnixSystem.cxx:1481
 TUnixSystem.cxx:1482
 TUnixSystem.cxx:1483
 TUnixSystem.cxx:1484
 TUnixSystem.cxx:1485
 TUnixSystem.cxx:1486
 TUnixSystem.cxx:1487
 TUnixSystem.cxx:1488
 TUnixSystem.cxx:1489
 TUnixSystem.cxx:1490
 TUnixSystem.cxx:1491
 TUnixSystem.cxx:1492
 TUnixSystem.cxx:1493
 TUnixSystem.cxx:1494
 TUnixSystem.cxx:1495
 TUnixSystem.cxx:1496
 TUnixSystem.cxx:1497
 TUnixSystem.cxx:1498
 TUnixSystem.cxx:1499
 TUnixSystem.cxx:1500
 TUnixSystem.cxx:1501
 TUnixSystem.cxx:1502
 TUnixSystem.cxx:1503
 TUnixSystem.cxx:1504
 TUnixSystem.cxx:1505
 TUnixSystem.cxx:1506
 TUnixSystem.cxx:1507
 TUnixSystem.cxx:1508
 TUnixSystem.cxx:1509
 TUnixSystem.cxx:1510
 TUnixSystem.cxx:1511
 TUnixSystem.cxx:1512
 TUnixSystem.cxx:1513
 TUnixSystem.cxx:1514
 TUnixSystem.cxx:1515
 TUnixSystem.cxx:1516
 TUnixSystem.cxx:1517
 TUnixSystem.cxx:1518
 TUnixSystem.cxx:1519
 TUnixSystem.cxx:1520
 TUnixSystem.cxx:1521
 TUnixSystem.cxx:1522
 TUnixSystem.cxx:1523
 TUnixSystem.cxx:1524
 TUnixSystem.cxx:1525
 TUnixSystem.cxx:1526
 TUnixSystem.cxx:1527
 TUnixSystem.cxx:1528
 TUnixSystem.cxx:1529
 TUnixSystem.cxx:1530
 TUnixSystem.cxx:1531
 TUnixSystem.cxx:1532
 TUnixSystem.cxx:1533
 TUnixSystem.cxx:1534
 TUnixSystem.cxx:1535
 TUnixSystem.cxx:1536
 TUnixSystem.cxx:1537
 TUnixSystem.cxx:1538
 TUnixSystem.cxx:1539
 TUnixSystem.cxx:1540
 TUnixSystem.cxx:1541
 TUnixSystem.cxx:1542
 TUnixSystem.cxx:1543
 TUnixSystem.cxx:1544
 TUnixSystem.cxx:1545
 TUnixSystem.cxx:1546
 TUnixSystem.cxx:1547
 TUnixSystem.cxx:1548
 TUnixSystem.cxx:1549
 TUnixSystem.cxx:1550
 TUnixSystem.cxx:1551
 TUnixSystem.cxx:1552
 TUnixSystem.cxx:1553
 TUnixSystem.cxx:1554
 TUnixSystem.cxx:1555
 TUnixSystem.cxx:1556
 TUnixSystem.cxx:1557
 TUnixSystem.cxx:1558
 TUnixSystem.cxx:1559
 TUnixSystem.cxx:1560
 TUnixSystem.cxx:1561
 TUnixSystem.cxx:1562
 TUnixSystem.cxx:1563
 TUnixSystem.cxx:1564
 TUnixSystem.cxx:1565
 TUnixSystem.cxx:1566
 TUnixSystem.cxx:1567
 TUnixSystem.cxx:1568
 TUnixSystem.cxx:1569
 TUnixSystem.cxx:1570
 TUnixSystem.cxx:1571
 TUnixSystem.cxx:1572
 TUnixSystem.cxx:1573
 TUnixSystem.cxx:1574
 TUnixSystem.cxx:1575
 TUnixSystem.cxx:1576
 TUnixSystem.cxx:1577
 TUnixSystem.cxx:1578
 TUnixSystem.cxx:1579
 TUnixSystem.cxx:1580
 TUnixSystem.cxx:1581
 TUnixSystem.cxx:1582
 TUnixSystem.cxx:1583
 TUnixSystem.cxx:1584
 TUnixSystem.cxx:1585
 TUnixSystem.cxx:1586
 TUnixSystem.cxx:1587
 TUnixSystem.cxx:1588
 TUnixSystem.cxx:1589
 TUnixSystem.cxx:1590
 TUnixSystem.cxx:1591
 TUnixSystem.cxx:1592
 TUnixSystem.cxx:1593
 TUnixSystem.cxx:1594
 TUnixSystem.cxx:1595
 TUnixSystem.cxx:1596
 TUnixSystem.cxx:1597
 TUnixSystem.cxx:1598
 TUnixSystem.cxx:1599
 TUnixSystem.cxx:1600
 TUnixSystem.cxx:1601
 TUnixSystem.cxx:1602
 TUnixSystem.cxx:1603
 TUnixSystem.cxx:1604
 TUnixSystem.cxx:1605
 TUnixSystem.cxx:1606
 TUnixSystem.cxx:1607
 TUnixSystem.cxx:1608
 TUnixSystem.cxx:1609
 TUnixSystem.cxx:1610
 TUnixSystem.cxx:1611
 TUnixSystem.cxx:1612
 TUnixSystem.cxx:1613
 TUnixSystem.cxx:1614
 TUnixSystem.cxx:1615
 TUnixSystem.cxx:1616
 TUnixSystem.cxx:1617
 TUnixSystem.cxx:1618
 TUnixSystem.cxx:1619
 TUnixSystem.cxx:1620
 TUnixSystem.cxx:1621
 TUnixSystem.cxx:1622
 TUnixSystem.cxx:1623
 TUnixSystem.cxx:1624
 TUnixSystem.cxx:1625
 TUnixSystem.cxx:1626
 TUnixSystem.cxx:1627
 TUnixSystem.cxx:1628
 TUnixSystem.cxx:1629
 TUnixSystem.cxx:1630
 TUnixSystem.cxx:1631
 TUnixSystem.cxx:1632
 TUnixSystem.cxx:1633
 TUnixSystem.cxx:1634
 TUnixSystem.cxx:1635
 TUnixSystem.cxx:1636
 TUnixSystem.cxx:1637
 TUnixSystem.cxx:1638
 TUnixSystem.cxx:1639
 TUnixSystem.cxx:1640
 TUnixSystem.cxx:1641
 TUnixSystem.cxx:1642
 TUnixSystem.cxx:1643
 TUnixSystem.cxx:1644
 TUnixSystem.cxx:1645
 TUnixSystem.cxx:1646
 TUnixSystem.cxx:1647
 TUnixSystem.cxx:1648
 TUnixSystem.cxx:1649
 TUnixSystem.cxx:1650
 TUnixSystem.cxx:1651
 TUnixSystem.cxx:1652
 TUnixSystem.cxx:1653
 TUnixSystem.cxx:1654
 TUnixSystem.cxx:1655
 TUnixSystem.cxx:1656
 TUnixSystem.cxx:1657
 TUnixSystem.cxx:1658
 TUnixSystem.cxx:1659
 TUnixSystem.cxx:1660
 TUnixSystem.cxx:1661
 TUnixSystem.cxx:1662
 TUnixSystem.cxx:1663
 TUnixSystem.cxx:1664
 TUnixSystem.cxx:1665
 TUnixSystem.cxx:1666
 TUnixSystem.cxx:1667
 TUnixSystem.cxx:1668
 TUnixSystem.cxx:1669
 TUnixSystem.cxx:1670
 TUnixSystem.cxx:1671
 TUnixSystem.cxx:1672
 TUnixSystem.cxx:1673
 TUnixSystem.cxx:1674
 TUnixSystem.cxx:1675
 TUnixSystem.cxx:1676
 TUnixSystem.cxx:1677
 TUnixSystem.cxx:1678
 TUnixSystem.cxx:1679
 TUnixSystem.cxx:1680
 TUnixSystem.cxx:1681
 TUnixSystem.cxx:1682
 TUnixSystem.cxx:1683
 TUnixSystem.cxx:1684
 TUnixSystem.cxx:1685
 TUnixSystem.cxx:1686
 TUnixSystem.cxx:1687
 TUnixSystem.cxx:1688
 TUnixSystem.cxx:1689
 TUnixSystem.cxx:1690
 TUnixSystem.cxx:1691
 TUnixSystem.cxx:1692
 TUnixSystem.cxx:1693
 TUnixSystem.cxx:1694
 TUnixSystem.cxx:1695
 TUnixSystem.cxx:1696
 TUnixSystem.cxx:1697
 TUnixSystem.cxx:1698
 TUnixSystem.cxx:1699
 TUnixSystem.cxx:1700
 TUnixSystem.cxx:1701
 TUnixSystem.cxx:1702
 TUnixSystem.cxx:1703
 TUnixSystem.cxx:1704
 TUnixSystem.cxx:1705
 TUnixSystem.cxx:1706
 TUnixSystem.cxx:1707
 TUnixSystem.cxx:1708
 TUnixSystem.cxx:1709
 TUnixSystem.cxx:1710
 TUnixSystem.cxx:1711
 TUnixSystem.cxx:1712
 TUnixSystem.cxx:1713
 TUnixSystem.cxx:1714
 TUnixSystem.cxx:1715
 TUnixSystem.cxx:1716
 TUnixSystem.cxx:1717
 TUnixSystem.cxx:1718
 TUnixSystem.cxx:1719
 TUnixSystem.cxx:1720
 TUnixSystem.cxx:1721
 TUnixSystem.cxx:1722
 TUnixSystem.cxx:1723
 TUnixSystem.cxx:1724
 TUnixSystem.cxx:1725
 TUnixSystem.cxx:1726
 TUnixSystem.cxx:1727
 TUnixSystem.cxx:1728
 TUnixSystem.cxx:1729
 TUnixSystem.cxx:1730
 TUnixSystem.cxx:1731
 TUnixSystem.cxx:1732
 TUnixSystem.cxx:1733
 TUnixSystem.cxx:1734
 TUnixSystem.cxx:1735
 TUnixSystem.cxx:1736
 TUnixSystem.cxx:1737
 TUnixSystem.cxx:1738
 TUnixSystem.cxx:1739
 TUnixSystem.cxx:1740
 TUnixSystem.cxx:1741
 TUnixSystem.cxx:1742
 TUnixSystem.cxx:1743
 TUnixSystem.cxx:1744
 TUnixSystem.cxx:1745
 TUnixSystem.cxx:1746
 TUnixSystem.cxx:1747
 TUnixSystem.cxx:1748
 TUnixSystem.cxx:1749
 TUnixSystem.cxx:1750
 TUnixSystem.cxx:1751
 TUnixSystem.cxx:1752
 TUnixSystem.cxx:1753
 TUnixSystem.cxx:1754
 TUnixSystem.cxx:1755
 TUnixSystem.cxx:1756
 TUnixSystem.cxx:1757
 TUnixSystem.cxx:1758
 TUnixSystem.cxx:1759
 TUnixSystem.cxx:1760
 TUnixSystem.cxx:1761
 TUnixSystem.cxx:1762
 TUnixSystem.cxx:1763
 TUnixSystem.cxx:1764
 TUnixSystem.cxx:1765
 TUnixSystem.cxx:1766
 TUnixSystem.cxx:1767
 TUnixSystem.cxx:1768
 TUnixSystem.cxx:1769
 TUnixSystem.cxx:1770
 TUnixSystem.cxx:1771
 TUnixSystem.cxx:1772
 TUnixSystem.cxx:1773
 TUnixSystem.cxx:1774
 TUnixSystem.cxx:1775
 TUnixSystem.cxx:1776
 TUnixSystem.cxx:1777
 TUnixSystem.cxx:1778
 TUnixSystem.cxx:1779
 TUnixSystem.cxx:1780
 TUnixSystem.cxx:1781
 TUnixSystem.cxx:1782
 TUnixSystem.cxx:1783
 TUnixSystem.cxx:1784
 TUnixSystem.cxx:1785
 TUnixSystem.cxx:1786
 TUnixSystem.cxx:1787
 TUnixSystem.cxx:1788
 TUnixSystem.cxx:1789
 TUnixSystem.cxx:1790
 TUnixSystem.cxx:1791
 TUnixSystem.cxx:1792
 TUnixSystem.cxx:1793
 TUnixSystem.cxx:1794
 TUnixSystem.cxx:1795
 TUnixSystem.cxx:1796
 TUnixSystem.cxx:1797
 TUnixSystem.cxx:1798
 TUnixSystem.cxx:1799
 TUnixSystem.cxx:1800
 TUnixSystem.cxx:1801
 TUnixSystem.cxx:1802
 TUnixSystem.cxx:1803
 TUnixSystem.cxx:1804
 TUnixSystem.cxx:1805
 TUnixSystem.cxx:1806
 TUnixSystem.cxx:1807
 TUnixSystem.cxx:1808
 TUnixSystem.cxx:1809
 TUnixSystem.cxx:1810
 TUnixSystem.cxx:1811
 TUnixSystem.cxx:1812
 TUnixSystem.cxx:1813
 TUnixSystem.cxx:1814
 TUnixSystem.cxx:1815
 TUnixSystem.cxx:1816
 TUnixSystem.cxx:1817
 TUnixSystem.cxx:1818
 TUnixSystem.cxx:1819
 TUnixSystem.cxx:1820
 TUnixSystem.cxx:1821
 TUnixSystem.cxx:1822
 TUnixSystem.cxx:1823
 TUnixSystem.cxx:1824
 TUnixSystem.cxx:1825
 TUnixSystem.cxx:1826
 TUnixSystem.cxx:1827
 TUnixSystem.cxx:1828
 TUnixSystem.cxx:1829
 TUnixSystem.cxx:1830
 TUnixSystem.cxx:1831
 TUnixSystem.cxx:1832
 TUnixSystem.cxx:1833
 TUnixSystem.cxx:1834
 TUnixSystem.cxx:1835
 TUnixSystem.cxx:1836
 TUnixSystem.cxx:1837
 TUnixSystem.cxx:1838
 TUnixSystem.cxx:1839
 TUnixSystem.cxx:1840
 TUnixSystem.cxx:1841
 TUnixSystem.cxx:1842
 TUnixSystem.cxx:1843
 TUnixSystem.cxx:1844
 TUnixSystem.cxx:1845
 TUnixSystem.cxx:1846
 TUnixSystem.cxx:1847
 TUnixSystem.cxx:1848
 TUnixSystem.cxx:1849
 TUnixSystem.cxx:1850
 TUnixSystem.cxx:1851
 TUnixSystem.cxx:1852
 TUnixSystem.cxx:1853
 TUnixSystem.cxx:1854
 TUnixSystem.cxx:1855
 TUnixSystem.cxx:1856
 TUnixSystem.cxx:1857
 TUnixSystem.cxx:1858
 TUnixSystem.cxx:1859
 TUnixSystem.cxx:1860
 TUnixSystem.cxx:1861
 TUnixSystem.cxx:1862
 TUnixSystem.cxx:1863
 TUnixSystem.cxx:1864
 TUnixSystem.cxx:1865
 TUnixSystem.cxx:1866
 TUnixSystem.cxx:1867
 TUnixSystem.cxx:1868
 TUnixSystem.cxx:1869
 TUnixSystem.cxx:1870
 TUnixSystem.cxx:1871
 TUnixSystem.cxx:1872
 TUnixSystem.cxx:1873
 TUnixSystem.cxx:1874
 TUnixSystem.cxx:1875
 TUnixSystem.cxx:1876
 TUnixSystem.cxx:1877
 TUnixSystem.cxx:1878
 TUnixSystem.cxx:1879
 TUnixSystem.cxx:1880
 TUnixSystem.cxx:1881
 TUnixSystem.cxx:1882
 TUnixSystem.cxx:1883
 TUnixSystem.cxx:1884
 TUnixSystem.cxx:1885
 TUnixSystem.cxx:1886
 TUnixSystem.cxx:1887
 TUnixSystem.cxx:1888
 TUnixSystem.cxx:1889
 TUnixSystem.cxx:1890
 TUnixSystem.cxx:1891
 TUnixSystem.cxx:1892
 TUnixSystem.cxx:1893
 TUnixSystem.cxx:1894
 TUnixSystem.cxx:1895
 TUnixSystem.cxx:1896
 TUnixSystem.cxx:1897
 TUnixSystem.cxx:1898
 TUnixSystem.cxx:1899
 TUnixSystem.cxx:1900
 TUnixSystem.cxx:1901
 TUnixSystem.cxx:1902
 TUnixSystem.cxx:1903
 TUnixSystem.cxx:1904
 TUnixSystem.cxx:1905
 TUnixSystem.cxx:1906
 TUnixSystem.cxx:1907
 TUnixSystem.cxx:1908
 TUnixSystem.cxx:1909
 TUnixSystem.cxx:1910
 TUnixSystem.cxx:1911
 TUnixSystem.cxx:1912
 TUnixSystem.cxx:1913
 TUnixSystem.cxx:1914
 TUnixSystem.cxx:1915
 TUnixSystem.cxx:1916
 TUnixSystem.cxx:1917
 TUnixSystem.cxx:1918
 TUnixSystem.cxx:1919
 TUnixSystem.cxx:1920
 TUnixSystem.cxx:1921
 TUnixSystem.cxx:1922
 TUnixSystem.cxx:1923
 TUnixSystem.cxx:1924
 TUnixSystem.cxx:1925
 TUnixSystem.cxx:1926
 TUnixSystem.cxx:1927
 TUnixSystem.cxx:1928
 TUnixSystem.cxx:1929
 TUnixSystem.cxx:1930
 TUnixSystem.cxx:1931
 TUnixSystem.cxx:1932
 TUnixSystem.cxx:1933
 TUnixSystem.cxx:1934
 TUnixSystem.cxx:1935
 TUnixSystem.cxx:1936
 TUnixSystem.cxx:1937
 TUnixSystem.cxx:1938
 TUnixSystem.cxx:1939
 TUnixSystem.cxx:1940
 TUnixSystem.cxx:1941
 TUnixSystem.cxx:1942
 TUnixSystem.cxx:1943
 TUnixSystem.cxx:1944
 TUnixSystem.cxx:1945
 TUnixSystem.cxx:1946
 TUnixSystem.cxx:1947
 TUnixSystem.cxx:1948
 TUnixSystem.cxx:1949
 TUnixSystem.cxx:1950
 TUnixSystem.cxx:1951
 TUnixSystem.cxx:1952
 TUnixSystem.cxx:1953
 TUnixSystem.cxx:1954
 TUnixSystem.cxx:1955
 TUnixSystem.cxx:1956
 TUnixSystem.cxx:1957
 TUnixSystem.cxx:1958
 TUnixSystem.cxx:1959
 TUnixSystem.cxx:1960
 TUnixSystem.cxx:1961
 TUnixSystem.cxx:1962
 TUnixSystem.cxx:1963
 TUnixSystem.cxx:1964
 TUnixSystem.cxx:1965
 TUnixSystem.cxx:1966
 TUnixSystem.cxx:1967
 TUnixSystem.cxx:1968
 TUnixSystem.cxx:1969
 TUnixSystem.cxx:1970
 TUnixSystem.cxx:1971
 TUnixSystem.cxx:1972
 TUnixSystem.cxx:1973
 TUnixSystem.cxx:1974
 TUnixSystem.cxx:1975
 TUnixSystem.cxx:1976
 TUnixSystem.cxx:1977
 TUnixSystem.cxx:1978
 TUnixSystem.cxx:1979
 TUnixSystem.cxx:1980
 TUnixSystem.cxx:1981
 TUnixSystem.cxx:1982
 TUnixSystem.cxx:1983
 TUnixSystem.cxx:1984
 TUnixSystem.cxx:1985
 TUnixSystem.cxx:1986
 TUnixSystem.cxx:1987
 TUnixSystem.cxx:1988
 TUnixSystem.cxx:1989
 TUnixSystem.cxx:1990
 TUnixSystem.cxx:1991
 TUnixSystem.cxx:1992
 TUnixSystem.cxx:1993
 TUnixSystem.cxx:1994
 TUnixSystem.cxx:1995
 TUnixSystem.cxx:1996
 TUnixSystem.cxx:1997
 TUnixSystem.cxx:1998
 TUnixSystem.cxx:1999
 TUnixSystem.cxx:2000
 TUnixSystem.cxx:2001
 TUnixSystem.cxx:2002
 TUnixSystem.cxx:2003
 TUnixSystem.cxx:2004
 TUnixSystem.cxx:2005
 TUnixSystem.cxx:2006
 TUnixSystem.cxx:2007
 TUnixSystem.cxx:2008
 TUnixSystem.cxx:2009
 TUnixSystem.cxx:2010
 TUnixSystem.cxx:2011
 TUnixSystem.cxx:2012
 TUnixSystem.cxx:2013
 TUnixSystem.cxx:2014
 TUnixSystem.cxx:2015
 TUnixSystem.cxx:2016
 TUnixSystem.cxx:2017
 TUnixSystem.cxx:2018
 TUnixSystem.cxx:2019
 TUnixSystem.cxx:2020
 TUnixSystem.cxx:2021
 TUnixSystem.cxx:2022
 TUnixSystem.cxx:2023
 TUnixSystem.cxx:2024
 TUnixSystem.cxx:2025
 TUnixSystem.cxx:2026
 TUnixSystem.cxx:2027
 TUnixSystem.cxx:2028
 TUnixSystem.cxx:2029
 TUnixSystem.cxx:2030
 TUnixSystem.cxx:2031
 TUnixSystem.cxx:2032
 TUnixSystem.cxx:2033
 TUnixSystem.cxx:2034
 TUnixSystem.cxx:2035
 TUnixSystem.cxx:2036
 TUnixSystem.cxx:2037
 TUnixSystem.cxx:2038
 TUnixSystem.cxx:2039
 TUnixSystem.cxx:2040
 TUnixSystem.cxx:2041
 TUnixSystem.cxx:2042
 TUnixSystem.cxx:2043
 TUnixSystem.cxx:2044
 TUnixSystem.cxx:2045
 TUnixSystem.cxx:2046
 TUnixSystem.cxx:2047
 TUnixSystem.cxx:2048
 TUnixSystem.cxx:2049
 TUnixSystem.cxx:2050
 TUnixSystem.cxx:2051
 TUnixSystem.cxx:2052
 TUnixSystem.cxx:2053
 TUnixSystem.cxx:2054
 TUnixSystem.cxx:2055
 TUnixSystem.cxx:2056
 TUnixSystem.cxx:2057
 TUnixSystem.cxx:2058
 TUnixSystem.cxx:2059
 TUnixSystem.cxx:2060
 TUnixSystem.cxx:2061
 TUnixSystem.cxx:2062
 TUnixSystem.cxx:2063
 TUnixSystem.cxx:2064
 TUnixSystem.cxx:2065
 TUnixSystem.cxx:2066
 TUnixSystem.cxx:2067
 TUnixSystem.cxx:2068
 TUnixSystem.cxx:2069
 TUnixSystem.cxx:2070
 TUnixSystem.cxx:2071
 TUnixSystem.cxx:2072
 TUnixSystem.cxx:2073
 TUnixSystem.cxx:2074
 TUnixSystem.cxx:2075
 TUnixSystem.cxx:2076
 TUnixSystem.cxx:2077
 TUnixSystem.cxx:2078
 TUnixSystem.cxx:2079
 TUnixSystem.cxx:2080
 TUnixSystem.cxx:2081
 TUnixSystem.cxx:2082
 TUnixSystem.cxx:2083
 TUnixSystem.cxx:2084
 TUnixSystem.cxx:2085
 TUnixSystem.cxx:2086
 TUnixSystem.cxx:2087
 TUnixSystem.cxx:2088
 TUnixSystem.cxx:2089
 TUnixSystem.cxx:2090
 TUnixSystem.cxx:2091
 TUnixSystem.cxx:2092
 TUnixSystem.cxx:2093
 TUnixSystem.cxx:2094
 TUnixSystem.cxx:2095
 TUnixSystem.cxx:2096
 TUnixSystem.cxx:2097
 TUnixSystem.cxx:2098
 TUnixSystem.cxx:2099
 TUnixSystem.cxx:2100
 TUnixSystem.cxx:2101
 TUnixSystem.cxx:2102
 TUnixSystem.cxx:2103
 TUnixSystem.cxx:2104
 TUnixSystem.cxx:2105
 TUnixSystem.cxx:2106
 TUnixSystem.cxx:2107
 TUnixSystem.cxx:2108
 TUnixSystem.cxx:2109
 TUnixSystem.cxx:2110
 TUnixSystem.cxx:2111
 TUnixSystem.cxx:2112
 TUnixSystem.cxx:2113
 TUnixSystem.cxx:2114
 TUnixSystem.cxx:2115
 TUnixSystem.cxx:2116
 TUnixSystem.cxx:2117
 TUnixSystem.cxx:2118
 TUnixSystem.cxx:2119
 TUnixSystem.cxx:2120
 TUnixSystem.cxx:2121
 TUnixSystem.cxx:2122
 TUnixSystem.cxx:2123
 TUnixSystem.cxx:2124
 TUnixSystem.cxx:2125
 TUnixSystem.cxx:2126
 TUnixSystem.cxx:2127
 TUnixSystem.cxx:2128
 TUnixSystem.cxx:2129
 TUnixSystem.cxx:2130
 TUnixSystem.cxx:2131
 TUnixSystem.cxx:2132
 TUnixSystem.cxx:2133
 TUnixSystem.cxx:2134
 TUnixSystem.cxx:2135
 TUnixSystem.cxx:2136
 TUnixSystem.cxx:2137
 TUnixSystem.cxx:2138
 TUnixSystem.cxx:2139
 TUnixSystem.cxx:2140
 TUnixSystem.cxx:2141
 TUnixSystem.cxx:2142
 TUnixSystem.cxx:2143
 TUnixSystem.cxx:2144
 TUnixSystem.cxx:2145
 TUnixSystem.cxx:2146
 TUnixSystem.cxx:2147
 TUnixSystem.cxx:2148
 TUnixSystem.cxx:2149
 TUnixSystem.cxx:2150
 TUnixSystem.cxx:2151
 TUnixSystem.cxx:2152
 TUnixSystem.cxx:2153
 TUnixSystem.cxx:2154
 TUnixSystem.cxx:2155
 TUnixSystem.cxx:2156
 TUnixSystem.cxx:2157
 TUnixSystem.cxx:2158
 TUnixSystem.cxx:2159
 TUnixSystem.cxx:2160
 TUnixSystem.cxx:2161
 TUnixSystem.cxx:2162
 TUnixSystem.cxx:2163
 TUnixSystem.cxx:2164
 TUnixSystem.cxx:2165
 TUnixSystem.cxx:2166
 TUnixSystem.cxx:2167
 TUnixSystem.cxx:2168
 TUnixSystem.cxx:2169
 TUnixSystem.cxx:2170
 TUnixSystem.cxx:2171
 TUnixSystem.cxx:2172
 TUnixSystem.cxx:2173
 TUnixSystem.cxx:2174
 TUnixSystem.cxx:2175
 TUnixSystem.cxx:2176
 TUnixSystem.cxx:2177
 TUnixSystem.cxx:2178
 TUnixSystem.cxx:2179
 TUnixSystem.cxx:2180
 TUnixSystem.cxx:2181
 TUnixSystem.cxx:2182
 TUnixSystem.cxx:2183
 TUnixSystem.cxx:2184
 TUnixSystem.cxx:2185
 TUnixSystem.cxx:2186
 TUnixSystem.cxx:2187
 TUnixSystem.cxx:2188
 TUnixSystem.cxx:2189
 TUnixSystem.cxx:2190
 TUnixSystem.cxx:2191
 TUnixSystem.cxx:2192
 TUnixSystem.cxx:2193
 TUnixSystem.cxx:2194
 TUnixSystem.cxx:2195
 TUnixSystem.cxx:2196
 TUnixSystem.cxx:2197
 TUnixSystem.cxx:2198
 TUnixSystem.cxx:2199
 TUnixSystem.cxx:2200
 TUnixSystem.cxx:2201
 TUnixSystem.cxx:2202
 TUnixSystem.cxx:2203
 TUnixSystem.cxx:2204
 TUnixSystem.cxx:2205
 TUnixSystem.cxx:2206
 TUnixSystem.cxx:2207
 TUnixSystem.cxx:2208
 TUnixSystem.cxx:2209
 TUnixSystem.cxx:2210
 TUnixSystem.cxx:2211
 TUnixSystem.cxx:2212
 TUnixSystem.cxx:2213
 TUnixSystem.cxx:2214
 TUnixSystem.cxx:2215
 TUnixSystem.cxx:2216
 TUnixSystem.cxx:2217
 TUnixSystem.cxx:2218
 TUnixSystem.cxx:2219
 TUnixSystem.cxx:2220
 TUnixSystem.cxx:2221
 TUnixSystem.cxx:2222
 TUnixSystem.cxx:2223
 TUnixSystem.cxx:2224
 TUnixSystem.cxx:2225
 TUnixSystem.cxx:2226
 TUnixSystem.cxx:2227
 TUnixSystem.cxx:2228
 TUnixSystem.cxx:2229
 TUnixSystem.cxx:2230
 TUnixSystem.cxx:2231
 TUnixSystem.cxx:2232
 TUnixSystem.cxx:2233
 TUnixSystem.cxx:2234
 TUnixSystem.cxx:2235
 TUnixSystem.cxx:2236
 TUnixSystem.cxx:2237
 TUnixSystem.cxx:2238
 TUnixSystem.cxx:2239
 TUnixSystem.cxx:2240
 TUnixSystem.cxx:2241
 TUnixSystem.cxx:2242
 TUnixSystem.cxx:2243
 TUnixSystem.cxx:2244
 TUnixSystem.cxx:2245
 TUnixSystem.cxx:2246
 TUnixSystem.cxx:2247
 TUnixSystem.cxx:2248
 TUnixSystem.cxx:2249
 TUnixSystem.cxx:2250
 TUnixSystem.cxx:2251
 TUnixSystem.cxx:2252
 TUnixSystem.cxx:2253
 TUnixSystem.cxx:2254
 TUnixSystem.cxx:2255
 TUnixSystem.cxx:2256
 TUnixSystem.cxx:2257
 TUnixSystem.cxx:2258
 TUnixSystem.cxx:2259
 TUnixSystem.cxx:2260
 TUnixSystem.cxx:2261
 TUnixSystem.cxx:2262
 TUnixSystem.cxx:2263
 TUnixSystem.cxx:2264
 TUnixSystem.cxx:2265
 TUnixSystem.cxx:2266
 TUnixSystem.cxx:2267
 TUnixSystem.cxx:2268
 TUnixSystem.cxx:2269
 TUnixSystem.cxx:2270
 TUnixSystem.cxx:2271
 TUnixSystem.cxx:2272
 TUnixSystem.cxx:2273
 TUnixSystem.cxx:2274
 TUnixSystem.cxx:2275
 TUnixSystem.cxx:2276
 TUnixSystem.cxx:2277
 TUnixSystem.cxx:2278
 TUnixSystem.cxx:2279
 TUnixSystem.cxx:2280
 TUnixSystem.cxx:2281
 TUnixSystem.cxx:2282
 TUnixSystem.cxx:2283
 TUnixSystem.cxx:2284
 TUnixSystem.cxx:2285
 TUnixSystem.cxx:2286
 TUnixSystem.cxx:2287
 TUnixSystem.cxx:2288
 TUnixSystem.cxx:2289
 TUnixSystem.cxx:2290
 TUnixSystem.cxx:2291
 TUnixSystem.cxx:2292
 TUnixSystem.cxx:2293
 TUnixSystem.cxx:2294
 TUnixSystem.cxx:2295
 TUnixSystem.cxx:2296
 TUnixSystem.cxx:2297
 TUnixSystem.cxx:2298
 TUnixSystem.cxx:2299
 TUnixSystem.cxx:2300
 TUnixSystem.cxx:2301
 TUnixSystem.cxx:2302
 TUnixSystem.cxx:2303
 TUnixSystem.cxx:2304
 TUnixSystem.cxx:2305
 TUnixSystem.cxx:2306
 TUnixSystem.cxx:2307
 TUnixSystem.cxx:2308
 TUnixSystem.cxx:2309
 TUnixSystem.cxx:2310
 TUnixSystem.cxx:2311
 TUnixSystem.cxx:2312
 TUnixSystem.cxx:2313
 TUnixSystem.cxx:2314
 TUnixSystem.cxx:2315
 TUnixSystem.cxx:2316
 TUnixSystem.cxx:2317
 TUnixSystem.cxx:2318
 TUnixSystem.cxx:2319
 TUnixSystem.cxx:2320
 TUnixSystem.cxx:2321
 TUnixSystem.cxx:2322
 TUnixSystem.cxx:2323
 TUnixSystem.cxx:2324
 TUnixSystem.cxx:2325
 TUnixSystem.cxx:2326
 TUnixSystem.cxx:2327
 TUnixSystem.cxx:2328
 TUnixSystem.cxx:2329
 TUnixSystem.cxx:2330
 TUnixSystem.cxx:2331
 TUnixSystem.cxx:2332
 TUnixSystem.cxx:2333
 TUnixSystem.cxx:2334
 TUnixSystem.cxx:2335
 TUnixSystem.cxx:2336
 TUnixSystem.cxx:2337
 TUnixSystem.cxx:2338
 TUnixSystem.cxx:2339
 TUnixSystem.cxx:2340
 TUnixSystem.cxx:2341
 TUnixSystem.cxx:2342
 TUnixSystem.cxx:2343
 TUnixSystem.cxx:2344
 TUnixSystem.cxx:2345
 TUnixSystem.cxx:2346
 TUnixSystem.cxx:2347
 TUnixSystem.cxx:2348
 TUnixSystem.cxx:2349
 TUnixSystem.cxx:2350
 TUnixSystem.cxx:2351
 TUnixSystem.cxx:2352
 TUnixSystem.cxx:2353
 TUnixSystem.cxx:2354
 TUnixSystem.cxx:2355
 TUnixSystem.cxx:2356
 TUnixSystem.cxx:2357
 TUnixSystem.cxx:2358
 TUnixSystem.cxx:2359
 TUnixSystem.cxx:2360
 TUnixSystem.cxx:2361
 TUnixSystem.cxx:2362
 TUnixSystem.cxx:2363
 TUnixSystem.cxx:2364
 TUnixSystem.cxx:2365
 TUnixSystem.cxx:2366
 TUnixSystem.cxx:2367
 TUnixSystem.cxx:2368
 TUnixSystem.cxx:2369
 TUnixSystem.cxx:2370
 TUnixSystem.cxx:2371
 TUnixSystem.cxx:2372
 TUnixSystem.cxx:2373
 TUnixSystem.cxx:2374
 TUnixSystem.cxx:2375
 TUnixSystem.cxx:2376
 TUnixSystem.cxx:2377
 TUnixSystem.cxx:2378
 TUnixSystem.cxx:2379
 TUnixSystem.cxx:2380
 TUnixSystem.cxx:2381
 TUnixSystem.cxx:2382
 TUnixSystem.cxx:2383
 TUnixSystem.cxx:2384
 TUnixSystem.cxx:2385
 TUnixSystem.cxx:2386
 TUnixSystem.cxx:2387
 TUnixSystem.cxx:2388
 TUnixSystem.cxx:2389
 TUnixSystem.cxx:2390
 TUnixSystem.cxx:2391
 TUnixSystem.cxx:2392
 TUnixSystem.cxx:2393
 TUnixSystem.cxx:2394
 TUnixSystem.cxx:2395
 TUnixSystem.cxx:2396
 TUnixSystem.cxx:2397
 TUnixSystem.cxx:2398
 TUnixSystem.cxx:2399
 TUnixSystem.cxx:2400
 TUnixSystem.cxx:2401
 TUnixSystem.cxx:2402
 TUnixSystem.cxx:2403
 TUnixSystem.cxx:2404
 TUnixSystem.cxx:2405
 TUnixSystem.cxx:2406
 TUnixSystem.cxx:2407
 TUnixSystem.cxx:2408
 TUnixSystem.cxx:2409
 TUnixSystem.cxx:2410
 TUnixSystem.cxx:2411
 TUnixSystem.cxx:2412
 TUnixSystem.cxx:2413
 TUnixSystem.cxx:2414
 TUnixSystem.cxx:2415
 TUnixSystem.cxx:2416
 TUnixSystem.cxx:2417
 TUnixSystem.cxx:2418
 TUnixSystem.cxx:2419
 TUnixSystem.cxx:2420
 TUnixSystem.cxx:2421
 TUnixSystem.cxx:2422
 TUnixSystem.cxx:2423
 TUnixSystem.cxx:2424
 TUnixSystem.cxx:2425
 TUnixSystem.cxx:2426
 TUnixSystem.cxx:2427
 TUnixSystem.cxx:2428
 TUnixSystem.cxx:2429
 TUnixSystem.cxx:2430
 TUnixSystem.cxx:2431
 TUnixSystem.cxx:2432
 TUnixSystem.cxx:2433
 TUnixSystem.cxx:2434
 TUnixSystem.cxx:2435
 TUnixSystem.cxx:2436
 TUnixSystem.cxx:2437
 TUnixSystem.cxx:2438
 TUnixSystem.cxx:2439
 TUnixSystem.cxx:2440
 TUnixSystem.cxx:2441
 TUnixSystem.cxx:2442
 TUnixSystem.cxx:2443
 TUnixSystem.cxx:2444
 TUnixSystem.cxx:2445
 TUnixSystem.cxx:2446
 TUnixSystem.cxx:2447
 TUnixSystem.cxx:2448
 TUnixSystem.cxx:2449
 TUnixSystem.cxx:2450
 TUnixSystem.cxx:2451
 TUnixSystem.cxx:2452
 TUnixSystem.cxx:2453
 TUnixSystem.cxx:2454
 TUnixSystem.cxx:2455
 TUnixSystem.cxx:2456
 TUnixSystem.cxx:2457
 TUnixSystem.cxx:2458
 TUnixSystem.cxx:2459
 TUnixSystem.cxx:2460
 TUnixSystem.cxx:2461
 TUnixSystem.cxx:2462
 TUnixSystem.cxx:2463
 TUnixSystem.cxx:2464
 TUnixSystem.cxx:2465
 TUnixSystem.cxx:2466
 TUnixSystem.cxx:2467
 TUnixSystem.cxx:2468
 TUnixSystem.cxx:2469
 TUnixSystem.cxx:2470
 TUnixSystem.cxx:2471
 TUnixSystem.cxx:2472
 TUnixSystem.cxx:2473
 TUnixSystem.cxx:2474
 TUnixSystem.cxx:2475
 TUnixSystem.cxx:2476
 TUnixSystem.cxx:2477
 TUnixSystem.cxx:2478
 TUnixSystem.cxx:2479
 TUnixSystem.cxx:2480
 TUnixSystem.cxx:2481
 TUnixSystem.cxx:2482
 TUnixSystem.cxx:2483
 TUnixSystem.cxx:2484
 TUnixSystem.cxx:2485
 TUnixSystem.cxx:2486
 TUnixSystem.cxx:2487
 TUnixSystem.cxx:2488
 TUnixSystem.cxx:2489
 TUnixSystem.cxx:2490
 TUnixSystem.cxx:2491
 TUnixSystem.cxx:2492
 TUnixSystem.cxx:2493
 TUnixSystem.cxx:2494
 TUnixSystem.cxx:2495
 TUnixSystem.cxx:2496
 TUnixSystem.cxx:2497
 TUnixSystem.cxx:2498
 TUnixSystem.cxx:2499
 TUnixSystem.cxx:2500
 TUnixSystem.cxx:2501
 TUnixSystem.cxx:2502
 TUnixSystem.cxx:2503
 TUnixSystem.cxx:2504
 TUnixSystem.cxx:2505
 TUnixSystem.cxx:2506
 TUnixSystem.cxx:2507
 TUnixSystem.cxx:2508
 TUnixSystem.cxx:2509
 TUnixSystem.cxx:2510
 TUnixSystem.cxx:2511
 TUnixSystem.cxx:2512
 TUnixSystem.cxx:2513
 TUnixSystem.cxx:2514
 TUnixSystem.cxx:2515
 TUnixSystem.cxx:2516
 TUnixSystem.cxx:2517
 TUnixSystem.cxx:2518
 TUnixSystem.cxx:2519
 TUnixSystem.cxx:2520
 TUnixSystem.cxx:2521
 TUnixSystem.cxx:2522
 TUnixSystem.cxx:2523
 TUnixSystem.cxx:2524
 TUnixSystem.cxx:2525
 TUnixSystem.cxx:2526
 TUnixSystem.cxx:2527
 TUnixSystem.cxx:2528
 TUnixSystem.cxx:2529
 TUnixSystem.cxx:2530
 TUnixSystem.cxx:2531
 TUnixSystem.cxx:2532
 TUnixSystem.cxx:2533
 TUnixSystem.cxx:2534
 TUnixSystem.cxx:2535
 TUnixSystem.cxx:2536
 TUnixSystem.cxx:2537
 TUnixSystem.cxx:2538
 TUnixSystem.cxx:2539
 TUnixSystem.cxx:2540
 TUnixSystem.cxx:2541
 TUnixSystem.cxx:2542
 TUnixSystem.cxx:2543
 TUnixSystem.cxx:2544
 TUnixSystem.cxx:2545
 TUnixSystem.cxx:2546
 TUnixSystem.cxx:2547
 TUnixSystem.cxx:2548
 TUnixSystem.cxx:2549
 TUnixSystem.cxx:2550
 TUnixSystem.cxx:2551
 TUnixSystem.cxx:2552
 TUnixSystem.cxx:2553
 TUnixSystem.cxx:2554
 TUnixSystem.cxx:2555
 TUnixSystem.cxx:2556
 TUnixSystem.cxx:2557
 TUnixSystem.cxx:2558
 TUnixSystem.cxx:2559
 TUnixSystem.cxx:2560
 TUnixSystem.cxx:2561
 TUnixSystem.cxx:2562
 TUnixSystem.cxx:2563
 TUnixSystem.cxx:2564
 TUnixSystem.cxx:2565
 TUnixSystem.cxx:2566
 TUnixSystem.cxx:2567
 TUnixSystem.cxx:2568
 TUnixSystem.cxx:2569
 TUnixSystem.cxx:2570
 TUnixSystem.cxx:2571
 TUnixSystem.cxx:2572
 TUnixSystem.cxx:2573
 TUnixSystem.cxx:2574
 TUnixSystem.cxx:2575
 TUnixSystem.cxx:2576
 TUnixSystem.cxx:2577
 TUnixSystem.cxx:2578
 TUnixSystem.cxx:2579
 TUnixSystem.cxx:2580
 TUnixSystem.cxx:2581
 TUnixSystem.cxx:2582
 TUnixSystem.cxx:2583
 TUnixSystem.cxx:2584
 TUnixSystem.cxx:2585
 TUnixSystem.cxx:2586
 TUnixSystem.cxx:2587
 TUnixSystem.cxx:2588
 TUnixSystem.cxx:2589
 TUnixSystem.cxx:2590
 TUnixSystem.cxx:2591
 TUnixSystem.cxx:2592
 TUnixSystem.cxx:2593
 TUnixSystem.cxx:2594
 TUnixSystem.cxx:2595
 TUnixSystem.cxx:2596
 TUnixSystem.cxx:2597
 TUnixSystem.cxx:2598
 TUnixSystem.cxx:2599
 TUnixSystem.cxx:2600
 TUnixSystem.cxx:2601
 TUnixSystem.cxx:2602
 TUnixSystem.cxx:2603
 TUnixSystem.cxx:2604
 TUnixSystem.cxx:2605
 TUnixSystem.cxx:2606
 TUnixSystem.cxx:2607
 TUnixSystem.cxx:2608
 TUnixSystem.cxx:2609
 TUnixSystem.cxx:2610
 TUnixSystem.cxx:2611
 TUnixSystem.cxx:2612
 TUnixSystem.cxx:2613
 TUnixSystem.cxx:2614
 TUnixSystem.cxx:2615
 TUnixSystem.cxx:2616
 TUnixSystem.cxx:2617
 TUnixSystem.cxx:2618
 TUnixSystem.cxx:2619
 TUnixSystem.cxx:2620
 TUnixSystem.cxx:2621
 TUnixSystem.cxx:2622
 TUnixSystem.cxx:2623
 TUnixSystem.cxx:2624
 TUnixSystem.cxx:2625
 TUnixSystem.cxx:2626
 TUnixSystem.cxx:2627
 TUnixSystem.cxx:2628
 TUnixSystem.cxx:2629
 TUnixSystem.cxx:2630
 TUnixSystem.cxx:2631
 TUnixSystem.cxx:2632
 TUnixSystem.cxx:2633
 TUnixSystem.cxx:2634
 TUnixSystem.cxx:2635
 TUnixSystem.cxx:2636
 TUnixSystem.cxx:2637
 TUnixSystem.cxx:2638
 TUnixSystem.cxx:2639
 TUnixSystem.cxx:2640
 TUnixSystem.cxx:2641
 TUnixSystem.cxx:2642
 TUnixSystem.cxx:2643
 TUnixSystem.cxx:2644
 TUnixSystem.cxx:2645
 TUnixSystem.cxx:2646
 TUnixSystem.cxx:2647
 TUnixSystem.cxx:2648
 TUnixSystem.cxx:2649
 TUnixSystem.cxx:2650
 TUnixSystem.cxx:2651
 TUnixSystem.cxx:2652
 TUnixSystem.cxx:2653
 TUnixSystem.cxx:2654
 TUnixSystem.cxx:2655
 TUnixSystem.cxx:2656
 TUnixSystem.cxx:2657
 TUnixSystem.cxx:2658
 TUnixSystem.cxx:2659
 TUnixSystem.cxx:2660
 TUnixSystem.cxx:2661
 TUnixSystem.cxx:2662
 TUnixSystem.cxx:2663
 TUnixSystem.cxx:2664
 TUnixSystem.cxx:2665
 TUnixSystem.cxx:2666
 TUnixSystem.cxx:2667
 TUnixSystem.cxx:2668
 TUnixSystem.cxx:2669
 TUnixSystem.cxx:2670
 TUnixSystem.cxx:2671
 TUnixSystem.cxx:2672
 TUnixSystem.cxx:2673
 TUnixSystem.cxx:2674
 TUnixSystem.cxx:2675
 TUnixSystem.cxx:2676
 TUnixSystem.cxx:2677
 TUnixSystem.cxx:2678
 TUnixSystem.cxx:2679
 TUnixSystem.cxx:2680
 TUnixSystem.cxx:2681
 TUnixSystem.cxx:2682
 TUnixSystem.cxx:2683
 TUnixSystem.cxx:2684
 TUnixSystem.cxx:2685
 TUnixSystem.cxx:2686
 TUnixSystem.cxx:2687
 TUnixSystem.cxx:2688
 TUnixSystem.cxx:2689
 TUnixSystem.cxx:2690
 TUnixSystem.cxx:2691
 TUnixSystem.cxx:2692
 TUnixSystem.cxx:2693
 TUnixSystem.cxx:2694
 TUnixSystem.cxx:2695
 TUnixSystem.cxx:2696
 TUnixSystem.cxx:2697
 TUnixSystem.cxx:2698
 TUnixSystem.cxx:2699
 TUnixSystem.cxx:2700
 TUnixSystem.cxx:2701
 TUnixSystem.cxx:2702
 TUnixSystem.cxx:2703
 TUnixSystem.cxx:2704
 TUnixSystem.cxx:2705
 TUnixSystem.cxx:2706
 TUnixSystem.cxx:2707
 TUnixSystem.cxx:2708
 TUnixSystem.cxx:2709
 TUnixSystem.cxx:2710
 TUnixSystem.cxx:2711
 TUnixSystem.cxx:2712
 TUnixSystem.cxx:2713
 TUnixSystem.cxx:2714
 TUnixSystem.cxx:2715
 TUnixSystem.cxx:2716
 TUnixSystem.cxx:2717
 TUnixSystem.cxx:2718
 TUnixSystem.cxx:2719
 TUnixSystem.cxx:2720
 TUnixSystem.cxx:2721
 TUnixSystem.cxx:2722
 TUnixSystem.cxx:2723
 TUnixSystem.cxx:2724
 TUnixSystem.cxx:2725
 TUnixSystem.cxx:2726
 TUnixSystem.cxx:2727
 TUnixSystem.cxx:2728
 TUnixSystem.cxx:2729
 TUnixSystem.cxx:2730
 TUnixSystem.cxx:2731
 TUnixSystem.cxx:2732
 TUnixSystem.cxx:2733
 TUnixSystem.cxx:2734
 TUnixSystem.cxx:2735
 TUnixSystem.cxx:2736
 TUnixSystem.cxx:2737
 TUnixSystem.cxx:2738
 TUnixSystem.cxx:2739
 TUnixSystem.cxx:2740
 TUnixSystem.cxx:2741
 TUnixSystem.cxx:2742
 TUnixSystem.cxx:2743
 TUnixSystem.cxx:2744
 TUnixSystem.cxx:2745
 TUnixSystem.cxx:2746
 TUnixSystem.cxx:2747
 TUnixSystem.cxx:2748
 TUnixSystem.cxx:2749
 TUnixSystem.cxx:2750
 TUnixSystem.cxx:2751
 TUnixSystem.cxx:2752
 TUnixSystem.cxx:2753
 TUnixSystem.cxx:2754
 TUnixSystem.cxx:2755
 TUnixSystem.cxx:2756
 TUnixSystem.cxx:2757
 TUnixSystem.cxx:2758
 TUnixSystem.cxx:2759
 TUnixSystem.cxx:2760
 TUnixSystem.cxx:2761
 TUnixSystem.cxx:2762
 TUnixSystem.cxx:2763
 TUnixSystem.cxx:2764
 TUnixSystem.cxx:2765
 TUnixSystem.cxx:2766
 TUnixSystem.cxx:2767
 TUnixSystem.cxx:2768
 TUnixSystem.cxx:2769
 TUnixSystem.cxx:2770
 TUnixSystem.cxx:2771
 TUnixSystem.cxx:2772
 TUnixSystem.cxx:2773
 TUnixSystem.cxx:2774
 TUnixSystem.cxx:2775
 TUnixSystem.cxx:2776
 TUnixSystem.cxx:2777
 TUnixSystem.cxx:2778
 TUnixSystem.cxx:2779
 TUnixSystem.cxx:2780
 TUnixSystem.cxx:2781
 TUnixSystem.cxx:2782
 TUnixSystem.cxx:2783
 TUnixSystem.cxx:2784
 TUnixSystem.cxx:2785
 TUnixSystem.cxx:2786
 TUnixSystem.cxx:2787
 TUnixSystem.cxx:2788
 TUnixSystem.cxx:2789
 TUnixSystem.cxx:2790
 TUnixSystem.cxx:2791
 TUnixSystem.cxx:2792
 TUnixSystem.cxx:2793
 TUnixSystem.cxx:2794
 TUnixSystem.cxx:2795
 TUnixSystem.cxx:2796
 TUnixSystem.cxx:2797
 TUnixSystem.cxx:2798
 TUnixSystem.cxx:2799
 TUnixSystem.cxx:2800
 TUnixSystem.cxx:2801
 TUnixSystem.cxx:2802
 TUnixSystem.cxx:2803
 TUnixSystem.cxx:2804
 TUnixSystem.cxx:2805
 TUnixSystem.cxx:2806
 TUnixSystem.cxx:2807
 TUnixSystem.cxx:2808
 TUnixSystem.cxx:2809
 TUnixSystem.cxx:2810
 TUnixSystem.cxx:2811
 TUnixSystem.cxx:2812
 TUnixSystem.cxx:2813
 TUnixSystem.cxx:2814
 TUnixSystem.cxx:2815
 TUnixSystem.cxx:2816
 TUnixSystem.cxx:2817
 TUnixSystem.cxx:2818
 TUnixSystem.cxx:2819
 TUnixSystem.cxx:2820
 TUnixSystem.cxx:2821
 TUnixSystem.cxx:2822
 TUnixSystem.cxx:2823
 TUnixSystem.cxx:2824
 TUnixSystem.cxx:2825
 TUnixSystem.cxx:2826
 TUnixSystem.cxx:2827
 TUnixSystem.cxx:2828
 TUnixSystem.cxx:2829
 TUnixSystem.cxx:2830
 TUnixSystem.cxx:2831
 TUnixSystem.cxx:2832
 TUnixSystem.cxx:2833
 TUnixSystem.cxx:2834
 TUnixSystem.cxx:2835
 TUnixSystem.cxx:2836
 TUnixSystem.cxx:2837
 TUnixSystem.cxx:2838
 TUnixSystem.cxx:2839
 TUnixSystem.cxx:2840
 TUnixSystem.cxx:2841
 TUnixSystem.cxx:2842
 TUnixSystem.cxx:2843
 TUnixSystem.cxx:2844
 TUnixSystem.cxx:2845
 TUnixSystem.cxx:2846
 TUnixSystem.cxx:2847
 TUnixSystem.cxx:2848
 TUnixSystem.cxx:2849
 TUnixSystem.cxx:2850
 TUnixSystem.cxx:2851
 TUnixSystem.cxx:2852
 TUnixSystem.cxx:2853
 TUnixSystem.cxx:2854
 TUnixSystem.cxx:2855
 TUnixSystem.cxx:2856
 TUnixSystem.cxx:2857
 TUnixSystem.cxx:2858
 TUnixSystem.cxx:2859
 TUnixSystem.cxx:2860
 TUnixSystem.cxx:2861
 TUnixSystem.cxx:2862
 TUnixSystem.cxx:2863
 TUnixSystem.cxx:2864
 TUnixSystem.cxx:2865
 TUnixSystem.cxx:2866
 TUnixSystem.cxx:2867
 TUnixSystem.cxx:2868
 TUnixSystem.cxx:2869
 TUnixSystem.cxx:2870
 TUnixSystem.cxx:2871
 TUnixSystem.cxx:2872
 TUnixSystem.cxx:2873
 TUnixSystem.cxx:2874
 TUnixSystem.cxx:2875
 TUnixSystem.cxx:2876
 TUnixSystem.cxx:2877
 TUnixSystem.cxx:2878
 TUnixSystem.cxx:2879
 TUnixSystem.cxx:2880
 TUnixSystem.cxx:2881
 TUnixSystem.cxx:2882
 TUnixSystem.cxx:2883
 TUnixSystem.cxx:2884
 TUnixSystem.cxx:2885
 TUnixSystem.cxx:2886
 TUnixSystem.cxx:2887
 TUnixSystem.cxx:2888
 TUnixSystem.cxx:2889
 TUnixSystem.cxx:2890
 TUnixSystem.cxx:2891
 TUnixSystem.cxx:2892
 TUnixSystem.cxx:2893
 TUnixSystem.cxx:2894
 TUnixSystem.cxx:2895
 TUnixSystem.cxx:2896
 TUnixSystem.cxx:2897
 TUnixSystem.cxx:2898
 TUnixSystem.cxx:2899
 TUnixSystem.cxx:2900
 TUnixSystem.cxx:2901
 TUnixSystem.cxx:2902
 TUnixSystem.cxx:2903
 TUnixSystem.cxx:2904
 TUnixSystem.cxx:2905
 TUnixSystem.cxx:2906
 TUnixSystem.cxx:2907
 TUnixSystem.cxx:2908
 TUnixSystem.cxx:2909
 TUnixSystem.cxx:2910
 TUnixSystem.cxx:2911
 TUnixSystem.cxx:2912
 TUnixSystem.cxx:2913
 TUnixSystem.cxx:2914
 TUnixSystem.cxx:2915
 TUnixSystem.cxx:2916
 TUnixSystem.cxx:2917
 TUnixSystem.cxx:2918
 TUnixSystem.cxx:2919
 TUnixSystem.cxx:2920
 TUnixSystem.cxx:2921
 TUnixSystem.cxx:2922
 TUnixSystem.cxx:2923
 TUnixSystem.cxx:2924
 TUnixSystem.cxx:2925
 TUnixSystem.cxx:2926
 TUnixSystem.cxx:2927
 TUnixSystem.cxx:2928
 TUnixSystem.cxx:2929
 TUnixSystem.cxx:2930
 TUnixSystem.cxx:2931
 TUnixSystem.cxx:2932
 TUnixSystem.cxx:2933
 TUnixSystem.cxx:2934
 TUnixSystem.cxx:2935
 TUnixSystem.cxx:2936
 TUnixSystem.cxx:2937
 TUnixSystem.cxx:2938
 TUnixSystem.cxx:2939
 TUnixSystem.cxx:2940
 TUnixSystem.cxx:2941
 TUnixSystem.cxx:2942
 TUnixSystem.cxx:2943
 TUnixSystem.cxx:2944
 TUnixSystem.cxx:2945
 TUnixSystem.cxx:2946
 TUnixSystem.cxx:2947
 TUnixSystem.cxx:2948
 TUnixSystem.cxx:2949
 TUnixSystem.cxx:2950
 TUnixSystem.cxx:2951
 TUnixSystem.cxx:2952
 TUnixSystem.cxx:2953
 TUnixSystem.cxx:2954
 TUnixSystem.cxx:2955
 TUnixSystem.cxx:2956
 TUnixSystem.cxx:2957
 TUnixSystem.cxx:2958
 TUnixSystem.cxx:2959
 TUnixSystem.cxx:2960
 TUnixSystem.cxx:2961
 TUnixSystem.cxx:2962
 TUnixSystem.cxx:2963
 TUnixSystem.cxx:2964
 TUnixSystem.cxx:2965
 TUnixSystem.cxx:2966
 TUnixSystem.cxx:2967
 TUnixSystem.cxx:2968
 TUnixSystem.cxx:2969
 TUnixSystem.cxx:2970
 TUnixSystem.cxx:2971
 TUnixSystem.cxx:2972
 TUnixSystem.cxx:2973
 TUnixSystem.cxx:2974
 TUnixSystem.cxx:2975
 TUnixSystem.cxx:2976
 TUnixSystem.cxx:2977
 TUnixSystem.cxx:2978
 TUnixSystem.cxx:2979
 TUnixSystem.cxx:2980
 TUnixSystem.cxx:2981
 TUnixSystem.cxx:2982
 TUnixSystem.cxx:2983
 TUnixSystem.cxx:2984
 TUnixSystem.cxx:2985
 TUnixSystem.cxx:2986
 TUnixSystem.cxx:2987
 TUnixSystem.cxx:2988
 TUnixSystem.cxx:2989
 TUnixSystem.cxx:2990
 TUnixSystem.cxx:2991
 TUnixSystem.cxx:2992
 TUnixSystem.cxx:2993
 TUnixSystem.cxx:2994
 TUnixSystem.cxx:2995
 TUnixSystem.cxx:2996
 TUnixSystem.cxx:2997
 TUnixSystem.cxx:2998
 TUnixSystem.cxx:2999
 TUnixSystem.cxx:3000
 TUnixSystem.cxx:3001
 TUnixSystem.cxx:3002
 TUnixSystem.cxx:3003
 TUnixSystem.cxx:3004
 TUnixSystem.cxx:3005
 TUnixSystem.cxx:3006
 TUnixSystem.cxx:3007
 TUnixSystem.cxx:3008
 TUnixSystem.cxx:3009
 TUnixSystem.cxx:3010
 TUnixSystem.cxx:3011
 TUnixSystem.cxx:3012
 TUnixSystem.cxx:3013
 TUnixSystem.cxx:3014
 TUnixSystem.cxx:3015
 TUnixSystem.cxx:3016
 TUnixSystem.cxx:3017
 TUnixSystem.cxx:3018
 TUnixSystem.cxx:3019
 TUnixSystem.cxx:3020
 TUnixSystem.cxx:3021
 TUnixSystem.cxx:3022
 TUnixSystem.cxx:3023
 TUnixSystem.cxx:3024
 TUnixSystem.cxx:3025
 TUnixSystem.cxx:3026
 TUnixSystem.cxx:3027
 TUnixSystem.cxx:3028
 TUnixSystem.cxx:3029
 TUnixSystem.cxx:3030
 TUnixSystem.cxx:3031
 TUnixSystem.cxx:3032
 TUnixSystem.cxx:3033
 TUnixSystem.cxx:3034
 TUnixSystem.cxx:3035
 TUnixSystem.cxx:3036
 TUnixSystem.cxx:3037
 TUnixSystem.cxx:3038
 TUnixSystem.cxx:3039
 TUnixSystem.cxx:3040
 TUnixSystem.cxx:3041
 TUnixSystem.cxx:3042
 TUnixSystem.cxx:3043
 TUnixSystem.cxx:3044
 TUnixSystem.cxx:3045
 TUnixSystem.cxx:3046
 TUnixSystem.cxx:3047
 TUnixSystem.cxx:3048
 TUnixSystem.cxx:3049
 TUnixSystem.cxx:3050
 TUnixSystem.cxx:3051
 TUnixSystem.cxx:3052
 TUnixSystem.cxx:3053
 TUnixSystem.cxx:3054
 TUnixSystem.cxx:3055
 TUnixSystem.cxx:3056
 TUnixSystem.cxx:3057
 TUnixSystem.cxx:3058
 TUnixSystem.cxx:3059
 TUnixSystem.cxx:3060
 TUnixSystem.cxx:3061
 TUnixSystem.cxx:3062
 TUnixSystem.cxx:3063
 TUnixSystem.cxx:3064
 TUnixSystem.cxx:3065
 TUnixSystem.cxx:3066
 TUnixSystem.cxx:3067
 TUnixSystem.cxx:3068
 TUnixSystem.cxx:3069
 TUnixSystem.cxx:3070
 TUnixSystem.cxx:3071
 TUnixSystem.cxx:3072
 TUnixSystem.cxx:3073
 TUnixSystem.cxx:3074
 TUnixSystem.cxx:3075
 TUnixSystem.cxx:3076
 TUnixSystem.cxx:3077
 TUnixSystem.cxx:3078
 TUnixSystem.cxx:3079
 TUnixSystem.cxx:3080
 TUnixSystem.cxx:3081
 TUnixSystem.cxx:3082
 TUnixSystem.cxx:3083
 TUnixSystem.cxx:3084
 TUnixSystem.cxx:3085
 TUnixSystem.cxx:3086
 TUnixSystem.cxx:3087
 TUnixSystem.cxx:3088
 TUnixSystem.cxx:3089
 TUnixSystem.cxx:3090
 TUnixSystem.cxx:3091
 TUnixSystem.cxx:3092
 TUnixSystem.cxx:3093
 TUnixSystem.cxx:3094
 TUnixSystem.cxx:3095
 TUnixSystem.cxx:3096
 TUnixSystem.cxx:3097
 TUnixSystem.cxx:3098
 TUnixSystem.cxx:3099
 TUnixSystem.cxx:3100
 TUnixSystem.cxx:3101
 TUnixSystem.cxx:3102
 TUnixSystem.cxx:3103
 TUnixSystem.cxx:3104
 TUnixSystem.cxx:3105
 TUnixSystem.cxx:3106
 TUnixSystem.cxx:3107
 TUnixSystem.cxx:3108
 TUnixSystem.cxx:3109
 TUnixSystem.cxx:3110
 TUnixSystem.cxx:3111
 TUnixSystem.cxx:3112
 TUnixSystem.cxx:3113
 TUnixSystem.cxx:3114
 TUnixSystem.cxx:3115
 TUnixSystem.cxx:3116
 TUnixSystem.cxx:3117
 TUnixSystem.cxx:3118
 TUnixSystem.cxx:3119
 TUnixSystem.cxx:3120
 TUnixSystem.cxx:3121
 TUnixSystem.cxx:3122
 TUnixSystem.cxx:3123
 TUnixSystem.cxx:3124
 TUnixSystem.cxx:3125
 TUnixSystem.cxx:3126
 TUnixSystem.cxx:3127
 TUnixSystem.cxx:3128
 TUnixSystem.cxx:3129
 TUnixSystem.cxx:3130
 TUnixSystem.cxx:3131
 TUnixSystem.cxx:3132
 TUnixSystem.cxx:3133
 TUnixSystem.cxx:3134
 TUnixSystem.cxx:3135
 TUnixSystem.cxx:3136
 TUnixSystem.cxx:3137
 TUnixSystem.cxx:3138
 TUnixSystem.cxx:3139
 TUnixSystem.cxx:3140
 TUnixSystem.cxx:3141
 TUnixSystem.cxx:3142
 TUnixSystem.cxx:3143
 TUnixSystem.cxx:3144
 TUnixSystem.cxx:3145
 TUnixSystem.cxx:3146
 TUnixSystem.cxx:3147
 TUnixSystem.cxx:3148
 TUnixSystem.cxx:3149
 TUnixSystem.cxx:3150
 TUnixSystem.cxx:3151
 TUnixSystem.cxx:3152
 TUnixSystem.cxx:3153
 TUnixSystem.cxx:3154
 TUnixSystem.cxx:3155
 TUnixSystem.cxx:3156
 TUnixSystem.cxx:3157
 TUnixSystem.cxx:3158
 TUnixSystem.cxx:3159
 TUnixSystem.cxx:3160
 TUnixSystem.cxx:3161
 TUnixSystem.cxx:3162
 TUnixSystem.cxx:3163
 TUnixSystem.cxx:3164
 TUnixSystem.cxx:3165
 TUnixSystem.cxx:3166
 TUnixSystem.cxx:3167
 TUnixSystem.cxx:3168
 TUnixSystem.cxx:3169
 TUnixSystem.cxx:3170
 TUnixSystem.cxx:3171
 TUnixSystem.cxx:3172
 TUnixSystem.cxx:3173
 TUnixSystem.cxx:3174
 TUnixSystem.cxx:3175
 TUnixSystem.cxx:3176
 TUnixSystem.cxx:3177
 TUnixSystem.cxx:3178
 TUnixSystem.cxx:3179
 TUnixSystem.cxx:3180
 TUnixSystem.cxx:3181
 TUnixSystem.cxx:3182
 TUnixSystem.cxx:3183
 TUnixSystem.cxx:3184
 TUnixSystem.cxx:3185
 TUnixSystem.cxx:3186
 TUnixSystem.cxx:3187
 TUnixSystem.cxx:3188
 TUnixSystem.cxx:3189
 TUnixSystem.cxx:3190
 TUnixSystem.cxx:3191
 TUnixSystem.cxx:3192
 TUnixSystem.cxx:3193
 TUnixSystem.cxx:3194
 TUnixSystem.cxx:3195
 TUnixSystem.cxx:3196
 TUnixSystem.cxx:3197
 TUnixSystem.cxx:3198
 TUnixSystem.cxx:3199
 TUnixSystem.cxx:3200
 TUnixSystem.cxx:3201
 TUnixSystem.cxx:3202
 TUnixSystem.cxx:3203
 TUnixSystem.cxx:3204
 TUnixSystem.cxx:3205
 TUnixSystem.cxx:3206
 TUnixSystem.cxx:3207
 TUnixSystem.cxx:3208
 TUnixSystem.cxx:3209
 TUnixSystem.cxx:3210
 TUnixSystem.cxx:3211
 TUnixSystem.cxx:3212
 TUnixSystem.cxx:3213
 TUnixSystem.cxx:3214
 TUnixSystem.cxx:3215
 TUnixSystem.cxx:3216
 TUnixSystem.cxx:3217
 TUnixSystem.cxx:3218
 TUnixSystem.cxx:3219
 TUnixSystem.cxx:3220
 TUnixSystem.cxx:3221
 TUnixSystem.cxx:3222
 TUnixSystem.cxx:3223
 TUnixSystem.cxx:3224
 TUnixSystem.cxx:3225
 TUnixSystem.cxx:3226
 TUnixSystem.cxx:3227
 TUnixSystem.cxx:3228
 TUnixSystem.cxx:3229
 TUnixSystem.cxx:3230
 TUnixSystem.cxx:3231
 TUnixSystem.cxx:3232
 TUnixSystem.cxx:3233
 TUnixSystem.cxx:3234
 TUnixSystem.cxx:3235
 TUnixSystem.cxx:3236
 TUnixSystem.cxx:3237
 TUnixSystem.cxx:3238
 TUnixSystem.cxx:3239
 TUnixSystem.cxx:3240
 TUnixSystem.cxx:3241
 TUnixSystem.cxx:3242
 TUnixSystem.cxx:3243
 TUnixSystem.cxx:3244
 TUnixSystem.cxx:3245
 TUnixSystem.cxx:3246
 TUnixSystem.cxx:3247
 TUnixSystem.cxx:3248
 TUnixSystem.cxx:3249
 TUnixSystem.cxx:3250
 TUnixSystem.cxx:3251
 TUnixSystem.cxx:3252
 TUnixSystem.cxx:3253
 TUnixSystem.cxx:3254
 TUnixSystem.cxx:3255
 TUnixSystem.cxx:3256
 TUnixSystem.cxx:3257
 TUnixSystem.cxx:3258
 TUnixSystem.cxx:3259
 TUnixSystem.cxx:3260
 TUnixSystem.cxx:3261
 TUnixSystem.cxx:3262
 TUnixSystem.cxx:3263
 TUnixSystem.cxx:3264
 TUnixSystem.cxx:3265
 TUnixSystem.cxx:3266
 TUnixSystem.cxx:3267
 TUnixSystem.cxx:3268
 TUnixSystem.cxx:3269
 TUnixSystem.cxx:3270
 TUnixSystem.cxx:3271
 TUnixSystem.cxx:3272
 TUnixSystem.cxx:3273
 TUnixSystem.cxx:3274
 TUnixSystem.cxx:3275
 TUnixSystem.cxx:3276
 TUnixSystem.cxx:3277
 TUnixSystem.cxx:3278
 TUnixSystem.cxx:3279
 TUnixSystem.cxx:3280
 TUnixSystem.cxx:3281
 TUnixSystem.cxx:3282
 TUnixSystem.cxx:3283
 TUnixSystem.cxx:3284
 TUnixSystem.cxx:3285
 TUnixSystem.cxx:3286
 TUnixSystem.cxx:3287
 TUnixSystem.cxx:3288
 TUnixSystem.cxx:3289
 TUnixSystem.cxx:3290
 TUnixSystem.cxx:3291
 TUnixSystem.cxx:3292
 TUnixSystem.cxx:3293
 TUnixSystem.cxx:3294
 TUnixSystem.cxx:3295
 TUnixSystem.cxx:3296
 TUnixSystem.cxx:3297
 TUnixSystem.cxx:3298
 TUnixSystem.cxx:3299
 TUnixSystem.cxx:3300
 TUnixSystem.cxx:3301
 TUnixSystem.cxx:3302
 TUnixSystem.cxx:3303
 TUnixSystem.cxx:3304
 TUnixSystem.cxx:3305
 TUnixSystem.cxx:3306
 TUnixSystem.cxx:3307
 TUnixSystem.cxx:3308
 TUnixSystem.cxx:3309
 TUnixSystem.cxx:3310
 TUnixSystem.cxx:3311
 TUnixSystem.cxx:3312
 TUnixSystem.cxx:3313
 TUnixSystem.cxx:3314
 TUnixSystem.cxx:3315
 TUnixSystem.cxx:3316
 TUnixSystem.cxx:3317
 TUnixSystem.cxx:3318
 TUnixSystem.cxx:3319
 TUnixSystem.cxx:3320
 TUnixSystem.cxx:3321
 TUnixSystem.cxx:3322
 TUnixSystem.cxx:3323
 TUnixSystem.cxx:3324
 TUnixSystem.cxx:3325
 TUnixSystem.cxx:3326
 TUnixSystem.cxx:3327
 TUnixSystem.cxx:3328
 TUnixSystem.cxx:3329
 TUnixSystem.cxx:3330
 TUnixSystem.cxx:3331
 TUnixSystem.cxx:3332
 TUnixSystem.cxx:3333
 TUnixSystem.cxx:3334
 TUnixSystem.cxx:3335
 TUnixSystem.cxx:3336
 TUnixSystem.cxx:3337
 TUnixSystem.cxx:3338
 TUnixSystem.cxx:3339
 TUnixSystem.cxx:3340
 TUnixSystem.cxx:3341
 TUnixSystem.cxx:3342
 TUnixSystem.cxx:3343
 TUnixSystem.cxx:3344
 TUnixSystem.cxx:3345
 TUnixSystem.cxx:3346
 TUnixSystem.cxx:3347
 TUnixSystem.cxx:3348
 TUnixSystem.cxx:3349
 TUnixSystem.cxx:3350
 TUnixSystem.cxx:3351
 TUnixSystem.cxx:3352
 TUnixSystem.cxx:3353
 TUnixSystem.cxx:3354
 TUnixSystem.cxx:3355
 TUnixSystem.cxx:3356
 TUnixSystem.cxx:3357
 TUnixSystem.cxx:3358
 TUnixSystem.cxx:3359
 TUnixSystem.cxx:3360
 TUnixSystem.cxx:3361
 TUnixSystem.cxx:3362
 TUnixSystem.cxx:3363
 TUnixSystem.cxx:3364
 TUnixSystem.cxx:3365
 TUnixSystem.cxx:3366
 TUnixSystem.cxx:3367
 TUnixSystem.cxx:3368
 TUnixSystem.cxx:3369
 TUnixSystem.cxx:3370
 TUnixSystem.cxx:3371
 TUnixSystem.cxx:3372
 TUnixSystem.cxx:3373
 TUnixSystem.cxx:3374
 TUnixSystem.cxx:3375
 TUnixSystem.cxx:3376
 TUnixSystem.cxx:3377
 TUnixSystem.cxx:3378
 TUnixSystem.cxx:3379
 TUnixSystem.cxx:3380
 TUnixSystem.cxx:3381
 TUnixSystem.cxx:3382
 TUnixSystem.cxx:3383
 TUnixSystem.cxx:3384
 TUnixSystem.cxx:3385
 TUnixSystem.cxx:3386
 TUnixSystem.cxx:3387
 TUnixSystem.cxx:3388
 TUnixSystem.cxx:3389
 TUnixSystem.cxx:3390
 TUnixSystem.cxx:3391
 TUnixSystem.cxx:3392
 TUnixSystem.cxx:3393
 TUnixSystem.cxx:3394
 TUnixSystem.cxx:3395
 TUnixSystem.cxx:3396
 TUnixSystem.cxx:3397
 TUnixSystem.cxx:3398
 TUnixSystem.cxx:3399
 TUnixSystem.cxx:3400
 TUnixSystem.cxx:3401
 TUnixSystem.cxx:3402
 TUnixSystem.cxx:3403
 TUnixSystem.cxx:3404
 TUnixSystem.cxx:3405
 TUnixSystem.cxx:3406
 TUnixSystem.cxx:3407
 TUnixSystem.cxx:3408
 TUnixSystem.cxx:3409
 TUnixSystem.cxx:3410
 TUnixSystem.cxx:3411
 TUnixSystem.cxx:3412
 TUnixSystem.cxx:3413
 TUnixSystem.cxx:3414
 TUnixSystem.cxx:3415
 TUnixSystem.cxx:3416
 TUnixSystem.cxx:3417
 TUnixSystem.cxx:3418
 TUnixSystem.cxx:3419
 TUnixSystem.cxx:3420
 TUnixSystem.cxx:3421
 TUnixSystem.cxx:3422
 TUnixSystem.cxx:3423
 TUnixSystem.cxx:3424
 TUnixSystem.cxx:3425
 TUnixSystem.cxx:3426
 TUnixSystem.cxx:3427
 TUnixSystem.cxx:3428
 TUnixSystem.cxx:3429
 TUnixSystem.cxx:3430
 TUnixSystem.cxx:3431
 TUnixSystem.cxx:3432
 TUnixSystem.cxx:3433
 TUnixSystem.cxx:3434
 TUnixSystem.cxx:3435
 TUnixSystem.cxx:3436
 TUnixSystem.cxx:3437
 TUnixSystem.cxx:3438
 TUnixSystem.cxx:3439
 TUnixSystem.cxx:3440
 TUnixSystem.cxx:3441
 TUnixSystem.cxx:3442
 TUnixSystem.cxx:3443
 TUnixSystem.cxx:3444
 TUnixSystem.cxx:3445
 TUnixSystem.cxx:3446
 TUnixSystem.cxx:3447
 TUnixSystem.cxx:3448
 TUnixSystem.cxx:3449
 TUnixSystem.cxx:3450
 TUnixSystem.cxx:3451
 TUnixSystem.cxx:3452
 TUnixSystem.cxx:3453
 TUnixSystem.cxx:3454
 TUnixSystem.cxx:3455
 TUnixSystem.cxx:3456
 TUnixSystem.cxx:3457
 TUnixSystem.cxx:3458
 TUnixSystem.cxx:3459
 TUnixSystem.cxx:3460
 TUnixSystem.cxx:3461
 TUnixSystem.cxx:3462
 TUnixSystem.cxx:3463
 TUnixSystem.cxx:3464
 TUnixSystem.cxx:3465
 TUnixSystem.cxx:3466
 TUnixSystem.cxx:3467
 TUnixSystem.cxx:3468
 TUnixSystem.cxx:3469
 TUnixSystem.cxx:3470
 TUnixSystem.cxx:3471
 TUnixSystem.cxx:3472
 TUnixSystem.cxx:3473
 TUnixSystem.cxx:3474
 TUnixSystem.cxx:3475
 TUnixSystem.cxx:3476
 TUnixSystem.cxx:3477
 TUnixSystem.cxx:3478
 TUnixSystem.cxx:3479
 TUnixSystem.cxx:3480
 TUnixSystem.cxx:3481
 TUnixSystem.cxx:3482
 TUnixSystem.cxx:3483
 TUnixSystem.cxx:3484
 TUnixSystem.cxx:3485
 TUnixSystem.cxx:3486
 TUnixSystem.cxx:3487
 TUnixSystem.cxx:3488
 TUnixSystem.cxx:3489
 TUnixSystem.cxx:3490
 TUnixSystem.cxx:3491
 TUnixSystem.cxx:3492
 TUnixSystem.cxx:3493
 TUnixSystem.cxx:3494
 TUnixSystem.cxx:3495
 TUnixSystem.cxx:3496
 TUnixSystem.cxx:3497
 TUnixSystem.cxx:3498
 TUnixSystem.cxx:3499
 TUnixSystem.cxx:3500
 TUnixSystem.cxx:3501
 TUnixSystem.cxx:3502
 TUnixSystem.cxx:3503
 TUnixSystem.cxx:3504
 TUnixSystem.cxx:3505
 TUnixSystem.cxx:3506
 TUnixSystem.cxx:3507
 TUnixSystem.cxx:3508
 TUnixSystem.cxx:3509
 TUnixSystem.cxx:3510
 TUnixSystem.cxx:3511
 TUnixSystem.cxx:3512
 TUnixSystem.cxx:3513
 TUnixSystem.cxx:3514
 TUnixSystem.cxx:3515
 TUnixSystem.cxx:3516
 TUnixSystem.cxx:3517
 TUnixSystem.cxx:3518
 TUnixSystem.cxx:3519
 TUnixSystem.cxx:3520
 TUnixSystem.cxx:3521
 TUnixSystem.cxx:3522
 TUnixSystem.cxx:3523
 TUnixSystem.cxx:3524
 TUnixSystem.cxx:3525
 TUnixSystem.cxx:3526
 TUnixSystem.cxx:3527
 TUnixSystem.cxx:3528
 TUnixSystem.cxx:3529
 TUnixSystem.cxx:3530
 TUnixSystem.cxx:3531
 TUnixSystem.cxx:3532
 TUnixSystem.cxx:3533
 TUnixSystem.cxx:3534
 TUnixSystem.cxx:3535
 TUnixSystem.cxx:3536
 TUnixSystem.cxx:3537
 TUnixSystem.cxx:3538
 TUnixSystem.cxx:3539
 TUnixSystem.cxx:3540
 TUnixSystem.cxx:3541
 TUnixSystem.cxx:3542
 TUnixSystem.cxx:3543
 TUnixSystem.cxx:3544
 TUnixSystem.cxx:3545
 TUnixSystem.cxx:3546
 TUnixSystem.cxx:3547
 TUnixSystem.cxx:3548
 TUnixSystem.cxx:3549
 TUnixSystem.cxx:3550
 TUnixSystem.cxx:3551
 TUnixSystem.cxx:3552
 TUnixSystem.cxx:3553
 TUnixSystem.cxx:3554
 TUnixSystem.cxx:3555
 TUnixSystem.cxx:3556
 TUnixSystem.cxx:3557
 TUnixSystem.cxx:3558
 TUnixSystem.cxx:3559
 TUnixSystem.cxx:3560
 TUnixSystem.cxx:3561
 TUnixSystem.cxx:3562
 TUnixSystem.cxx:3563
 TUnixSystem.cxx:3564
 TUnixSystem.cxx:3565
 TUnixSystem.cxx:3566
 TUnixSystem.cxx:3567
 TUnixSystem.cxx:3568
 TUnixSystem.cxx:3569
 TUnixSystem.cxx:3570
 TUnixSystem.cxx:3571
 TUnixSystem.cxx:3572
 TUnixSystem.cxx:3573
 TUnixSystem.cxx:3574
 TUnixSystem.cxx:3575
 TUnixSystem.cxx:3576
 TUnixSystem.cxx:3577
 TUnixSystem.cxx:3578
 TUnixSystem.cxx:3579
 TUnixSystem.cxx:3580
 TUnixSystem.cxx:3581
 TUnixSystem.cxx:3582
 TUnixSystem.cxx:3583
 TUnixSystem.cxx:3584
 TUnixSystem.cxx:3585
 TUnixSystem.cxx:3586
 TUnixSystem.cxx:3587
 TUnixSystem.cxx:3588
 TUnixSystem.cxx:3589
 TUnixSystem.cxx:3590
 TUnixSystem.cxx:3591
 TUnixSystem.cxx:3592
 TUnixSystem.cxx:3593
 TUnixSystem.cxx:3594
 TUnixSystem.cxx:3595
 TUnixSystem.cxx:3596
 TUnixSystem.cxx:3597
 TUnixSystem.cxx:3598
 TUnixSystem.cxx:3599
 TUnixSystem.cxx:3600
 TUnixSystem.cxx:3601
 TUnixSystem.cxx:3602
 TUnixSystem.cxx:3603
 TUnixSystem.cxx:3604
 TUnixSystem.cxx:3605
 TUnixSystem.cxx:3606
 TUnixSystem.cxx:3607
 TUnixSystem.cxx:3608
 TUnixSystem.cxx:3609
 TUnixSystem.cxx:3610
 TUnixSystem.cxx:3611
 TUnixSystem.cxx:3612
 TUnixSystem.cxx:3613
 TUnixSystem.cxx:3614
 TUnixSystem.cxx:3615
 TUnixSystem.cxx:3616
 TUnixSystem.cxx:3617
 TUnixSystem.cxx:3618
 TUnixSystem.cxx:3619
 TUnixSystem.cxx:3620
 TUnixSystem.cxx:3621
 TUnixSystem.cxx:3622
 TUnixSystem.cxx:3623
 TUnixSystem.cxx:3624
 TUnixSystem.cxx:3625
 TUnixSystem.cxx:3626
 TUnixSystem.cxx:3627
 TUnixSystem.cxx:3628
 TUnixSystem.cxx:3629
 TUnixSystem.cxx:3630
 TUnixSystem.cxx:3631
 TUnixSystem.cxx:3632
 TUnixSystem.cxx:3633
 TUnixSystem.cxx:3634
 TUnixSystem.cxx:3635
 TUnixSystem.cxx:3636
 TUnixSystem.cxx:3637
 TUnixSystem.cxx:3638
 TUnixSystem.cxx:3639
 TUnixSystem.cxx:3640
 TUnixSystem.cxx:3641
 TUnixSystem.cxx:3642
 TUnixSystem.cxx:3643
 TUnixSystem.cxx:3644
 TUnixSystem.cxx:3645
 TUnixSystem.cxx:3646
 TUnixSystem.cxx:3647
 TUnixSystem.cxx:3648
 TUnixSystem.cxx:3649
 TUnixSystem.cxx:3650
 TUnixSystem.cxx:3651
 TUnixSystem.cxx:3652
 TUnixSystem.cxx:3653
 TUnixSystem.cxx:3654
 TUnixSystem.cxx:3655
 TUnixSystem.cxx:3656
 TUnixSystem.cxx:3657
 TUnixSystem.cxx:3658
 TUnixSystem.cxx:3659
 TUnixSystem.cxx:3660
 TUnixSystem.cxx:3661
 TUnixSystem.cxx:3662
 TUnixSystem.cxx:3663
 TUnixSystem.cxx:3664
 TUnixSystem.cxx:3665
 TUnixSystem.cxx:3666
 TUnixSystem.cxx:3667
 TUnixSystem.cxx:3668
 TUnixSystem.cxx:3669
 TUnixSystem.cxx:3670
 TUnixSystem.cxx:3671
 TUnixSystem.cxx:3672
 TUnixSystem.cxx:3673
 TUnixSystem.cxx:3674
 TUnixSystem.cxx:3675
 TUnixSystem.cxx:3676
 TUnixSystem.cxx:3677
 TUnixSystem.cxx:3678
 TUnixSystem.cxx:3679
 TUnixSystem.cxx:3680
 TUnixSystem.cxx:3681
 TUnixSystem.cxx:3682
 TUnixSystem.cxx:3683
 TUnixSystem.cxx:3684
 TUnixSystem.cxx:3685
 TUnixSystem.cxx:3686
 TUnixSystem.cxx:3687
 TUnixSystem.cxx:3688
 TUnixSystem.cxx:3689
 TUnixSystem.cxx:3690
 TUnixSystem.cxx:3691
 TUnixSystem.cxx:3692
 TUnixSystem.cxx:3693
 TUnixSystem.cxx:3694
 TUnixSystem.cxx:3695
 TUnixSystem.cxx:3696
 TUnixSystem.cxx:3697
 TUnixSystem.cxx:3698
 TUnixSystem.cxx:3699
 TUnixSystem.cxx:3700
 TUnixSystem.cxx:3701
 TUnixSystem.cxx:3702
 TUnixSystem.cxx:3703
 TUnixSystem.cxx:3704
 TUnixSystem.cxx:3705
 TUnixSystem.cxx:3706
 TUnixSystem.cxx:3707
 TUnixSystem.cxx:3708
 TUnixSystem.cxx:3709
 TUnixSystem.cxx:3710
 TUnixSystem.cxx:3711
 TUnixSystem.cxx:3712
 TUnixSystem.cxx:3713
 TUnixSystem.cxx:3714
 TUnixSystem.cxx:3715
 TUnixSystem.cxx:3716
 TUnixSystem.cxx:3717
 TUnixSystem.cxx:3718
 TUnixSystem.cxx:3719
 TUnixSystem.cxx:3720
 TUnixSystem.cxx:3721
 TUnixSystem.cxx:3722
 TUnixSystem.cxx:3723
 TUnixSystem.cxx:3724
 TUnixSystem.cxx:3725
 TUnixSystem.cxx:3726
 TUnixSystem.cxx:3727
 TUnixSystem.cxx:3728
 TUnixSystem.cxx:3729
 TUnixSystem.cxx:3730
 TUnixSystem.cxx:3731
 TUnixSystem.cxx:3732
 TUnixSystem.cxx:3733
 TUnixSystem.cxx:3734
 TUnixSystem.cxx:3735
 TUnixSystem.cxx:3736
 TUnixSystem.cxx:3737
 TUnixSystem.cxx:3738
 TUnixSystem.cxx:3739
 TUnixSystem.cxx:3740
 TUnixSystem.cxx:3741
 TUnixSystem.cxx:3742
 TUnixSystem.cxx:3743
 TUnixSystem.cxx:3744
 TUnixSystem.cxx:3745
 TUnixSystem.cxx:3746
 TUnixSystem.cxx:3747
 TUnixSystem.cxx:3748
 TUnixSystem.cxx:3749
 TUnixSystem.cxx:3750
 TUnixSystem.cxx:3751
 TUnixSystem.cxx:3752
 TUnixSystem.cxx:3753
 TUnixSystem.cxx:3754
 TUnixSystem.cxx:3755
 TUnixSystem.cxx:3756
 TUnixSystem.cxx:3757
 TUnixSystem.cxx:3758
 TUnixSystem.cxx:3759
 TUnixSystem.cxx:3760
 TUnixSystem.cxx:3761
 TUnixSystem.cxx:3762
 TUnixSystem.cxx:3763
 TUnixSystem.cxx:3764
 TUnixSystem.cxx:3765
 TUnixSystem.cxx:3766
 TUnixSystem.cxx:3767
 TUnixSystem.cxx:3768
 TUnixSystem.cxx:3769
 TUnixSystem.cxx:3770
 TUnixSystem.cxx:3771
 TUnixSystem.cxx:3772
 TUnixSystem.cxx:3773
 TUnixSystem.cxx:3774
 TUnixSystem.cxx:3775
 TUnixSystem.cxx:3776
 TUnixSystem.cxx:3777
 TUnixSystem.cxx:3778
 TUnixSystem.cxx:3779
 TUnixSystem.cxx:3780
 TUnixSystem.cxx:3781
 TUnixSystem.cxx:3782
 TUnixSystem.cxx:3783
 TUnixSystem.cxx:3784
 TUnixSystem.cxx:3785
 TUnixSystem.cxx:3786
 TUnixSystem.cxx:3787
 TUnixSystem.cxx:3788
 TUnixSystem.cxx:3789
 TUnixSystem.cxx:3790
 TUnixSystem.cxx:3791
 TUnixSystem.cxx:3792
 TUnixSystem.cxx:3793
 TUnixSystem.cxx:3794
 TUnixSystem.cxx:3795
 TUnixSystem.cxx:3796
 TUnixSystem.cxx:3797
 TUnixSystem.cxx:3798
 TUnixSystem.cxx:3799
 TUnixSystem.cxx:3800
 TUnixSystem.cxx:3801
 TUnixSystem.cxx:3802
 TUnixSystem.cxx:3803
 TUnixSystem.cxx:3804
 TUnixSystem.cxx:3805
 TUnixSystem.cxx:3806
 TUnixSystem.cxx:3807
 TUnixSystem.cxx:3808
 TUnixSystem.cxx:3809
 TUnixSystem.cxx:3810
 TUnixSystem.cxx:3811
 TUnixSystem.cxx:3812
 TUnixSystem.cxx:3813
 TUnixSystem.cxx:3814
 TUnixSystem.cxx:3815
 TUnixSystem.cxx:3816
 TUnixSystem.cxx:3817
 TUnixSystem.cxx:3818
 TUnixSystem.cxx:3819
 TUnixSystem.cxx:3820
 TUnixSystem.cxx:3821
 TUnixSystem.cxx:3822
 TUnixSystem.cxx:3823
 TUnixSystem.cxx:3824
 TUnixSystem.cxx:3825
 TUnixSystem.cxx:3826
 TUnixSystem.cxx:3827
 TUnixSystem.cxx:3828
 TUnixSystem.cxx:3829
 TUnixSystem.cxx:3830
 TUnixSystem.cxx:3831
 TUnixSystem.cxx:3832
 TUnixSystem.cxx:3833
 TUnixSystem.cxx:3834
 TUnixSystem.cxx:3835
 TUnixSystem.cxx:3836
 TUnixSystem.cxx:3837
 TUnixSystem.cxx:3838
 TUnixSystem.cxx:3839
 TUnixSystem.cxx:3840
 TUnixSystem.cxx:3841
 TUnixSystem.cxx:3842
 TUnixSystem.cxx:3843
 TUnixSystem.cxx:3844
 TUnixSystem.cxx:3845
 TUnixSystem.cxx:3846
 TUnixSystem.cxx:3847
 TUnixSystem.cxx:3848
 TUnixSystem.cxx:3849
 TUnixSystem.cxx:3850
 TUnixSystem.cxx:3851
 TUnixSystem.cxx:3852
 TUnixSystem.cxx:3853
 TUnixSystem.cxx:3854
 TUnixSystem.cxx:3855
 TUnixSystem.cxx:3856
 TUnixSystem.cxx:3857
 TUnixSystem.cxx:3858
 TUnixSystem.cxx:3859
 TUnixSystem.cxx:3860
 TUnixSystem.cxx:3861
 TUnixSystem.cxx:3862
 TUnixSystem.cxx:3863
 TUnixSystem.cxx:3864
 TUnixSystem.cxx:3865
 TUnixSystem.cxx:3866
 TUnixSystem.cxx:3867
 TUnixSystem.cxx:3868
 TUnixSystem.cxx:3869
 TUnixSystem.cxx:3870
 TUnixSystem.cxx:3871
 TUnixSystem.cxx:3872
 TUnixSystem.cxx:3873
 TUnixSystem.cxx:3874
 TUnixSystem.cxx:3875
 TUnixSystem.cxx:3876
 TUnixSystem.cxx:3877
 TUnixSystem.cxx:3878
 TUnixSystem.cxx:3879
 TUnixSystem.cxx:3880
 TUnixSystem.cxx:3881
 TUnixSystem.cxx:3882
 TUnixSystem.cxx:3883
 TUnixSystem.cxx:3884
 TUnixSystem.cxx:3885
 TUnixSystem.cxx:3886
 TUnixSystem.cxx:3887
 TUnixSystem.cxx:3888
 TUnixSystem.cxx:3889
 TUnixSystem.cxx:3890
 TUnixSystem.cxx:3891
 TUnixSystem.cxx:3892
 TUnixSystem.cxx:3893
 TUnixSystem.cxx:3894
 TUnixSystem.cxx:3895
 TUnixSystem.cxx:3896
 TUnixSystem.cxx:3897
 TUnixSystem.cxx:3898
 TUnixSystem.cxx:3899
 TUnixSystem.cxx:3900
 TUnixSystem.cxx:3901
 TUnixSystem.cxx:3902
 TUnixSystem.cxx:3903
 TUnixSystem.cxx:3904
 TUnixSystem.cxx:3905
 TUnixSystem.cxx:3906
 TUnixSystem.cxx:3907
 TUnixSystem.cxx:3908
 TUnixSystem.cxx:3909
 TUnixSystem.cxx:3910
 TUnixSystem.cxx:3911
 TUnixSystem.cxx:3912
 TUnixSystem.cxx:3913
 TUnixSystem.cxx:3914
 TUnixSystem.cxx:3915
 TUnixSystem.cxx:3916
 TUnixSystem.cxx:3917
 TUnixSystem.cxx:3918
 TUnixSystem.cxx:3919
 TUnixSystem.cxx:3920
 TUnixSystem.cxx:3921
 TUnixSystem.cxx:3922
 TUnixSystem.cxx:3923
 TUnixSystem.cxx:3924
 TUnixSystem.cxx:3925
 TUnixSystem.cxx:3926
 TUnixSystem.cxx:3927
 TUnixSystem.cxx:3928
 TUnixSystem.cxx:3929
 TUnixSystem.cxx:3930
 TUnixSystem.cxx:3931
 TUnixSystem.cxx:3932
 TUnixSystem.cxx:3933
 TUnixSystem.cxx:3934
 TUnixSystem.cxx:3935
 TUnixSystem.cxx:3936
 TUnixSystem.cxx:3937
 TUnixSystem.cxx:3938
 TUnixSystem.cxx:3939
 TUnixSystem.cxx:3940
 TUnixSystem.cxx:3941
 TUnixSystem.cxx:3942
 TUnixSystem.cxx:3943
 TUnixSystem.cxx:3944
 TUnixSystem.cxx:3945
 TUnixSystem.cxx:3946
 TUnixSystem.cxx:3947
 TUnixSystem.cxx:3948
 TUnixSystem.cxx:3949
 TUnixSystem.cxx:3950
 TUnixSystem.cxx:3951
 TUnixSystem.cxx:3952
 TUnixSystem.cxx:3953
 TUnixSystem.cxx:3954
 TUnixSystem.cxx:3955
 TUnixSystem.cxx:3956
 TUnixSystem.cxx:3957
 TUnixSystem.cxx:3958
 TUnixSystem.cxx:3959
 TUnixSystem.cxx:3960
 TUnixSystem.cxx:3961
 TUnixSystem.cxx:3962
 TUnixSystem.cxx:3963
 TUnixSystem.cxx:3964
 TUnixSystem.cxx:3965
 TUnixSystem.cxx:3966
 TUnixSystem.cxx:3967
 TUnixSystem.cxx:3968
 TUnixSystem.cxx:3969
 TUnixSystem.cxx:3970
 TUnixSystem.cxx:3971
 TUnixSystem.cxx:3972
 TUnixSystem.cxx:3973
 TUnixSystem.cxx:3974
 TUnixSystem.cxx:3975
 TUnixSystem.cxx:3976
 TUnixSystem.cxx:3977
 TUnixSystem.cxx:3978
 TUnixSystem.cxx:3979
 TUnixSystem.cxx:3980
 TUnixSystem.cxx:3981
 TUnixSystem.cxx:3982
 TUnixSystem.cxx:3983
 TUnixSystem.cxx:3984
 TUnixSystem.cxx:3985
 TUnixSystem.cxx:3986
 TUnixSystem.cxx:3987
 TUnixSystem.cxx:3988
 TUnixSystem.cxx:3989
 TUnixSystem.cxx:3990
 TUnixSystem.cxx:3991
 TUnixSystem.cxx:3992
 TUnixSystem.cxx:3993
 TUnixSystem.cxx:3994
 TUnixSystem.cxx:3995
 TUnixSystem.cxx:3996
 TUnixSystem.cxx:3997
 TUnixSystem.cxx:3998
 TUnixSystem.cxx:3999
 TUnixSystem.cxx:4000
 TUnixSystem.cxx:4001
 TUnixSystem.cxx:4002
 TUnixSystem.cxx:4003
 TUnixSystem.cxx:4004
 TUnixSystem.cxx:4005
 TUnixSystem.cxx:4006
 TUnixSystem.cxx:4007
 TUnixSystem.cxx:4008
 TUnixSystem.cxx:4009
 TUnixSystem.cxx:4010
 TUnixSystem.cxx:4011
 TUnixSystem.cxx:4012
 TUnixSystem.cxx:4013
 TUnixSystem.cxx:4014
 TUnixSystem.cxx:4015
 TUnixSystem.cxx:4016
 TUnixSystem.cxx:4017
 TUnixSystem.cxx:4018
 TUnixSystem.cxx:4019
 TUnixSystem.cxx:4020
 TUnixSystem.cxx:4021
 TUnixSystem.cxx:4022
 TUnixSystem.cxx:4023
 TUnixSystem.cxx:4024
 TUnixSystem.cxx:4025
 TUnixSystem.cxx:4026
 TUnixSystem.cxx:4027
 TUnixSystem.cxx:4028
 TUnixSystem.cxx:4029
 TUnixSystem.cxx:4030
 TUnixSystem.cxx:4031
 TUnixSystem.cxx:4032
 TUnixSystem.cxx:4033
 TUnixSystem.cxx:4034
 TUnixSystem.cxx:4035
 TUnixSystem.cxx:4036
 TUnixSystem.cxx:4037
 TUnixSystem.cxx:4038
 TUnixSystem.cxx:4039
 TUnixSystem.cxx:4040
 TUnixSystem.cxx:4041
 TUnixSystem.cxx:4042
 TUnixSystem.cxx:4043
 TUnixSystem.cxx:4044
 TUnixSystem.cxx:4045
 TUnixSystem.cxx:4046
 TUnixSystem.cxx:4047
 TUnixSystem.cxx:4048
 TUnixSystem.cxx:4049
 TUnixSystem.cxx:4050
 TUnixSystem.cxx:4051
 TUnixSystem.cxx:4052
 TUnixSystem.cxx:4053
 TUnixSystem.cxx:4054
 TUnixSystem.cxx:4055
 TUnixSystem.cxx:4056
 TUnixSystem.cxx:4057
 TUnixSystem.cxx:4058
 TUnixSystem.cxx:4059
 TUnixSystem.cxx:4060
 TUnixSystem.cxx:4061
 TUnixSystem.cxx:4062
 TUnixSystem.cxx:4063
 TUnixSystem.cxx:4064
 TUnixSystem.cxx:4065
 TUnixSystem.cxx:4066
 TUnixSystem.cxx:4067
 TUnixSystem.cxx:4068
 TUnixSystem.cxx:4069
 TUnixSystem.cxx:4070
 TUnixSystem.cxx:4071
 TUnixSystem.cxx:4072
 TUnixSystem.cxx:4073
 TUnixSystem.cxx:4074
 TUnixSystem.cxx:4075
 TUnixSystem.cxx:4076
 TUnixSystem.cxx:4077
 TUnixSystem.cxx:4078
 TUnixSystem.cxx:4079
 TUnixSystem.cxx:4080
 TUnixSystem.cxx:4081
 TUnixSystem.cxx:4082
 TUnixSystem.cxx:4083
 TUnixSystem.cxx:4084
 TUnixSystem.cxx:4085
 TUnixSystem.cxx:4086
 TUnixSystem.cxx:4087
 TUnixSystem.cxx:4088
 TUnixSystem.cxx:4089
 TUnixSystem.cxx:4090
 TUnixSystem.cxx:4091
 TUnixSystem.cxx:4092
 TUnixSystem.cxx:4093
 TUnixSystem.cxx:4094
 TUnixSystem.cxx:4095
 TUnixSystem.cxx:4096
 TUnixSystem.cxx:4097
 TUnixSystem.cxx:4098
 TUnixSystem.cxx:4099
 TUnixSystem.cxx:4100
 TUnixSystem.cxx:4101
 TUnixSystem.cxx:4102
 TUnixSystem.cxx:4103
 TUnixSystem.cxx:4104
 TUnixSystem.cxx:4105
 TUnixSystem.cxx:4106
 TUnixSystem.cxx:4107
 TUnixSystem.cxx:4108
 TUnixSystem.cxx:4109
 TUnixSystem.cxx:4110
 TUnixSystem.cxx:4111
 TUnixSystem.cxx:4112
 TUnixSystem.cxx:4113
 TUnixSystem.cxx:4114
 TUnixSystem.cxx:4115
 TUnixSystem.cxx:4116
 TUnixSystem.cxx:4117
 TUnixSystem.cxx:4118
 TUnixSystem.cxx:4119
 TUnixSystem.cxx:4120
 TUnixSystem.cxx:4121
 TUnixSystem.cxx:4122
 TUnixSystem.cxx:4123
 TUnixSystem.cxx:4124
 TUnixSystem.cxx:4125
 TUnixSystem.cxx:4126
 TUnixSystem.cxx:4127
 TUnixSystem.cxx:4128
 TUnixSystem.cxx:4129
 TUnixSystem.cxx:4130
 TUnixSystem.cxx:4131
 TUnixSystem.cxx:4132
 TUnixSystem.cxx:4133
 TUnixSystem.cxx:4134
 TUnixSystem.cxx:4135
 TUnixSystem.cxx:4136
 TUnixSystem.cxx:4137
 TUnixSystem.cxx:4138
 TUnixSystem.cxx:4139
 TUnixSystem.cxx:4140
 TUnixSystem.cxx:4141
 TUnixSystem.cxx:4142
 TUnixSystem.cxx:4143
 TUnixSystem.cxx:4144
 TUnixSystem.cxx:4145
 TUnixSystem.cxx:4146
 TUnixSystem.cxx:4147
 TUnixSystem.cxx:4148
 TUnixSystem.cxx:4149
 TUnixSystem.cxx:4150
 TUnixSystem.cxx:4151
 TUnixSystem.cxx:4152
 TUnixSystem.cxx:4153
 TUnixSystem.cxx:4154
 TUnixSystem.cxx:4155
 TUnixSystem.cxx:4156
 TUnixSystem.cxx:4157
 TUnixSystem.cxx:4158
 TUnixSystem.cxx:4159
 TUnixSystem.cxx:4160
 TUnixSystem.cxx:4161
 TUnixSystem.cxx:4162
 TUnixSystem.cxx:4163
 TUnixSystem.cxx:4164
 TUnixSystem.cxx:4165
 TUnixSystem.cxx:4166
 TUnixSystem.cxx:4167
 TUnixSystem.cxx:4168
 TUnixSystem.cxx:4169
 TUnixSystem.cxx:4170
 TUnixSystem.cxx:4171
 TUnixSystem.cxx:4172
 TUnixSystem.cxx:4173
 TUnixSystem.cxx:4174
 TUnixSystem.cxx:4175
 TUnixSystem.cxx:4176
 TUnixSystem.cxx:4177
 TUnixSystem.cxx:4178
 TUnixSystem.cxx:4179
 TUnixSystem.cxx:4180
 TUnixSystem.cxx:4181
 TUnixSystem.cxx:4182
 TUnixSystem.cxx:4183
 TUnixSystem.cxx:4184
 TUnixSystem.cxx:4185
 TUnixSystem.cxx:4186
 TUnixSystem.cxx:4187
 TUnixSystem.cxx:4188
 TUnixSystem.cxx:4189
 TUnixSystem.cxx:4190
 TUnixSystem.cxx:4191
 TUnixSystem.cxx:4192
 TUnixSystem.cxx:4193
 TUnixSystem.cxx:4194
 TUnixSystem.cxx:4195
 TUnixSystem.cxx:4196
 TUnixSystem.cxx:4197
 TUnixSystem.cxx:4198
 TUnixSystem.cxx:4199
 TUnixSystem.cxx:4200
 TUnixSystem.cxx:4201
 TUnixSystem.cxx:4202
 TUnixSystem.cxx:4203
 TUnixSystem.cxx:4204
 TUnixSystem.cxx:4205
 TUnixSystem.cxx:4206
 TUnixSystem.cxx:4207
 TUnixSystem.cxx:4208
 TUnixSystem.cxx:4209
 TUnixSystem.cxx:4210
 TUnixSystem.cxx:4211
 TUnixSystem.cxx:4212
 TUnixSystem.cxx:4213
 TUnixSystem.cxx:4214
 TUnixSystem.cxx:4215
 TUnixSystem.cxx:4216
 TUnixSystem.cxx:4217
 TUnixSystem.cxx:4218
 TUnixSystem.cxx:4219
 TUnixSystem.cxx:4220
 TUnixSystem.cxx:4221
 TUnixSystem.cxx:4222
 TUnixSystem.cxx:4223
 TUnixSystem.cxx:4224
 TUnixSystem.cxx:4225
 TUnixSystem.cxx:4226
 TUnixSystem.cxx:4227
 TUnixSystem.cxx:4228
 TUnixSystem.cxx:4229
 TUnixSystem.cxx:4230
 TUnixSystem.cxx:4231
 TUnixSystem.cxx:4232
 TUnixSystem.cxx:4233
 TUnixSystem.cxx:4234
 TUnixSystem.cxx:4235
 TUnixSystem.cxx:4236
 TUnixSystem.cxx:4237
 TUnixSystem.cxx:4238
 TUnixSystem.cxx:4239
 TUnixSystem.cxx:4240
 TUnixSystem.cxx:4241
 TUnixSystem.cxx:4242
 TUnixSystem.cxx:4243
 TUnixSystem.cxx:4244
 TUnixSystem.cxx:4245
 TUnixSystem.cxx:4246
 TUnixSystem.cxx:4247
 TUnixSystem.cxx:4248
 TUnixSystem.cxx:4249
 TUnixSystem.cxx:4250
 TUnixSystem.cxx:4251
 TUnixSystem.cxx:4252
 TUnixSystem.cxx:4253
 TUnixSystem.cxx:4254
 TUnixSystem.cxx:4255
 TUnixSystem.cxx:4256
 TUnixSystem.cxx:4257
 TUnixSystem.cxx:4258
 TUnixSystem.cxx:4259
 TUnixSystem.cxx:4260
 TUnixSystem.cxx:4261
 TUnixSystem.cxx:4262
 TUnixSystem.cxx:4263
 TUnixSystem.cxx:4264
 TUnixSystem.cxx:4265
 TUnixSystem.cxx:4266
 TUnixSystem.cxx:4267
 TUnixSystem.cxx:4268
 TUnixSystem.cxx:4269
 TUnixSystem.cxx:4270
 TUnixSystem.cxx:4271
 TUnixSystem.cxx:4272
 TUnixSystem.cxx:4273
 TUnixSystem.cxx:4274
 TUnixSystem.cxx:4275
 TUnixSystem.cxx:4276
 TUnixSystem.cxx:4277
 TUnixSystem.cxx:4278
 TUnixSystem.cxx:4279
 TUnixSystem.cxx:4280
 TUnixSystem.cxx:4281
 TUnixSystem.cxx:4282
 TUnixSystem.cxx:4283
 TUnixSystem.cxx:4284
 TUnixSystem.cxx:4285
 TUnixSystem.cxx:4286
 TUnixSystem.cxx:4287
 TUnixSystem.cxx:4288
 TUnixSystem.cxx:4289
 TUnixSystem.cxx:4290
 TUnixSystem.cxx:4291
 TUnixSystem.cxx:4292
 TUnixSystem.cxx:4293
 TUnixSystem.cxx:4294
 TUnixSystem.cxx:4295
 TUnixSystem.cxx:4296
 TUnixSystem.cxx:4297
 TUnixSystem.cxx:4298
 TUnixSystem.cxx:4299
 TUnixSystem.cxx:4300
 TUnixSystem.cxx:4301
 TUnixSystem.cxx:4302
 TUnixSystem.cxx:4303
 TUnixSystem.cxx:4304
 TUnixSystem.cxx:4305
 TUnixSystem.cxx:4306
 TUnixSystem.cxx:4307
 TUnixSystem.cxx:4308
 TUnixSystem.cxx:4309
 TUnixSystem.cxx:4310
 TUnixSystem.cxx:4311
 TUnixSystem.cxx:4312
 TUnixSystem.cxx:4313
 TUnixSystem.cxx:4314
 TUnixSystem.cxx:4315
 TUnixSystem.cxx:4316
 TUnixSystem.cxx:4317
 TUnixSystem.cxx:4318
 TUnixSystem.cxx:4319
 TUnixSystem.cxx:4320
 TUnixSystem.cxx:4321
 TUnixSystem.cxx:4322
 TUnixSystem.cxx:4323
 TUnixSystem.cxx:4324
 TUnixSystem.cxx:4325
 TUnixSystem.cxx:4326
 TUnixSystem.cxx:4327
 TUnixSystem.cxx:4328
 TUnixSystem.cxx:4329
 TUnixSystem.cxx:4330
 TUnixSystem.cxx:4331
 TUnixSystem.cxx:4332
 TUnixSystem.cxx:4333
 TUnixSystem.cxx:4334
 TUnixSystem.cxx:4335
 TUnixSystem.cxx:4336
 TUnixSystem.cxx:4337
 TUnixSystem.cxx:4338
 TUnixSystem.cxx:4339
 TUnixSystem.cxx:4340
 TUnixSystem.cxx:4341
 TUnixSystem.cxx:4342
 TUnixSystem.cxx:4343
 TUnixSystem.cxx:4344
 TUnixSystem.cxx:4345
 TUnixSystem.cxx:4346
 TUnixSystem.cxx:4347
 TUnixSystem.cxx:4348
 TUnixSystem.cxx:4349
 TUnixSystem.cxx:4350
 TUnixSystem.cxx:4351
 TUnixSystem.cxx:4352
 TUnixSystem.cxx:4353
 TUnixSystem.cxx:4354
 TUnixSystem.cxx:4355
 TUnixSystem.cxx:4356
 TUnixSystem.cxx:4357
 TUnixSystem.cxx:4358
 TUnixSystem.cxx:4359
 TUnixSystem.cxx:4360
 TUnixSystem.cxx:4361
 TUnixSystem.cxx:4362
 TUnixSystem.cxx:4363
 TUnixSystem.cxx:4364
 TUnixSystem.cxx:4365
 TUnixSystem.cxx:4366
 TUnixSystem.cxx:4367
 TUnixSystem.cxx:4368
 TUnixSystem.cxx:4369
 TUnixSystem.cxx:4370
 TUnixSystem.cxx:4371
 TUnixSystem.cxx:4372
 TUnixSystem.cxx:4373
 TUnixSystem.cxx:4374
 TUnixSystem.cxx:4375
 TUnixSystem.cxx:4376
 TUnixSystem.cxx:4377
 TUnixSystem.cxx:4378
 TUnixSystem.cxx:4379
 TUnixSystem.cxx:4380
 TUnixSystem.cxx:4381
 TUnixSystem.cxx:4382
 TUnixSystem.cxx:4383
 TUnixSystem.cxx:4384
 TUnixSystem.cxx:4385
 TUnixSystem.cxx:4386
 TUnixSystem.cxx:4387
 TUnixSystem.cxx:4388
 TUnixSystem.cxx:4389
 TUnixSystem.cxx:4390
 TUnixSystem.cxx:4391
 TUnixSystem.cxx:4392
 TUnixSystem.cxx:4393
 TUnixSystem.cxx:4394
 TUnixSystem.cxx:4395
 TUnixSystem.cxx:4396
 TUnixSystem.cxx:4397
 TUnixSystem.cxx:4398
 TUnixSystem.cxx:4399
 TUnixSystem.cxx:4400
 TUnixSystem.cxx:4401
 TUnixSystem.cxx:4402
 TUnixSystem.cxx:4403
 TUnixSystem.cxx:4404
 TUnixSystem.cxx:4405
 TUnixSystem.cxx:4406
 TUnixSystem.cxx:4407
 TUnixSystem.cxx:4408
 TUnixSystem.cxx:4409
 TUnixSystem.cxx:4410
 TUnixSystem.cxx:4411
 TUnixSystem.cxx:4412
 TUnixSystem.cxx:4413
 TUnixSystem.cxx:4414
 TUnixSystem.cxx:4415
 TUnixSystem.cxx:4416
 TUnixSystem.cxx:4417
 TUnixSystem.cxx:4418
 TUnixSystem.cxx:4419
 TUnixSystem.cxx:4420
 TUnixSystem.cxx:4421
 TUnixSystem.cxx:4422
 TUnixSystem.cxx:4423
 TUnixSystem.cxx:4424
 TUnixSystem.cxx:4425
 TUnixSystem.cxx:4426
 TUnixSystem.cxx:4427
 TUnixSystem.cxx:4428
 TUnixSystem.cxx:4429
 TUnixSystem.cxx:4430
 TUnixSystem.cxx:4431
 TUnixSystem.cxx:4432
 TUnixSystem.cxx:4433
 TUnixSystem.cxx:4434
 TUnixSystem.cxx:4435
 TUnixSystem.cxx:4436
 TUnixSystem.cxx:4437
 TUnixSystem.cxx:4438
 TUnixSystem.cxx:4439
 TUnixSystem.cxx:4440
 TUnixSystem.cxx:4441
 TUnixSystem.cxx:4442
 TUnixSystem.cxx:4443
 TUnixSystem.cxx:4444
 TUnixSystem.cxx:4445
 TUnixSystem.cxx:4446
 TUnixSystem.cxx:4447
 TUnixSystem.cxx:4448
 TUnixSystem.cxx:4449
 TUnixSystem.cxx:4450
 TUnixSystem.cxx:4451
 TUnixSystem.cxx:4452
 TUnixSystem.cxx:4453
 TUnixSystem.cxx:4454
 TUnixSystem.cxx:4455
 TUnixSystem.cxx:4456
 TUnixSystem.cxx:4457
 TUnixSystem.cxx:4458
 TUnixSystem.cxx:4459
 TUnixSystem.cxx:4460
 TUnixSystem.cxx:4461
 TUnixSystem.cxx:4462
 TUnixSystem.cxx:4463
 TUnixSystem.cxx:4464
 TUnixSystem.cxx:4465
 TUnixSystem.cxx:4466
 TUnixSystem.cxx:4467
 TUnixSystem.cxx:4468
 TUnixSystem.cxx:4469
 TUnixSystem.cxx:4470
 TUnixSystem.cxx:4471
 TUnixSystem.cxx:4472
 TUnixSystem.cxx:4473
 TUnixSystem.cxx:4474
 TUnixSystem.cxx:4475
 TUnixSystem.cxx:4476
 TUnixSystem.cxx:4477
 TUnixSystem.cxx:4478
 TUnixSystem.cxx:4479
 TUnixSystem.cxx:4480
 TUnixSystem.cxx:4481
 TUnixSystem.cxx:4482
 TUnixSystem.cxx:4483
 TUnixSystem.cxx:4484
 TUnixSystem.cxx:4485
 TUnixSystem.cxx:4486
 TUnixSystem.cxx:4487
 TUnixSystem.cxx:4488
 TUnixSystem.cxx:4489
 TUnixSystem.cxx:4490
 TUnixSystem.cxx:4491
 TUnixSystem.cxx:4492
 TUnixSystem.cxx:4493
 TUnixSystem.cxx:4494
 TUnixSystem.cxx:4495
 TUnixSystem.cxx:4496
 TUnixSystem.cxx:4497
 TUnixSystem.cxx:4498
 TUnixSystem.cxx:4499
 TUnixSystem.cxx:4500
 TUnixSystem.cxx:4501
 TUnixSystem.cxx:4502
 TUnixSystem.cxx:4503
 TUnixSystem.cxx:4504
 TUnixSystem.cxx:4505
 TUnixSystem.cxx:4506
 TUnixSystem.cxx:4507
 TUnixSystem.cxx:4508
 TUnixSystem.cxx:4509
 TUnixSystem.cxx:4510
 TUnixSystem.cxx:4511
 TUnixSystem.cxx:4512
 TUnixSystem.cxx:4513
 TUnixSystem.cxx:4514
 TUnixSystem.cxx:4515
 TUnixSystem.cxx:4516
 TUnixSystem.cxx:4517
 TUnixSystem.cxx:4518
 TUnixSystem.cxx:4519
 TUnixSystem.cxx:4520
 TUnixSystem.cxx:4521
 TUnixSystem.cxx:4522
 TUnixSystem.cxx:4523
 TUnixSystem.cxx:4524
 TUnixSystem.cxx:4525
 TUnixSystem.cxx:4526
 TUnixSystem.cxx:4527
 TUnixSystem.cxx:4528
 TUnixSystem.cxx:4529
 TUnixSystem.cxx:4530
 TUnixSystem.cxx:4531
 TUnixSystem.cxx:4532
 TUnixSystem.cxx:4533
 TUnixSystem.cxx:4534
 TUnixSystem.cxx:4535
 TUnixSystem.cxx:4536
 TUnixSystem.cxx:4537
 TUnixSystem.cxx:4538
 TUnixSystem.cxx:4539
 TUnixSystem.cxx:4540
 TUnixSystem.cxx:4541
 TUnixSystem.cxx:4542
 TUnixSystem.cxx:4543
 TUnixSystem.cxx:4544
 TUnixSystem.cxx:4545
 TUnixSystem.cxx:4546
 TUnixSystem.cxx:4547
 TUnixSystem.cxx:4548
 TUnixSystem.cxx:4549
 TUnixSystem.cxx:4550
 TUnixSystem.cxx:4551
 TUnixSystem.cxx:4552
 TUnixSystem.cxx:4553
 TUnixSystem.cxx:4554
 TUnixSystem.cxx:4555
 TUnixSystem.cxx:4556
 TUnixSystem.cxx:4557
 TUnixSystem.cxx:4558
 TUnixSystem.cxx:4559
 TUnixSystem.cxx:4560
 TUnixSystem.cxx:4561
 TUnixSystem.cxx:4562
 TUnixSystem.cxx:4563
 TUnixSystem.cxx:4564
 TUnixSystem.cxx:4565
 TUnixSystem.cxx:4566
 TUnixSystem.cxx:4567
 TUnixSystem.cxx:4568
 TUnixSystem.cxx:4569
 TUnixSystem.cxx:4570
 TUnixSystem.cxx:4571
 TUnixSystem.cxx:4572
 TUnixSystem.cxx:4573
 TUnixSystem.cxx:4574
 TUnixSystem.cxx:4575
 TUnixSystem.cxx:4576
 TUnixSystem.cxx:4577
 TUnixSystem.cxx:4578
 TUnixSystem.cxx:4579
 TUnixSystem.cxx:4580
 TUnixSystem.cxx:4581
 TUnixSystem.cxx:4582
 TUnixSystem.cxx:4583
 TUnixSystem.cxx:4584
 TUnixSystem.cxx:4585
 TUnixSystem.cxx:4586
 TUnixSystem.cxx:4587
 TUnixSystem.cxx:4588
 TUnixSystem.cxx:4589
 TUnixSystem.cxx:4590
 TUnixSystem.cxx:4591
 TUnixSystem.cxx:4592
 TUnixSystem.cxx:4593
 TUnixSystem.cxx:4594
 TUnixSystem.cxx:4595
 TUnixSystem.cxx:4596
 TUnixSystem.cxx:4597
 TUnixSystem.cxx:4598
 TUnixSystem.cxx:4599
 TUnixSystem.cxx:4600
 TUnixSystem.cxx:4601
 TUnixSystem.cxx:4602
 TUnixSystem.cxx:4603
 TUnixSystem.cxx:4604
 TUnixSystem.cxx:4605
 TUnixSystem.cxx:4606
 TUnixSystem.cxx:4607
 TUnixSystem.cxx:4608
 TUnixSystem.cxx:4609
 TUnixSystem.cxx:4610
 TUnixSystem.cxx:4611
 TUnixSystem.cxx:4612
 TUnixSystem.cxx:4613
 TUnixSystem.cxx:4614
 TUnixSystem.cxx:4615
 TUnixSystem.cxx:4616
 TUnixSystem.cxx:4617
 TUnixSystem.cxx:4618
 TUnixSystem.cxx:4619
 TUnixSystem.cxx:4620
 TUnixSystem.cxx:4621
 TUnixSystem.cxx:4622
 TUnixSystem.cxx:4623
 TUnixSystem.cxx:4624
 TUnixSystem.cxx:4625
 TUnixSystem.cxx:4626
 TUnixSystem.cxx:4627
 TUnixSystem.cxx:4628
 TUnixSystem.cxx:4629
 TUnixSystem.cxx:4630
 TUnixSystem.cxx:4631
 TUnixSystem.cxx:4632
 TUnixSystem.cxx:4633
 TUnixSystem.cxx:4634
 TUnixSystem.cxx:4635
 TUnixSystem.cxx:4636
 TUnixSystem.cxx:4637
 TUnixSystem.cxx:4638
 TUnixSystem.cxx:4639
 TUnixSystem.cxx:4640
 TUnixSystem.cxx:4641
 TUnixSystem.cxx:4642
 TUnixSystem.cxx:4643
 TUnixSystem.cxx:4644
 TUnixSystem.cxx:4645
 TUnixSystem.cxx:4646
 TUnixSystem.cxx:4647
 TUnixSystem.cxx:4648
 TUnixSystem.cxx:4649
 TUnixSystem.cxx:4650
 TUnixSystem.cxx:4651
 TUnixSystem.cxx:4652
 TUnixSystem.cxx:4653
 TUnixSystem.cxx:4654
 TUnixSystem.cxx:4655
 TUnixSystem.cxx:4656
 TUnixSystem.cxx:4657
 TUnixSystem.cxx:4658
 TUnixSystem.cxx:4659
 TUnixSystem.cxx:4660
 TUnixSystem.cxx:4661
 TUnixSystem.cxx:4662
 TUnixSystem.cxx:4663
 TUnixSystem.cxx:4664
 TUnixSystem.cxx:4665
 TUnixSystem.cxx:4666
 TUnixSystem.cxx:4667
 TUnixSystem.cxx:4668
 TUnixSystem.cxx:4669
 TUnixSystem.cxx:4670
 TUnixSystem.cxx:4671
 TUnixSystem.cxx:4672
 TUnixSystem.cxx:4673
 TUnixSystem.cxx:4674
 TUnixSystem.cxx:4675
 TUnixSystem.cxx:4676
 TUnixSystem.cxx:4677
 TUnixSystem.cxx:4678
 TUnixSystem.cxx:4679
 TUnixSystem.cxx:4680
 TUnixSystem.cxx:4681
 TUnixSystem.cxx:4682
 TUnixSystem.cxx:4683
 TUnixSystem.cxx:4684
 TUnixSystem.cxx:4685
 TUnixSystem.cxx:4686
 TUnixSystem.cxx:4687
 TUnixSystem.cxx:4688
 TUnixSystem.cxx:4689
 TUnixSystem.cxx:4690
 TUnixSystem.cxx:4691
 TUnixSystem.cxx:4692
 TUnixSystem.cxx:4693
 TUnixSystem.cxx:4694
 TUnixSystem.cxx:4695
 TUnixSystem.cxx:4696
 TUnixSystem.cxx:4697
 TUnixSystem.cxx:4698
 TUnixSystem.cxx:4699
 TUnixSystem.cxx:4700
 TUnixSystem.cxx:4701
 TUnixSystem.cxx:4702
 TUnixSystem.cxx:4703
 TUnixSystem.cxx:4704
 TUnixSystem.cxx:4705
 TUnixSystem.cxx:4706
 TUnixSystem.cxx:4707
 TUnixSystem.cxx:4708
 TUnixSystem.cxx:4709
 TUnixSystem.cxx:4710
 TUnixSystem.cxx:4711
 TUnixSystem.cxx:4712
 TUnixSystem.cxx:4713
 TUnixSystem.cxx:4714
 TUnixSystem.cxx:4715
 TUnixSystem.cxx:4716
 TUnixSystem.cxx:4717
 TUnixSystem.cxx:4718
 TUnixSystem.cxx:4719
 TUnixSystem.cxx:4720
 TUnixSystem.cxx:4721
 TUnixSystem.cxx:4722
 TUnixSystem.cxx:4723
 TUnixSystem.cxx:4724
 TUnixSystem.cxx:4725
 TUnixSystem.cxx:4726
 TUnixSystem.cxx:4727
 TUnixSystem.cxx:4728
 TUnixSystem.cxx:4729
 TUnixSystem.cxx:4730
 TUnixSystem.cxx:4731
 TUnixSystem.cxx:4732
 TUnixSystem.cxx:4733
 TUnixSystem.cxx:4734
 TUnixSystem.cxx:4735
 TUnixSystem.cxx:4736
 TUnixSystem.cxx:4737
 TUnixSystem.cxx:4738
 TUnixSystem.cxx:4739
 TUnixSystem.cxx:4740
 TUnixSystem.cxx:4741
 TUnixSystem.cxx:4742
 TUnixSystem.cxx:4743
 TUnixSystem.cxx:4744
 TUnixSystem.cxx:4745
 TUnixSystem.cxx:4746
 TUnixSystem.cxx:4747
 TUnixSystem.cxx:4748
 TUnixSystem.cxx:4749
 TUnixSystem.cxx:4750
 TUnixSystem.cxx:4751
 TUnixSystem.cxx:4752
 TUnixSystem.cxx:4753
 TUnixSystem.cxx:4754
 TUnixSystem.cxx:4755
 TUnixSystem.cxx:4756
 TUnixSystem.cxx:4757
 TUnixSystem.cxx:4758
 TUnixSystem.cxx:4759
 TUnixSystem.cxx:4760
 TUnixSystem.cxx:4761
 TUnixSystem.cxx:4762
 TUnixSystem.cxx:4763
 TUnixSystem.cxx:4764
 TUnixSystem.cxx:4765
 TUnixSystem.cxx:4766
 TUnixSystem.cxx:4767
 TUnixSystem.cxx:4768
 TUnixSystem.cxx:4769
 TUnixSystem.cxx:4770
 TUnixSystem.cxx:4771
 TUnixSystem.cxx:4772
 TUnixSystem.cxx:4773
 TUnixSystem.cxx:4774
 TUnixSystem.cxx:4775
 TUnixSystem.cxx:4776
 TUnixSystem.cxx:4777
 TUnixSystem.cxx:4778
 TUnixSystem.cxx:4779
 TUnixSystem.cxx:4780
 TUnixSystem.cxx:4781
 TUnixSystem.cxx:4782
 TUnixSystem.cxx:4783
 TUnixSystem.cxx:4784
 TUnixSystem.cxx:4785
 TUnixSystem.cxx:4786
 TUnixSystem.cxx:4787
 TUnixSystem.cxx:4788
 TUnixSystem.cxx:4789
 TUnixSystem.cxx:4790
 TUnixSystem.cxx:4791
 TUnixSystem.cxx:4792
 TUnixSystem.cxx:4793
 TUnixSystem.cxx:4794
 TUnixSystem.cxx:4795
 TUnixSystem.cxx:4796
 TUnixSystem.cxx:4797
 TUnixSystem.cxx:4798
 TUnixSystem.cxx:4799
 TUnixSystem.cxx:4800
 TUnixSystem.cxx:4801
 TUnixSystem.cxx:4802
 TUnixSystem.cxx:4803
 TUnixSystem.cxx:4804
 TUnixSystem.cxx:4805
 TUnixSystem.cxx:4806
 TUnixSystem.cxx:4807
 TUnixSystem.cxx:4808
 TUnixSystem.cxx:4809
 TUnixSystem.cxx:4810
 TUnixSystem.cxx:4811
 TUnixSystem.cxx:4812
 TUnixSystem.cxx:4813
 TUnixSystem.cxx:4814
 TUnixSystem.cxx:4815
 TUnixSystem.cxx:4816
 TUnixSystem.cxx:4817
 TUnixSystem.cxx:4818
 TUnixSystem.cxx:4819
 TUnixSystem.cxx:4820
 TUnixSystem.cxx:4821
 TUnixSystem.cxx:4822
 TUnixSystem.cxx:4823
 TUnixSystem.cxx:4824
 TUnixSystem.cxx:4825
 TUnixSystem.cxx:4826
 TUnixSystem.cxx:4827
 TUnixSystem.cxx:4828
 TUnixSystem.cxx:4829
 TUnixSystem.cxx:4830
 TUnixSystem.cxx:4831
 TUnixSystem.cxx:4832
 TUnixSystem.cxx:4833
 TUnixSystem.cxx:4834
 TUnixSystem.cxx:4835
 TUnixSystem.cxx:4836
 TUnixSystem.cxx:4837
 TUnixSystem.cxx:4838
 TUnixSystem.cxx:4839
 TUnixSystem.cxx:4840
 TUnixSystem.cxx:4841
 TUnixSystem.cxx:4842
 TUnixSystem.cxx:4843
 TUnixSystem.cxx:4844
 TUnixSystem.cxx:4845
 TUnixSystem.cxx:4846
 TUnixSystem.cxx:4847
 TUnixSystem.cxx:4848
 TUnixSystem.cxx:4849
 TUnixSystem.cxx:4850
 TUnixSystem.cxx:4851
 TUnixSystem.cxx:4852
 TUnixSystem.cxx:4853
 TUnixSystem.cxx:4854
 TUnixSystem.cxx:4855
 TUnixSystem.cxx:4856
 TUnixSystem.cxx:4857
 TUnixSystem.cxx:4858
 TUnixSystem.cxx:4859
 TUnixSystem.cxx:4860
 TUnixSystem.cxx:4861
 TUnixSystem.cxx:4862
 TUnixSystem.cxx:4863
 TUnixSystem.cxx:4864
 TUnixSystem.cxx:4865
 TUnixSystem.cxx:4866
 TUnixSystem.cxx:4867
 TUnixSystem.cxx:4868
 TUnixSystem.cxx:4869
 TUnixSystem.cxx:4870
 TUnixSystem.cxx:4871
 TUnixSystem.cxx:4872
 TUnixSystem.cxx:4873
 TUnixSystem.cxx:4874
 TUnixSystem.cxx:4875
 TUnixSystem.cxx:4876
 TUnixSystem.cxx:4877
 TUnixSystem.cxx:4878
 TUnixSystem.cxx:4879
 TUnixSystem.cxx:4880
 TUnixSystem.cxx:4881
 TUnixSystem.cxx:4882
 TUnixSystem.cxx:4883
 TUnixSystem.cxx:4884
 TUnixSystem.cxx:4885
 TUnixSystem.cxx:4886
 TUnixSystem.cxx:4887
 TUnixSystem.cxx:4888
 TUnixSystem.cxx:4889
 TUnixSystem.cxx:4890
 TUnixSystem.cxx:4891
 TUnixSystem.cxx:4892
 TUnixSystem.cxx:4893
 TUnixSystem.cxx:4894
 TUnixSystem.cxx:4895
 TUnixSystem.cxx:4896
 TUnixSystem.cxx:4897
 TUnixSystem.cxx:4898
 TUnixSystem.cxx:4899
 TUnixSystem.cxx:4900
 TUnixSystem.cxx:4901
 TUnixSystem.cxx:4902
 TUnixSystem.cxx:4903
 TUnixSystem.cxx:4904
 TUnixSystem.cxx:4905
 TUnixSystem.cxx:4906
 TUnixSystem.cxx:4907
 TUnixSystem.cxx:4908
 TUnixSystem.cxx:4909
 TUnixSystem.cxx:4910
 TUnixSystem.cxx:4911
 TUnixSystem.cxx:4912
 TUnixSystem.cxx:4913
 TUnixSystem.cxx:4914
 TUnixSystem.cxx:4915
 TUnixSystem.cxx:4916
 TUnixSystem.cxx:4917
 TUnixSystem.cxx:4918
 TUnixSystem.cxx:4919
 TUnixSystem.cxx:4920
 TUnixSystem.cxx:4921
 TUnixSystem.cxx:4922
 TUnixSystem.cxx:4923
 TUnixSystem.cxx:4924
 TUnixSystem.cxx:4925
 TUnixSystem.cxx:4926
 TUnixSystem.cxx:4927
 TUnixSystem.cxx:4928
 TUnixSystem.cxx:4929
 TUnixSystem.cxx:4930
 TUnixSystem.cxx:4931
 TUnixSystem.cxx:4932
 TUnixSystem.cxx:4933
 TUnixSystem.cxx:4934
 TUnixSystem.cxx:4935
 TUnixSystem.cxx:4936
 TUnixSystem.cxx:4937
 TUnixSystem.cxx:4938
 TUnixSystem.cxx:4939
 TUnixSystem.cxx:4940
 TUnixSystem.cxx:4941
 TUnixSystem.cxx:4942
 TUnixSystem.cxx:4943
 TUnixSystem.cxx:4944
 TUnixSystem.cxx:4945
 TUnixSystem.cxx:4946
 TUnixSystem.cxx:4947
 TUnixSystem.cxx:4948
 TUnixSystem.cxx:4949
 TUnixSystem.cxx:4950
 TUnixSystem.cxx:4951
 TUnixSystem.cxx:4952
 TUnixSystem.cxx:4953
 TUnixSystem.cxx:4954
 TUnixSystem.cxx:4955
 TUnixSystem.cxx:4956
 TUnixSystem.cxx:4957
 TUnixSystem.cxx:4958
 TUnixSystem.cxx:4959
 TUnixSystem.cxx:4960
 TUnixSystem.cxx:4961
 TUnixSystem.cxx:4962
 TUnixSystem.cxx:4963
 TUnixSystem.cxx:4964
 TUnixSystem.cxx:4965
 TUnixSystem.cxx:4966
 TUnixSystem.cxx:4967
 TUnixSystem.cxx:4968
 TUnixSystem.cxx:4969
 TUnixSystem.cxx:4970
 TUnixSystem.cxx:4971
 TUnixSystem.cxx:4972
 TUnixSystem.cxx:4973
 TUnixSystem.cxx:4974
 TUnixSystem.cxx:4975
 TUnixSystem.cxx:4976
 TUnixSystem.cxx:4977
 TUnixSystem.cxx:4978
 TUnixSystem.cxx:4979
 TUnixSystem.cxx:4980
 TUnixSystem.cxx:4981
 TUnixSystem.cxx:4982
 TUnixSystem.cxx:4983
 TUnixSystem.cxx:4984
 TUnixSystem.cxx:4985
 TUnixSystem.cxx:4986
 TUnixSystem.cxx:4987
 TUnixSystem.cxx:4988
 TUnixSystem.cxx:4989
 TUnixSystem.cxx:4990
 TUnixSystem.cxx:4991
 TUnixSystem.cxx:4992
 TUnixSystem.cxx:4993
 TUnixSystem.cxx:4994
 TUnixSystem.cxx:4995
 TUnixSystem.cxx:4996
 TUnixSystem.cxx:4997
 TUnixSystem.cxx:4998
 TUnixSystem.cxx:4999
 TUnixSystem.cxx:5000
 TUnixSystem.cxx:5001
 TUnixSystem.cxx:5002
 TUnixSystem.cxx:5003
 TUnixSystem.cxx:5004
 TUnixSystem.cxx:5005
 TUnixSystem.cxx:5006
 TUnixSystem.cxx:5007
 TUnixSystem.cxx:5008
 TUnixSystem.cxx:5009
 TUnixSystem.cxx:5010
 TUnixSystem.cxx:5011
 TUnixSystem.cxx:5012
 TUnixSystem.cxx:5013
 TUnixSystem.cxx:5014
 TUnixSystem.cxx:5015
 TUnixSystem.cxx:5016
 TUnixSystem.cxx:5017
 TUnixSystem.cxx:5018
 TUnixSystem.cxx:5019
 TUnixSystem.cxx:5020
 TUnixSystem.cxx:5021
 TUnixSystem.cxx:5022
 TUnixSystem.cxx:5023
 TUnixSystem.cxx:5024
 TUnixSystem.cxx:5025
 TUnixSystem.cxx:5026
 TUnixSystem.cxx:5027
 TUnixSystem.cxx:5028
 TUnixSystem.cxx:5029
 TUnixSystem.cxx:5030
 TUnixSystem.cxx:5031
 TUnixSystem.cxx:5032
 TUnixSystem.cxx:5033
 TUnixSystem.cxx:5034
 TUnixSystem.cxx:5035
 TUnixSystem.cxx:5036
 TUnixSystem.cxx:5037
 TUnixSystem.cxx:5038
 TUnixSystem.cxx:5039
 TUnixSystem.cxx:5040
 TUnixSystem.cxx:5041
 TUnixSystem.cxx:5042
 TUnixSystem.cxx:5043
 TUnixSystem.cxx:5044
 TUnixSystem.cxx:5045
 TUnixSystem.cxx:5046
 TUnixSystem.cxx:5047
 TUnixSystem.cxx:5048
 TUnixSystem.cxx:5049
 TUnixSystem.cxx:5050
 TUnixSystem.cxx:5051
 TUnixSystem.cxx:5052
 TUnixSystem.cxx:5053
 TUnixSystem.cxx:5054
 TUnixSystem.cxx:5055
 TUnixSystem.cxx:5056
 TUnixSystem.cxx:5057
 TUnixSystem.cxx:5058
 TUnixSystem.cxx:5059
 TUnixSystem.cxx:5060
 TUnixSystem.cxx:5061
 TUnixSystem.cxx:5062
 TUnixSystem.cxx:5063
 TUnixSystem.cxx:5064
 TUnixSystem.cxx:5065
 TUnixSystem.cxx:5066
 TUnixSystem.cxx:5067
 TUnixSystem.cxx:5068
 TUnixSystem.cxx:5069
 TUnixSystem.cxx:5070
 TUnixSystem.cxx:5071
 TUnixSystem.cxx:5072
 TUnixSystem.cxx:5073
 TUnixSystem.cxx:5074
 TUnixSystem.cxx:5075
 TUnixSystem.cxx:5076
 TUnixSystem.cxx:5077
 TUnixSystem.cxx:5078
 TUnixSystem.cxx:5079
 TUnixSystem.cxx:5080
 TUnixSystem.cxx:5081
 TUnixSystem.cxx:5082
 TUnixSystem.cxx:5083
 TUnixSystem.cxx:5084
 TUnixSystem.cxx:5085
 TUnixSystem.cxx:5086
 TUnixSystem.cxx:5087
 TUnixSystem.cxx:5088
 TUnixSystem.cxx:5089
 TUnixSystem.cxx:5090
 TUnixSystem.cxx:5091
 TUnixSystem.cxx:5092
 TUnixSystem.cxx:5093
 TUnixSystem.cxx:5094
 TUnixSystem.cxx:5095
 TUnixSystem.cxx:5096
 TUnixSystem.cxx:5097
 TUnixSystem.cxx:5098
 TUnixSystem.cxx:5099
 TUnixSystem.cxx:5100
 TUnixSystem.cxx:5101
 TUnixSystem.cxx:5102
 TUnixSystem.cxx:5103
 TUnixSystem.cxx:5104
 TUnixSystem.cxx:5105
 TUnixSystem.cxx:5106
 TUnixSystem.cxx:5107
 TUnixSystem.cxx:5108
 TUnixSystem.cxx:5109
 TUnixSystem.cxx:5110
 TUnixSystem.cxx:5111
 TUnixSystem.cxx:5112
 TUnixSystem.cxx:5113
 TUnixSystem.cxx:5114
 TUnixSystem.cxx:5115
 TUnixSystem.cxx:5116
 TUnixSystem.cxx:5117
 TUnixSystem.cxx:5118
 TUnixSystem.cxx:5119
 TUnixSystem.cxx:5120
 TUnixSystem.cxx:5121
 TUnixSystem.cxx:5122
 TUnixSystem.cxx:5123
 TUnixSystem.cxx:5124
 TUnixSystem.cxx:5125
 TUnixSystem.cxx:5126
 TUnixSystem.cxx:5127
 TUnixSystem.cxx:5128
 TUnixSystem.cxx:5129
 TUnixSystem.cxx:5130
 TUnixSystem.cxx:5131
 TUnixSystem.cxx:5132
 TUnixSystem.cxx:5133
 TUnixSystem.cxx:5134
 TUnixSystem.cxx:5135
 TUnixSystem.cxx:5136
 TUnixSystem.cxx:5137
 TUnixSystem.cxx:5138
 TUnixSystem.cxx:5139
 TUnixSystem.cxx:5140
 TUnixSystem.cxx:5141
 TUnixSystem.cxx:5142
 TUnixSystem.cxx:5143
 TUnixSystem.cxx:5144
 TUnixSystem.cxx:5145
 TUnixSystem.cxx:5146
 TUnixSystem.cxx:5147
 TUnixSystem.cxx:5148
 TUnixSystem.cxx:5149
 TUnixSystem.cxx:5150
 TUnixSystem.cxx:5151
 TUnixSystem.cxx:5152
 TUnixSystem.cxx:5153
 TUnixSystem.cxx:5154
 TUnixSystem.cxx:5155
 TUnixSystem.cxx:5156
 TUnixSystem.cxx:5157
 TUnixSystem.cxx:5158
 TUnixSystem.cxx:5159
 TUnixSystem.cxx:5160
 TUnixSystem.cxx:5161
 TUnixSystem.cxx:5162
 TUnixSystem.cxx:5163
 TUnixSystem.cxx:5164
 TUnixSystem.cxx:5165
 TUnixSystem.cxx:5166
 TUnixSystem.cxx:5167
 TUnixSystem.cxx:5168
 TUnixSystem.cxx:5169
 TUnixSystem.cxx:5170
 TUnixSystem.cxx:5171
 TUnixSystem.cxx:5172
 TUnixSystem.cxx:5173
 TUnixSystem.cxx:5174
 TUnixSystem.cxx:5175
 TUnixSystem.cxx:5176
 TUnixSystem.cxx:5177
 TUnixSystem.cxx:5178
 TUnixSystem.cxx:5179
 TUnixSystem.cxx:5180
 TUnixSystem.cxx:5181
 TUnixSystem.cxx:5182
 TUnixSystem.cxx:5183
 TUnixSystem.cxx:5184
 TUnixSystem.cxx:5185
 TUnixSystem.cxx:5186
 TUnixSystem.cxx:5187
 TUnixSystem.cxx:5188
 TUnixSystem.cxx:5189
 TUnixSystem.cxx:5190
 TUnixSystem.cxx:5191
 TUnixSystem.cxx:5192
 TUnixSystem.cxx:5193
 TUnixSystem.cxx:5194
 TUnixSystem.cxx:5195
 TUnixSystem.cxx:5196
 TUnixSystem.cxx:5197
 TUnixSystem.cxx:5198
 TUnixSystem.cxx:5199
 TUnixSystem.cxx:5200
 TUnixSystem.cxx:5201
 TUnixSystem.cxx:5202
 TUnixSystem.cxx:5203
 TUnixSystem.cxx:5204
 TUnixSystem.cxx:5205
 TUnixSystem.cxx:5206
 TUnixSystem.cxx:5207
 TUnixSystem.cxx:5208
 TUnixSystem.cxx:5209
 TUnixSystem.cxx:5210
 TUnixSystem.cxx:5211
 TUnixSystem.cxx:5212
 TUnixSystem.cxx:5213
 TUnixSystem.cxx:5214
 TUnixSystem.cxx:5215
 TUnixSystem.cxx:5216
 TUnixSystem.cxx:5217
 TUnixSystem.cxx:5218
 TUnixSystem.cxx:5219
 TUnixSystem.cxx:5220
 TUnixSystem.cxx:5221
 TUnixSystem.cxx:5222
 TUnixSystem.cxx:5223
 TUnixSystem.cxx:5224
 TUnixSystem.cxx:5225
 TUnixSystem.cxx:5226
 TUnixSystem.cxx:5227
 TUnixSystem.cxx:5228
 TUnixSystem.cxx:5229
 TUnixSystem.cxx:5230
 TUnixSystem.cxx:5231
 TUnixSystem.cxx:5232
 TUnixSystem.cxx:5233
 TUnixSystem.cxx:5234
 TUnixSystem.cxx:5235
 TUnixSystem.cxx:5236
 TUnixSystem.cxx:5237
 TUnixSystem.cxx:5238
 TUnixSystem.cxx:5239
 TUnixSystem.cxx:5240
 TUnixSystem.cxx:5241
 TUnixSystem.cxx:5242
 TUnixSystem.cxx:5243
 TUnixSystem.cxx:5244
 TUnixSystem.cxx:5245
 TUnixSystem.cxx:5246
 TUnixSystem.cxx:5247
 TUnixSystem.cxx:5248
 TUnixSystem.cxx:5249
 TUnixSystem.cxx:5250
 TUnixSystem.cxx:5251
 TUnixSystem.cxx:5252
 TUnixSystem.cxx:5253
 TUnixSystem.cxx:5254
 TUnixSystem.cxx:5255
 TUnixSystem.cxx:5256
 TUnixSystem.cxx:5257
 TUnixSystem.cxx:5258
 TUnixSystem.cxx:5259
 TUnixSystem.cxx:5260
 TUnixSystem.cxx:5261
 TUnixSystem.cxx:5262
 TUnixSystem.cxx:5263
 TUnixSystem.cxx:5264
 TUnixSystem.cxx:5265
 TUnixSystem.cxx:5266
 TUnixSystem.cxx:5267
 TUnixSystem.cxx:5268
 TUnixSystem.cxx:5269
 TUnixSystem.cxx:5270
 TUnixSystem.cxx:5271
 TUnixSystem.cxx:5272
 TUnixSystem.cxx:5273
 TUnixSystem.cxx:5274
 TUnixSystem.cxx:5275
 TUnixSystem.cxx:5276
 TUnixSystem.cxx:5277
 TUnixSystem.cxx:5278
 TUnixSystem.cxx:5279
 TUnixSystem.cxx:5280
 TUnixSystem.cxx:5281
 TUnixSystem.cxx:5282
 TUnixSystem.cxx:5283
 TUnixSystem.cxx:5284
 TUnixSystem.cxx:5285
 TUnixSystem.cxx:5286
 TUnixSystem.cxx:5287
 TUnixSystem.cxx:5288
 TUnixSystem.cxx:5289
 TUnixSystem.cxx:5290
 TUnixSystem.cxx:5291
 TUnixSystem.cxx:5292
 TUnixSystem.cxx:5293
 TUnixSystem.cxx:5294
 TUnixSystem.cxx:5295
 TUnixSystem.cxx:5296
 TUnixSystem.cxx:5297
 TUnixSystem.cxx:5298
 TUnixSystem.cxx:5299
 TUnixSystem.cxx:5300
 TUnixSystem.cxx:5301
 TUnixSystem.cxx:5302
 TUnixSystem.cxx:5303
 TUnixSystem.cxx:5304
 TUnixSystem.cxx:5305
 TUnixSystem.cxx:5306
 TUnixSystem.cxx:5307
 TUnixSystem.cxx:5308
 TUnixSystem.cxx:5309
 TUnixSystem.cxx:5310
 TUnixSystem.cxx:5311
 TUnixSystem.cxx:5312
 TUnixSystem.cxx:5313
 TUnixSystem.cxx:5314
 TUnixSystem.cxx:5315
 TUnixSystem.cxx:5316
 TUnixSystem.cxx:5317
 TUnixSystem.cxx:5318
 TUnixSystem.cxx:5319
 TUnixSystem.cxx:5320
 TUnixSystem.cxx:5321
 TUnixSystem.cxx:5322
 TUnixSystem.cxx:5323
 TUnixSystem.cxx:5324
 TUnixSystem.cxx:5325
 TUnixSystem.cxx:5326
 TUnixSystem.cxx:5327
 TUnixSystem.cxx:5328
 TUnixSystem.cxx:5329
 TUnixSystem.cxx:5330
 TUnixSystem.cxx:5331
 TUnixSystem.cxx:5332
 TUnixSystem.cxx:5333
 TUnixSystem.cxx:5334
 TUnixSystem.cxx:5335
 TUnixSystem.cxx:5336
 TUnixSystem.cxx:5337
 TUnixSystem.cxx:5338
 TUnixSystem.cxx:5339
 TUnixSystem.cxx:5340
 TUnixSystem.cxx:5341
 TUnixSystem.cxx:5342
 TUnixSystem.cxx:5343
 TUnixSystem.cxx:5344
 TUnixSystem.cxx:5345
 TUnixSystem.cxx:5346
 TUnixSystem.cxx:5347
 TUnixSystem.cxx:5348
 TUnixSystem.cxx:5349
 TUnixSystem.cxx:5350
 TUnixSystem.cxx:5351
 TUnixSystem.cxx:5352
 TUnixSystem.cxx:5353
 TUnixSystem.cxx:5354
 TUnixSystem.cxx:5355
 TUnixSystem.cxx:5356
 TUnixSystem.cxx:5357
 TUnixSystem.cxx:5358
 TUnixSystem.cxx:5359
 TUnixSystem.cxx:5360
 TUnixSystem.cxx:5361
 TUnixSystem.cxx:5362
 TUnixSystem.cxx:5363
 TUnixSystem.cxx:5364
 TUnixSystem.cxx:5365
 TUnixSystem.cxx:5366
 TUnixSystem.cxx:5367
 TUnixSystem.cxx:5368
 TUnixSystem.cxx:5369
 TUnixSystem.cxx:5370
 TUnixSystem.cxx:5371
 TUnixSystem.cxx:5372
 TUnixSystem.cxx:5373
 TUnixSystem.cxx:5374
 TUnixSystem.cxx:5375
 TUnixSystem.cxx:5376
 TUnixSystem.cxx:5377
 TUnixSystem.cxx:5378
 TUnixSystem.cxx:5379
 TUnixSystem.cxx:5380
 TUnixSystem.cxx:5381
 TUnixSystem.cxx:5382
 TUnixSystem.cxx:5383
 TUnixSystem.cxx:5384
 TUnixSystem.cxx:5385
 TUnixSystem.cxx:5386
 TUnixSystem.cxx:5387
 TUnixSystem.cxx:5388
 TUnixSystem.cxx:5389
 TUnixSystem.cxx:5390
 TUnixSystem.cxx:5391
 TUnixSystem.cxx:5392
 TUnixSystem.cxx:5393
 TUnixSystem.cxx:5394
 TUnixSystem.cxx:5395
 TUnixSystem.cxx:5396
 TUnixSystem.cxx:5397
 TUnixSystem.cxx:5398
 TUnixSystem.cxx:5399
 TUnixSystem.cxx:5400
 TUnixSystem.cxx:5401
 TUnixSystem.cxx:5402
 TUnixSystem.cxx:5403
 TUnixSystem.cxx:5404
 TUnixSystem.cxx:5405
 TUnixSystem.cxx:5406
 TUnixSystem.cxx:5407
 TUnixSystem.cxx:5408
 TUnixSystem.cxx:5409
 TUnixSystem.cxx:5410
 TUnixSystem.cxx:5411
 TUnixSystem.cxx:5412
 TUnixSystem.cxx:5413
 TUnixSystem.cxx:5414
 TUnixSystem.cxx:5415
 TUnixSystem.cxx:5416
 TUnixSystem.cxx:5417
 TUnixSystem.cxx:5418
 TUnixSystem.cxx:5419
 TUnixSystem.cxx:5420
 TUnixSystem.cxx:5421
 TUnixSystem.cxx:5422
 TUnixSystem.cxx:5423
 TUnixSystem.cxx:5424
 TUnixSystem.cxx:5425
 TUnixSystem.cxx:5426
 TUnixSystem.cxx:5427
 TUnixSystem.cxx:5428
 TUnixSystem.cxx:5429
 TUnixSystem.cxx:5430
 TUnixSystem.cxx:5431
 TUnixSystem.cxx:5432
 TUnixSystem.cxx:5433
 TUnixSystem.cxx:5434
 TUnixSystem.cxx:5435
 TUnixSystem.cxx:5436
 TUnixSystem.cxx:5437
 TUnixSystem.cxx:5438
 TUnixSystem.cxx:5439
 TUnixSystem.cxx:5440
 TUnixSystem.cxx:5441
 TUnixSystem.cxx:5442
 TUnixSystem.cxx:5443
 TUnixSystem.cxx:5444
 TUnixSystem.cxx:5445
 TUnixSystem.cxx:5446
 TUnixSystem.cxx:5447
 TUnixSystem.cxx:5448
 TUnixSystem.cxx:5449
 TUnixSystem.cxx:5450
 TUnixSystem.cxx:5451
 TUnixSystem.cxx:5452
 TUnixSystem.cxx:5453
 TUnixSystem.cxx:5454
 TUnixSystem.cxx:5455
 TUnixSystem.cxx:5456
 TUnixSystem.cxx:5457
 TUnixSystem.cxx:5458
 TUnixSystem.cxx:5459
 TUnixSystem.cxx:5460
 TUnixSystem.cxx:5461
 TUnixSystem.cxx:5462
 TUnixSystem.cxx:5463
 TUnixSystem.cxx:5464
 TUnixSystem.cxx:5465
 TUnixSystem.cxx:5466
 TUnixSystem.cxx:5467
 TUnixSystem.cxx:5468
 TUnixSystem.cxx:5469
 TUnixSystem.cxx:5470
 TUnixSystem.cxx:5471
 TUnixSystem.cxx:5472
 TUnixSystem.cxx:5473
 TUnixSystem.cxx:5474
 TUnixSystem.cxx:5475
 TUnixSystem.cxx:5476
 TUnixSystem.cxx:5477
 TUnixSystem.cxx:5478
 TUnixSystem.cxx:5479
 TUnixSystem.cxx:5480
 TUnixSystem.cxx:5481
 TUnixSystem.cxx:5482
 TUnixSystem.cxx:5483
 TUnixSystem.cxx:5484
 TUnixSystem.cxx:5485
 TUnixSystem.cxx:5486
 TUnixSystem.cxx:5487
 TUnixSystem.cxx:5488
 TUnixSystem.cxx:5489
 TUnixSystem.cxx:5490
 TUnixSystem.cxx:5491
 TUnixSystem.cxx:5492
 TUnixSystem.cxx:5493
 TUnixSystem.cxx:5494
 TUnixSystem.cxx:5495
 TUnixSystem.cxx:5496
 TUnixSystem.cxx:5497
 TUnixSystem.cxx:5498
 TUnixSystem.cxx:5499
 TUnixSystem.cxx:5500
 TUnixSystem.cxx:5501
 TUnixSystem.cxx:5502
 TUnixSystem.cxx:5503
 TUnixSystem.cxx:5504
 TUnixSystem.cxx:5505
 TUnixSystem.cxx:5506
 TUnixSystem.cxx:5507
 TUnixSystem.cxx:5508
 TUnixSystem.cxx:5509
 TUnixSystem.cxx:5510
 TUnixSystem.cxx:5511
 TUnixSystem.cxx:5512
 TUnixSystem.cxx:5513
 TUnixSystem.cxx:5514
 TUnixSystem.cxx:5515
 TUnixSystem.cxx:5516