diff --git a/asyncprotocol.c b/asyncprotocol.c
new file mode 100644
index 00000000..35fa8526
--- /dev/null
+++ b/asyncprotocol.c
@@ -0,0 +1,338 @@
+#include <sics.h>
+#include <asyncprotocol.h>
+#include <asyncqueue.h>
+
+int defaultSendCommand(pAsyncProtocol p, pAsyncTxn txn) {
+  int i, iRet;
+  int state;
+  const char *term = "\r\n";
+  if (p->sendTerminator)
+    term = p->sendTerminator;
+  state = 0;
+  for (i = 0; i < txn->out_len; ++i) {
+    if (txn->out_buf[i] == 0x00) { /* end of transmission */
+      break;
+    }
+    else if (txn->out_buf[i] == term[state]) {
+      ++state;
+      continue;
+    }
+    state = 0;
+  }
+  txn->txn_state = 0;
+  iRet = AsyncUnitWrite(txn->unit, txn->out_buf, txn->out_len);
+  if (iRet <= 0)
+    return iRet;
+  if (term[state] != 0)
+    iRet = AsyncUnitWrite(txn->unit,(void *) term, strlen(term));
+  return iRet;
+}
+
+int defaultHandleInput(pAsyncProtocol p, pAsyncTxn txn, int ch) {
+  const char *term = "\r\n";
+  if (p->replyTerminator)
+    term = p->replyTerminator;
+  if (ch == term[txn->txn_state])
+    ++txn->txn_state;
+  else
+    txn->txn_state = 0;
+
+  if (txn->inp_idx < txn->inp_len)
+    txn->inp_buf[txn->inp_idx++] = ch;
+  if (term[txn->txn_state] == 0) {
+    if (txn->inp_idx < txn->inp_len)
+      txn->inp_buf[txn->inp_idx] = '\0';
+    return AQU_POP_CMD;
+  }
+  return 1;
+}
+
+int defaultHandleEvent(pAsyncProtocol p, pAsyncTxn txn, int event) {
+  /* TODO: what could or should we do to handle the event */
+  return AQU_POP_CMD;
+}
+
+int defaultPrepareTxn(pAsyncProtocol p, pAsyncTxn txn, const char* cmd, int cmd_len, int rsp_len) {
+  int i;
+  int state;
+  const char *term = "\r\n";
+  if (p->sendTerminator)
+    term = p->sendTerminator;
+  state = 0;
+  for (i = 0; i < cmd_len; ++i) {
+    if (cmd[i] == 0x00) { /* end of transmission */
+      cmd_len = i;
+      break;
+    }
+    else if (cmd[i] == term[state]) {
+      ++state;
+      continue;
+    }
+    state = 0;
+  }
+  if (term[state] == 0) {
+    /* outgoing command is correctly terminated */
+    txn->out_buf = malloc(cmd_len + 1);
+    if (txn->out_buf == NULL) {
+      SICSLogWrite("Out of memory in AsyncProtocol::defaultPrepareTxn", eError);
+      return 0;
+    }
+    memcpy(txn->out_buf, cmd, cmd_len + 1);
+  }
+  else {
+    /* outgoing command is NOT correctly terminated */
+    int tlen = strlen(term);
+    txn->out_buf = malloc(cmd_len + tlen + 1);
+    if (txn->out_buf == NULL) {
+      SICSLogWrite("Out of memory in AsyncProtocol::defaultPrepareTxn", eError);
+      return 0;
+    }
+    memcpy(txn->out_buf, cmd, cmd_len);
+    memcpy(txn->out_buf + cmd_len, term, tlen + 1);
+    cmd_len += tlen;
+  }
+  txn->out_len = cmd_len;
+  txn->out_idx = 0;
+  txn->inp_buf = malloc(rsp_len);
+  if (txn->inp_buf == NULL) {
+    SICSLogWrite("Out of memory in AsyncProtocol::defaultPrepareTxn", eError);
+    free(txn->out_buf);
+    txn->out_buf = NULL;
+    return 0;
+  }
+  txn->inp_len = rsp_len;
+  txn->inp_idx = 0;
+  txn->txn_state = 0;
+  txn->txn_status = 0;
+  return 1;
+}
+
+static const char* hex = "0123456789ABCDEF";
+
+/*--------------------------------------------------------------------*/
+static void encodeTerminator(char *result, char *terminator)
+{
+  if (terminator)
+    while (*terminator) {
+      *result++ = '0';
+      *result++ = 'x';
+      *result++ = hex[(*terminator >> 4) &0xF];
+      *result++ = hex[(*terminator) &0xF];
+      ++terminator;
+    }
+  *result = '\0';
+  return;
+}
+
+static int fromHex(const char* code) {
+  int icode = -1;
+  int result = -1;
+  if (code[0] == '0' && (code[1] == 'x' || code[1] == 'X')) {
+    if (code[2] >= '0' && code[2] <= '9')
+      icode = (code[2] - '0');
+    else if (code[2] >= 'a' && code[2] <= 'f')
+      icode = 10 + (code[2] - 'a');
+    else if (code[2] >= 'A' && code[2] <= 'F')
+      icode = 10 + (code[2] - 'A');
+    if (icode < 0)
+      return -1;
+    result = icode << 4;
+    icode = -1;
+    if (code[3] >= '0' && code[3] <= '9')
+      icode = (code[3] - '0');
+    else if (code[3] >= 'a' && code[3] <= 'f')
+      icode = 10 + (code[3] - 'a');
+    else if (code[3] >= 'A' && code[3] <= 'F')
+      icode = 10 + (code[3] - 'A');
+    if (icode < 0)
+      return -1;
+    result |= icode;
+    return result;
+  }
+  return -1;
+}
+/*--------------------------------------------------------------------*/
+static char *decodeTerminator(char *code)
+{
+  int count = 0, icode;
+  char *pResult;
+  char* pCh;
+  char* pQt = NULL; /* pointer to quote character if found */
+
+  if (code == NULL)
+    return NULL;
+  count = strlen(code);
+  pResult = (char *) malloc(count + 1);
+  if (!pResult) {
+    SICSLogWrite("Out of memory in AsyncProtocol::decodeTerminator", eError);
+    return NULL;
+  }
+  memset(pResult, 0, count + 1);
+
+  pCh = pResult;
+  if (*code == '\'' || *code == '"') /* check for leading quote */
+    pQt = code++;
+
+  while (*code) {
+    if (pQt && *code == *pQt) /* check for trailing quote */
+      break;
+
+    if (code[0] == '\\' && code[1] == 'r') { /* CR */
+      *pCh++ = '\r';
+      code += 2;
+    }
+    else if (code[0] == '\\' && code[1] == 'n') { /* LF */
+      *pCh++ = '\n';
+      code += 2;
+    }
+    else if ((icode = fromHex(code)) >= 0) { /* Hex: 0xFF */
+      *pCh++ = icode;
+      code += 4;
+    }
+    else /* literal */
+      *pCh++ = *code++;
+  }
+  *pCh = '\0';
+
+  return pResult;
+}
+int AsyncProtocolNoAction(SConnection *pCon, SicsInterp *pSics,
+                        void *pData, int argc, char *argv[])
+{
+  char line[132];
+  pAsyncProtocol self = (pAsyncProtocol) pData;
+  snprintf(line, 132, "%s does not understand %s", argv[0], argv[1]);
+  SCWrite(pCon, line, eError);
+  return 0;
+}
+
+int AsyncProtocolAction(SConnection *pCon, SicsInterp *pSics,
+                        void *pData, int argc, char *argv[])
+{
+  char line[132];
+  pAsyncProtocol self = (pAsyncProtocol) pData;
+  if (argc > 1) {
+    /* handle genecic parameters like terminators */
+    if (strcasecmp(argv[1], "sendterminator") == 0) {
+      if (argc > 2) {
+        char* pPtr = decodeTerminator(argv[2]);
+        if (pPtr) {
+          if (self->sendTerminator)
+            free(self->sendTerminator);
+          self->sendTerminator = pPtr;
+        }
+        SCSendOK(pCon);
+      }
+      else
+      {
+        char term[132];
+        char line[1024];
+        encodeTerminator(term, self->sendTerminator);
+        sprintf(line, "%s.sendTerminator = \"%s\"", argv[0], term);
+        SCWrite(pCon, line, eValue);
+      }
+      return 1;
+    }
+    else if (strcasecmp(argv[1], "replyterminator") == 0) {
+      if (argc > 2) {
+        char* pPtr = decodeTerminator(argv[2]);
+        if (pPtr) {
+          if (self->replyTerminator)
+            free(self->replyTerminator);
+          self->replyTerminator = pPtr;
+        }
+        SCSendOK(pCon);
+      }
+      else
+      {
+        char term[132];
+        char line[1024];
+        encodeTerminator(term, self->replyTerminator);
+        sprintf(line, "%s.replyTerminator = \"%s\"", argv[0], term);
+        SCWrite(pCon, line, eValue);
+      }
+      return 1;
+    }
+  }
+  else if (strcasecmp(argv[1], "list") == 0) {
+    int ac = 2;
+    char* av[3] = { argv[0], 0, 0 };
+    av[1] = "sendterminator";
+    AsyncProtocolAction(pCon, pSics, pData, ac, av);
+    av[1] = "replyterminator";
+    AsyncProtocolAction(pCon, pSics, pData, ac, av);
+    return 1;
+  }
+  /* handle any other actions here */
+  return AsyncProtocolNoAction(pCon, pSics, pData, argc,argv);
+}
+
+void defaultKillPrivate(pAsyncProtocol p) {
+  if (p->privateData) {
+    /* TODO: should we do anything? */
+    free(p->privateData);
+  }
+}
+
+void AsyncProtocolKill(void *pData) {
+  pAsyncProtocol self = (pAsyncProtocol) pData;
+  if(self->pDes)
+    DeleteDescriptor(self->pDes);
+  if(self->sendTerminator != NULL)
+    free(self->sendTerminator);
+  if(self->replyTerminator != NULL)
+    free(self->replyTerminator);
+  if (self->killPrivate)
+    self->killPrivate(self);
+}
+
+pAsyncProtocol AsyncProtocolCreate(SicsInterp *pSics, const char* protocolName,
+    ObjectFunc pFunc, KillFunc pKFunc) {
+  int iRet;
+  pAsyncProtocol self = NULL;
+
+  /* try to find an existing queue with this name */
+  self = (pAsyncProtocol) FindCommandData(pServ->pSics,(char *)protocolName, "AsyncProtocol");
+  if (self != NULL) {
+    return self;
+  }
+
+  self = (pAsyncProtocol) malloc(sizeof(AsyncProtocol));
+  if (self == NULL) {
+    SICSLogWrite("Out of memory in AsyncProtocolCreate", eError);
+    return NULL;
+  }
+  memset(self, 0, sizeof(AsyncProtocol));
+  self->pDes = CreateDescriptor("AsyncProtocol");
+  if (pFunc == NULL)
+    pFunc = AsyncProtocolNoAction;
+  if (pKFunc == NULL)
+    pKFunc = AsyncProtocolKill;
+  iRet = AddCommand(pSics, (char *)protocolName, pFunc, pKFunc, self);
+  if (!iRet ) {
+    SICSLogWrite("AddCommand failed in AsyncProtocolCreate", eError);
+    AsyncProtocolKill(self);
+    return NULL;
+  }
+  self->sendCommand = defaultSendCommand;
+  self->handleInput = defaultHandleInput;
+  self->handleEvent = defaultHandleEvent;
+  self->prepareTxn = defaultPrepareTxn;
+  self->killPrivate = defaultKillPrivate;
+  self->sendTerminator = strdup("\r\n");
+  self->replyTerminator = strdup("\r\n");
+  return self;
+}
+
+int AsyncProtocolFactory(SConnection *pCon, SicsInterp *pSics,
+    void *pData, int argc, char *argv[]) {
+  if (argc < 2) {
+    SCWrite(pCon,"ERROR: insufficient arguments to AsyncProtocolFactory", eError);
+    return 0;
+  }
+  pAsyncProtocol pNew = AsyncProtocolCreate(pSics, argv[1],
+      AsyncProtocolAction, AsyncProtocolKill);
+  /* handle any extra arguments here */
+  pNew->privateData = NULL;
+  return 1;
+}
diff --git a/asyncprotocol.h b/asyncprotocol.h
new file mode 100644
index 00000000..2bf04d18
--- /dev/null
+++ b/asyncprotocol.h
@@ -0,0 +1,61 @@
+#ifndef ASYNCPROTOCOL
+#define ASYNCPROTOCOL
+
+typedef struct __AsyncUnit AsyncUnit, *pAsyncUnit;
+
+typedef struct __async_txn AsyncTxn, *pAsyncTxn;
+typedef int (*AsyncTxnHandler)(pAsyncTxn pTxn);
+
+typedef struct __async_protocol AsyncProtocol, *pAsyncProtocol;
+
+pAsyncProtocol AsyncProtocolCreate(SicsInterp *pSics, const char* protocolName,
+    ObjectFunc pFunc, KillFunc pKFunc);
+
+int AsyncProtocolAction(SConnection *pCon, SicsInterp *pSics,
+                        void *pData, int argc, char *argv[]);
+
+int AsyncProtocolFactory(SConnection *pCon, SicsInterp *pSics,
+    void *pData, int argc, char *argv[]);
+
+typedef enum {
+  ATX_NULL=0,
+  ATX_TIMEOUT=-1,
+  ATX_ACTIVE=1,
+  ATX_COMPLETE=2
+} ATX_STATUS;
+
+struct __async_txn {
+  pAsyncUnit  unit; /**< unit that transaction is associated with */
+  int         txn_state; /**< protocol handler transaction parse state */
+  ATX_STATUS  txn_status; /**< status of the transaction OK, Error, ... */
+  int         txn_timeout; /**< transaction timeout in milliseconds */
+  char*       out_buf; /**< output buffer for sendCommand */
+  int         out_len; /**< length of data to be sent */
+  int         out_idx; /**< index of next character to transmit */
+  char*       inp_buf; /**< input buffer for transaction response */
+  int         inp_len; /**< length of input buffer */
+  int         inp_idx; /**< index of next character (number already received) */
+  AsyncTxnHandler handleResponse; /**< Txn response handler of command sender */
+  void*       cntx; /**< opaque context used by command sender */
+  /* The cntx field may be used by protocol handler from sendCommand
+   * as long as it is restored when response is complete
+   */
+};
+
+/*
+ * The async protocol interface virtual function table
+ */
+struct __async_protocol {
+  pObjectDescriptor pDes;
+  char* protocolName;
+  char *sendTerminator;
+  char *replyTerminator;
+  void* privateData;
+  int (* sendCommand)(pAsyncProtocol p, pAsyncTxn txn);
+  int (* handleInput)(pAsyncProtocol p, pAsyncTxn txn, int ch);
+  int (* handleEvent)(pAsyncProtocol p, pAsyncTxn txn, int event);
+  int (* prepareTxn)(pAsyncProtocol p, pAsyncTxn txn, const char* cmd, int cmd_len, int rsp_len);
+  void (* killPrivate)(pAsyncProtocol p);
+};
+
+#endif /* ASYNCPROTOCOL */
diff --git a/asyncqueue.c b/asyncqueue.c
new file mode 100644
index 00000000..fe7254a6
--- /dev/null
+++ b/asyncqueue.c
@@ -0,0 +1,956 @@
+/*
+ * A S Y N C Q U E U E
+ *
+ * This module manages AsyncQueue communications.
+ *
+ * The AsyncQueue is an asynchronous queue between drivers and the device.  It
+ * supports multiple logical units on a single device controller that share a
+ * single command channel.
+ *
+ * Douglas Clowes, February 2007
+ *
+ */
+
+#include <sys/time.h>
+#include <arpa/inet.h>
+#include <netinet/tcp.h>
+#include <netdb.h>
+#include <sics.h>
+#include <rs232controller.h>
+#include "network.h"
+#include "asyncqueue.h"
+#include "nwatch.h"
+
+typedef struct __AsyncQueue AsyncQueue, *pAsyncQueue;
+
+typedef struct __async_command AQ_Cmd, *pAQ_Cmd;
+
+struct __async_command {
+  pAQ_Cmd     next;
+  pAsyncTxn   tran;
+  pAsyncUnit  unit;
+  int         timeout;
+  int         retries;
+  int         active;
+};
+
+struct __AsyncUnit {
+  pAsyncUnit  next;
+  pAsyncQueue queue;
+  AQU_Notify  notify_func;
+  void*       notify_cntx;
+};
+
+struct __AsyncQueue {
+  pObjectDescriptor pDes;
+  char*           queue_name;
+  char*           pHost;
+  int             iPort;
+  int             iDelay;       /* intercommand delay in milliseconds */
+  int             timeout;
+  int             retries;
+  struct timeval  tvLastCmd;    /* time of completion of last command */
+  int             unit_count;   /* number of units connected */
+  pAsyncUnit      units;        /* head of unit chain */
+  pAQ_Cmd         command_head; /* first/next command in queue */
+  pAQ_Cmd         command_tail; /* last command in queue */
+  pNWContext      nw_ctx;       /* NetWait context handle */
+  pNWTimer        nw_tmr;       /* NetWait timer handle */
+  mkChannel*      pSock;        /* socket address */
+  pAsyncProtocol  protocol;
+};
+
+static pAsyncQueue queue_array[FD_SETSIZE];
+static int queue_index = 0;
+
+/* ---------------------------- Local ------------------------------------
+     CreateSocketAdress stolen from Tcl. Thanks to John Ousterhout
+*/
+
+static int
+CreateSocketAdress(
+    struct sockaddr_in *sockaddrPtr,	/* Socket address */
+    char *host,				/* Host.  NULL implies INADDR_ANY */
+    int port)				/* Port number */
+{
+    struct hostent *hostent;		/* Host database entry */
+    struct in_addr addr;		/* For 64/32 bit madness */
+
+    (void) memset((char *) sockaddrPtr, '\0', sizeof(struct sockaddr_in));
+    sockaddrPtr->sin_family = AF_INET;
+    sockaddrPtr->sin_port = htons((unsigned short) (port & 0xFFFF));
+    if (host == NULL) {
+	addr.s_addr = INADDR_ANY;
+    } else {
+	hostent = gethostbyname(host);
+	if (hostent != NULL) {
+	    memcpy((char *) &addr,
+		(char *) hostent->h_addr_list[0], (size_t) hostent->h_length);
+	} else {
+	    addr.s_addr = inet_addr(host);
+	    if (addr.s_addr == (unsigned long)-1) {
+		return 0;	/* error */
+	    }
+	}
+    }
+    /*
+     * There is a rumor that this assignment may require care on
+     * some 64 bit machines.
+     */
+
+    sockaddrPtr->sin_addr.s_addr = addr.s_addr;
+    return 1;
+}
+
+static void AQ_Notify(pAsyncQueue self, int event)
+{
+  pAsyncUnit unit;
+  for (unit = self->units; unit; unit = unit->next)
+    if (unit->notify_func != NULL)
+      unit->notify_func(unit->notify_cntx, event);
+}
+
+static int AQ_Reconnect(pAsyncQueue self)
+{
+  int iRet;
+  int sock;
+  int flag = 1;
+  char line[132];
+
+  iRet = NETReconnect(self->pSock);
+  if (iRet <= 0) {
+    snprintf(line, 132, "Disconnect on AsyncQueue '%s'", self->queue_name);
+    SICSLogWrite(line, eStatus);
+    AQ_Notify(self, AQU_DISCONNECT);
+    return iRet;
+  }
+  snprintf(line, 132, "Reconnect on AsyncQueue '%s'", self->queue_name);
+  SICSLogWrite(line, eStatus);
+  AQ_Notify(self, AQU_RECONNECT);
+  return 1;
+}
+
+
+static int CommandTimeout(void* cntx, int mode);
+static int DelayedStart(void* cntx, int mode);
+
+static int StartCommand(pAsyncQueue self)
+{
+  pAQ_Cmd myCmd = self->command_head;
+  mkChannel* sock = self->pSock;
+
+  if (myCmd == NULL)
+    return OKOK;
+
+  /*
+   * Remove any old command timeout timer
+   */
+  if (self->nw_tmr)
+    NetWatchRemoveTimer(self->nw_tmr);
+
+  /*
+   * Implement the inter-command delay
+   */
+  if (self->iDelay) {
+    struct timeval now, when;
+    gettimeofday(&now, NULL);
+    if (self->tvLastCmd.tv_sec == 0)
+      self->tvLastCmd = now;
+    when.tv_sec = self->tvLastCmd.tv_sec;
+    when.tv_usec = self->tvLastCmd.tv_usec + 1000 * self->iDelay;
+    if (when.tv_usec >= 1000000) {
+      when.tv_sec += when.tv_usec / 1000000;
+      when.tv_usec %= 1000000;
+    }
+    if (when.tv_sec > now.tv_sec ||
+        (when.tv_sec == now.tv_sec && when.tv_usec > now.tv_usec)) {
+      int delay = when.tv_sec - now.tv_sec;
+      delay *= 1000;
+      delay += (when.tv_usec - now.tv_usec + (1000 - 1)) / 1000;
+      NetWatchRegisterTimer(&self->nw_tmr, delay,
+          DelayedStart, self);
+      return OKOK;
+    }
+  }
+
+  /*
+   * Discard any input before sending command
+   */
+  while (NETAvailable(sock, 0)) {
+    /* TODO: handle unsolicited input */
+    char reply[1];
+    int iRet;
+    iRet = NETRead(sock, reply, 1, 0);
+    if (iRet < 0) { /* EOF */
+      iRet = AQ_Reconnect(self);
+      if (iRet == 0)
+        return 0;
+    }
+  }
+  /*
+   * Add a new command timeout timer
+   */
+  if (myCmd->timeout > 0)
+    NetWatchRegisterTimer(&self->nw_tmr, myCmd->timeout,
+        CommandTimeout, self);
+  else
+    NetWatchRegisterTimer(&self->nw_tmr, 30000,
+        CommandTimeout, self);
+  myCmd->active = 1;
+  return self->protocol->sendCommand(self->protocol, myCmd->tran);
+}
+
+static int QueCommandHead(pAsyncQueue self, pAQ_Cmd cmd)
+{
+  cmd->next = NULL;
+  /*
+   * If the command queue is empty, start transmission
+   */
+  if (self->command_head == NULL) {
+    self->command_head = self->command_tail = cmd;
+    StartCommand(self);
+    return 1;
+  }
+  if (self->command_head->active) {
+    cmd->next = self->command_head->next;
+    self->command_head->next = cmd;
+  }
+  else {
+    cmd->next = self->command_head;
+    self->command_head = cmd;
+  }
+  if (cmd->next == NULL)
+    self->command_tail = cmd;
+  return 1;
+}
+
+static int QueCommand(pAsyncQueue self, pAQ_Cmd cmd)
+{
+  cmd->next = NULL;
+  /*
+   * If the command queue is empty, start transmission
+   */
+  if (self->command_head == NULL) {
+    self->command_head = self->command_tail = cmd;
+    StartCommand(self);
+    return 1;
+  }
+  self->command_tail->next = cmd;
+  self->command_tail = cmd;
+  return 1;
+}
+
+static int PopCommand(pAsyncQueue self)
+{
+  pAQ_Cmd myCmd = self->command_head;
+  if (self->nw_tmr)
+    NetWatchRemoveTimer(self->nw_tmr);
+  self->nw_tmr = 0;
+  gettimeofday(&self->tvLastCmd, NULL);
+  /*
+   * If this is not the last in queue, start transmission
+   */
+  if (myCmd->next) {
+    pAQ_Cmd pNew = myCmd->next;
+    self->command_head = pNew;
+    StartCommand(self);
+  }
+  else
+    self->command_head = self->command_tail = NULL;
+  free(myCmd->tran->out_buf);
+  free(myCmd->tran->inp_buf);
+  free(myCmd->tran);
+  free(myCmd);
+  return 1;
+}
+
+static int CommandTimeout(void* cntx, int mode)
+{
+  pAsyncQueue self = (pAsyncQueue) cntx;
+  pAQ_Cmd myCmd = self->command_head;
+  self->nw_tmr = 0;
+  if (myCmd->retries > 0) {
+    --myCmd->retries;
+    StartCommand(self);
+  }
+  else {
+    int iRet;
+    iRet = self->protocol->handleEvent(self->protocol, myCmd->tran, AQU_TIMEOUT);
+    if (iRet == AQU_POP_CMD) {
+      if (myCmd->tran->handleResponse)
+        myCmd->tran->handleResponse(myCmd->tran);
+      PopCommand(self); /* remove command */
+    }
+    else if (iRet == AQU_RETRY_CMD)
+      StartCommand(self); /* restart command */
+    else if (iRet == AQU_RECONNECT)
+      AQ_Reconnect(self);
+  }
+  return 1;
+}
+
+static int DelayedStart(void* cntx, int mode)
+{
+  pAsyncQueue self = (pAsyncQueue) cntx;
+  self->nw_tmr = 0;
+  StartCommand(self);
+  return 1;
+}
+
+static int MyCallback(void* context, int mode)
+{
+  pAsyncQueue self = (pAsyncQueue) context;
+
+  if (mode & nwatch_read) {
+    int iRet;
+    char reply[1];
+
+    iRet = NETRead(self->pSock, reply, 1, 0);
+    if (iRet < 0) { /* EOF */
+      iRet = AQ_Reconnect(self);
+      if (iRet <= 0)
+        return iRet;
+      /* restart the command */
+      StartCommand(self);
+      return 1;
+    }
+    if (iRet == 0) { /* TODO: timeout or error */
+      return 0;
+    } else {
+      pAQ_Cmd myCmd = self->command_head;
+      if (myCmd) {
+        iRet = self->protocol->handleInput(self->protocol, myCmd->tran, reply[0]);
+        if (iRet == 0 || iRet == AQU_POP_CMD) { /* end of command */
+          if (myCmd->tran->handleResponse)
+            myCmd->tran->handleResponse(myCmd->tran);
+          PopCommand(self);
+        }
+        else if (iRet < 0) /* TODO: error */
+          ;
+      }
+      else {
+        /* TODO: handle unsolicited input */
+      }
+    }
+  }
+  return 1;
+}
+
+int AsyncUnitEnqueHead(pAsyncUnit unit, pAsyncTxn context)
+{
+  pAQ_Cmd myCmd = NULL;
+
+  assert(unit && unit->queue && unit->queue->protocol);
+  myCmd = (pAQ_Cmd) malloc(sizeof(AQ_Cmd));
+  if (myCmd == NULL) {
+    SICSLogWrite("ERROR: Out of memory in AsyncUnitEnqueHead", eError);
+    return 0;
+  }
+  memset(myCmd, 0, sizeof(AQ_Cmd));
+  myCmd->tran = context;
+  myCmd->unit = unit;
+  myCmd->timeout = unit->queue->timeout;
+  myCmd->retries = unit->queue->retries;
+  myCmd->active = 0;
+  return QueCommandHead(unit->queue, myCmd);
+}
+
+int AsyncUnitEnqueueTxn(pAsyncUnit unit, pAsyncTxn pTxn)
+{
+  pAQ_Cmd myCmd = NULL;
+
+  assert(unit && unit->queue && unit->queue->protocol);
+  myCmd = (pAQ_Cmd) malloc(sizeof(AQ_Cmd));
+  if (myCmd == NULL) {
+    SICSLogWrite("ERROR: Out of memory in AsyncUnitEnqueueTxn", eError);
+    return 0;
+  }
+  memset(myCmd, 0, sizeof(AQ_Cmd));
+  myCmd->tran = pTxn;
+  myCmd->unit = unit;
+  myCmd->timeout = unit->queue->timeout;
+  myCmd->retries = unit->queue->retries;
+  myCmd->active = 0;
+  return QueCommand(unit->queue, myCmd);
+}
+
+pAsyncTxn AsyncUnitPrepareTxn(pAsyncUnit unit,
+    const char* command, int cmd_len,
+    AsyncTxnHandler callback, void* context,
+    int rsp_len)
+{
+  pAsyncTxn myTxn = NULL;
+
+  assert(unit);
+  myTxn = (pAsyncTxn) malloc(sizeof(AsyncTxn));
+  if (myTxn == NULL) {
+    SICSLogWrite("ERROR: Out of memory in AsyncUnitPrepareTxn", eError);
+    return 0;
+  }
+  memset(myTxn, 0, sizeof(AsyncTxn));
+  if (unit->queue->protocol->prepareTxn) {
+    int iRet;
+    iRet = unit->queue->protocol->prepareTxn(unit->queue->protocol, myTxn, command, cmd_len, rsp_len);
+  }
+  else {
+    myTxn->out_buf = (char*) malloc(cmd_len + 5);
+    if (myTxn->out_buf == NULL) {
+      SICSLogWrite("ERROR: Out of memory in AsyncUnitPrepareTxn", eError);
+      free(myTxn);
+      return 0;
+    }
+    memcpy(myTxn->out_buf, command, cmd_len);
+    myTxn->out_len = cmd_len;
+    if (myTxn->out_len < 2 ||
+        myTxn->out_buf[myTxn->out_len - 1] != 0x0A ||
+        myTxn->out_buf[myTxn->out_len - 2] != 0x0D) {
+      myTxn->out_buf[myTxn->out_len++] = 0x0D;
+      myTxn->out_buf[myTxn->out_len++] = 0x0A;
+    }
+    myTxn->out_buf[myTxn->out_len] = '\0';
+  }
+  if (rsp_len == 0)
+    myTxn->inp_buf = NULL;
+  else {
+    myTxn->inp_buf = malloc(rsp_len + 1);
+    if (myTxn->inp_buf == NULL) {
+      SICSLogWrite("ERROR: Out of memory in AsyncUnitPrepareTxn", eError);
+      free(myTxn->out_buf);
+      free(myTxn);
+      return 0;
+    }
+    memset(myTxn->inp_buf, 0, rsp_len + 1);
+  }
+  myTxn->inp_len = rsp_len;
+  myTxn->unit = unit;
+  myTxn->handleResponse = callback;
+  myTxn->cntx = context;
+  return myTxn;
+}
+
+int AsyncUnitSendTxn(pAsyncUnit unit,
+    const char* command, int cmd_len,
+    AsyncTxnHandler callback, void* context,
+    int rsp_len)
+{
+  pAsyncTxn myTxn = NULL;
+  myTxn = AsyncUnitPrepareTxn(unit, command, cmd_len,
+      callback, context, rsp_len);
+  if (myTxn == NULL)
+    return -1;
+  return AsyncUnitEnqueueTxn(unit, myTxn);
+}
+
+
+typedef struct txn_s {
+  char* transReply;
+  int transWait;
+} TXN, *pTXN;
+
+/**
+ * \brief TransCallback is the callback for the general command transaction.
+ */
+static int TransCallback(pAsyncTxn pCmd) {
+  char* resp = pCmd->inp_buf;
+  int resp_len = pCmd->inp_idx;
+  pTXN self = (pTXN) pCmd->cntx;
+
+  if (pCmd->txn_status == ATX_TIMEOUT) {
+    memcpy(self->transReply, resp, resp_len);
+    self->transReply[resp_len] = '\0';
+    self->transReply[0] = '\0';
+    self->transWait = -1;
+  }
+  else {
+    memcpy(self->transReply, resp, resp_len);
+    self->transReply[resp_len] = '\0';
+    self->transWait = 0;
+  }
+  return 0;
+}
+
+int AsyncUnitTransact(pAsyncUnit unit,
+    const char* command, int cmd_len,
+    char* response, int rsp_len)
+{
+  TXN txn;
+  assert(unit);
+  txn.transReply = response;
+  txn.transWait = 1;
+  AsyncUnitSendTxn(unit,
+      command, cmd_len,
+      TransCallback, &txn, rsp_len);
+  while (txn.transWait == 1)
+    TaskYield(pServ->pTasker);
+  if (txn.transWait < 0)
+    return txn.transWait;
+  return 1;
+}
+
+int AsyncUnitWrite(pAsyncUnit unit, void* buffer, int buflen)
+{
+  int iRet;
+  mkChannel* sock;
+  assert(unit);
+  assert(unit->queue);
+  if (buflen > 0) {
+    sock = AsyncUnitGetSocket(unit);
+    iRet = NETWrite(sock, buffer, buflen);
+    /* TODO handle errors */
+    if (iRet < 0) { /* EOF */
+      iRet = AQ_Reconnect(unit->queue);
+      if (iRet == 0)
+        return 0;
+    }
+  }
+  return 1;
+}
+
+void AsyncUnitSetNotify(pAsyncUnit unit, void* context, AQU_Notify notify)
+{
+  assert(unit);
+  unit->notify_func = notify;
+  unit->notify_cntx = context;
+}
+
+int AsyncUnitGetDelay(pAsyncUnit unit)
+{
+  assert(unit);
+  return unit->queue->iDelay;
+}
+
+void AsyncUnitSetDelay(pAsyncUnit unit, int iDelay)
+{
+  assert(unit);
+  unit->queue->iDelay = iDelay;
+}
+
+int AsyncUnitGetTimeout(pAsyncUnit unit)
+{
+  assert(unit);
+  return unit->queue->timeout;
+}
+
+void AsyncUnitSetTimeout(pAsyncUnit unit, int timeout)
+{
+  assert(unit);
+  unit->queue->timeout = timeout;
+}
+
+int AsyncUnitGetRetries(pAsyncUnit unit)
+{
+  assert(unit);
+  return unit->queue->retries;
+}
+
+void AsyncUnitSetRetries(pAsyncUnit unit, int retries)
+{
+  assert(unit);
+  unit->queue->retries = retries;
+}
+
+pAsyncProtocol AsyncUnitGetProtocol(pAsyncUnit unit)
+{
+  return unit->queue->protocol;
+}
+
+void AsyncUnitSetProtocol(pAsyncUnit unit, pAsyncProtocol protocol)
+{
+  unit->queue->protocol = protocol;
+}
+
+mkChannel* AsyncUnitGetSocket(pAsyncUnit unit)
+{
+  assert(unit);
+  assert(unit->queue);
+  return unit->queue->pSock;
+}
+
+int AsyncUnitReconnect(pAsyncUnit unit)
+{
+  int iRet;
+  assert(unit);
+  assert(unit->queue);
+  iRet = AQ_Reconnect(unit->queue);
+  /* TODO: handle in-progress */
+  return iRet;
+}
+
+int AsyncQueueAction(SConnection *pCon, SicsInterp *pSics,
+                        void *pData, int argc, char *argv[])
+{
+  char line[132];
+  pAsyncQueue self = (pAsyncQueue) pData;
+  if (argc > 1) {
+    if (strcasecmp("send", argv[1]) == 0) {
+      AsyncUnit myUnit;
+      char cmd[10240];
+      char rsp[10240];
+      int idx = 0;
+      int i, j;
+      cmd[0] = '\0';
+      for (i = 2; i < argc; ++i) {
+        j = snprintf(&cmd[idx], 10240 - idx, "%s%s",
+            (i > 2) ? " " : "",
+            argv[i]);
+        if (j < 0)
+          break;
+        idx += j;
+      }
+      memset(&myUnit, 0, sizeof(AsyncUnit));
+      myUnit.queue = self;
+      AsyncUnitTransact(&myUnit, cmd, idx, rsp, 10240);
+      SCWrite(pCon, rsp, eValue);
+      return 1;
+    }
+    if (strcasecmp(argv[1], "reconnect") == 0) {
+      AQ_Reconnect(self);
+      return OKOK;
+    }
+    if (strcasecmp(argv[1], "delay") == 0) {
+      if (argc > 2) {
+        int delay;
+        int iRet;
+        iRet = sscanf(argv[2], "%d", &delay);
+        if (iRet != 1) {
+          snprintf(line, 132, "Invalid argument: %s", argv[2]);
+          SCWrite(pCon, line, eError);
+          return 0;
+        }
+        else {
+          if (delay < 0 || delay > 30000) {
+            snprintf(line, 132, "Value out of range: %d", delay);
+            SCWrite(pCon, line, eError);
+            return 0;
+          }
+          self->iDelay = delay;
+          return OKOK;
+        }
+      }
+      else {
+        snprintf(line, 132, "%s.delay = %d", argv[0], self->iDelay);
+        SCWrite(pCon, line, eStatus);
+        return OKOK;
+      }
+      return OKOK;
+    }
+    if (strcasecmp(argv[1], "timeout") == 0) {
+      if (argc > 2) {
+        int timeout;
+        int iRet;
+        iRet = sscanf(argv[2], "%d", &timeout);
+        if (iRet != 1) {
+          snprintf(line, 132, "Invalid argument: %s", argv[2]);
+          SCWrite(pCon, line, eError);
+          return 0;
+        }
+        else {
+          if (timeout < 0 || timeout > 30000) {
+            snprintf(line, 132, "Value out of range: %d", timeout);
+            SCWrite(pCon, line, eError);
+            return 0;
+          }
+          self->timeout = timeout;
+          return OKOK;
+        }
+      }
+      else {
+        snprintf(line, 132, "%s.timeout = %d", argv[0], self->timeout);
+        SCWrite(pCon, line, eStatus);
+        return OKOK;
+      }
+      return OKOK;
+    }
+    if (strcasecmp(argv[1], "retries") == 0) {
+      if (argc > 2) {
+        int retries;
+        int iRet;
+        iRet = sscanf(argv[2], "%d", &retries);
+        if (iRet != 1) {
+          snprintf(line, 132, "Invalid argument: %s", argv[2]);
+          SCWrite(pCon, line, eError);
+          return 0;
+        }
+        else {
+          if (retries < 0 || retries > 30000) {
+            snprintf(line, 132, "Value out of range: %d", retries);
+            SCWrite(pCon, line, eError);
+            return 0;
+          }
+          self->retries = retries;
+          return OKOK;
+        }
+      }
+      else {
+        snprintf(line, 132, "%s.retries = %d", argv[0], self->retries);
+        SCWrite(pCon, line, eStatus);
+        return OKOK;
+      }
+      return OKOK;
+    }
+  }
+  snprintf(line, 132, "%s does not understand %s", argv[0], argv[1]);
+  SCWrite(pCon, line, eError);
+  return 0;
+}
+
+static pAsyncQueue AQ_Create(const char* host, const char* port)
+{
+  int i;
+  pAsyncQueue self = NULL;
+  mkChannel* channel = NULL;
+
+  if (host == NULL)
+    return NULL;
+
+  /* try the AsyncQueue with this name */
+  self = (pAsyncQueue) FindCommandData(pServ->pSics,(char *) host, "AsyncQueue");
+
+  /* try host and port */
+  if (self == NULL && port) {
+    int port_no = atoi(port);
+    if (port_no == 0) {
+      struct servent *sp=NULL;
+      sp = getservbyname(port, NULL);
+      if (sp)
+        port_no = ntohs(sp->s_port);
+    }
+    if (port_no > 0) {
+      struct sockaddr_in sa;
+      if (CreateSocketAdress(&sa,(char *) host, port_no)) {
+        /* look for queue with same address */
+        for (i = 0; i < queue_index; ++i)
+          if (queue_array[i]->pSock->adresse.sin_port == sa.sin_port
+              && queue_array[i]->pSock->adresse.sin_addr.s_addr == sa.sin_addr.s_addr) {
+            self = queue_array[i];
+            break;
+          }
+      }
+      if (self == NULL) {
+        channel = NETConnectWithFlags((char *)host, port_no, 0);
+        /* TODO handle asynchronous connection */
+      }
+    }
+  }
+
+  if (self == NULL) {
+    if (channel == NULL)
+      return NULL;
+
+    self = (pAsyncQueue) malloc(sizeof(AsyncQueue));
+    if (self == NULL)
+      return NULL;
+    memset(self, 0, sizeof(AsyncQueue));
+    self->pSock = channel;
+    self->pDes = CreateDescriptor("AsyncQueue");
+    queue_array[queue_index++] = self;
+  }
+
+  for (i = 0; i < queue_index; ++i)
+    if (queue_array[i] == self) {
+      break;
+    }
+  if (i == queue_index)
+    queue_array[queue_index++] = self;
+
+  return self;
+}
+
+static int AQ_Init(pAsyncQueue self)
+{
+  /* Init the controller */
+  if (self->nw_ctx == NULL)
+    NetWatchRegisterCallback(&self->nw_ctx,
+        self->pSock->sockid,
+        MyCallback,
+        self);
+  return 1;
+}
+
+static void AQ_Kill(void* pData)
+{
+  int i;
+  pAsyncQueue self = (pAsyncQueue) pData;
+  for (i = 0; i < queue_index; ++i)
+    if (queue_array[i] == self) {
+      --queue_index;
+      if (queue_index > 0)
+        queue_array[i] = queue_array[queue_index];
+      if (self->nw_ctx)
+        NetWatchRemoveCallback(self->nw_ctx);
+      if (self->nw_tmr)
+        NetWatchRemoveTimer(self->nw_tmr);
+      if (self->queue_name)
+        free(self->queue_name);
+      NETClosePort(self->pSock);
+      free(self->pSock);
+      DeleteDescriptor(self->pDes);
+      free(self);
+      return;
+    }
+}
+
+/*
+ * \brief make a AsyncQueue from the command line
+ *
+ * MakeAsyncQueue queueName protocolName hostName portname
+ */
+int AsyncQueueFactory(SConnection *pCon, SicsInterp *pSics,
+    void *pData, int argc, char *argv[])
+{
+  pAsyncQueue pNew = NULL;
+  mkChannel* channel = NULL;
+  pAsyncProtocol pPro = NULL;
+  int port_no;
+  int iRet = 0;
+
+  if (argc < 5) {
+    SCWrite(pCon,"ERROR: insufficient arguments to AsyncQueueFactory", eError);
+    return 0;
+  }
+
+  /* try to find an existing queue with this name */
+  pNew = (pAsyncQueue) FindCommandData(pServ->pSics, argv[1], "AsyncQueue");
+  if (pNew != NULL) {
+    char line[132];
+    snprintf(line, 132, "WARNING: AsyncQueue '%s' already exists", argv[1]);
+    SCWrite(pCon, line, eError);
+    SCSendOK(pCon);
+    return 1;
+  }
+
+  /* try to find an existing protocol with this name */
+  pPro = (pAsyncProtocol) FindCommandData(pServ->pSics, argv[2], "AsyncProtocol");
+  if (pPro == NULL) {
+    char line[132];
+    snprintf(line, 132, "WARNING: AsyncQueue protocol '%s' not found", argv[2]);
+    SCWrite(pCon, line, eError);
+    return 0;
+  }
+
+  port_no = atoi(argv[4]);
+  if (port_no == 0) {
+    struct servent *sp=NULL;
+    sp = getservbyname(argv[4], NULL);
+    if (sp)
+      port_no = ntohs(sp->s_port);
+  }
+  if (port_no > 0) {
+    struct sockaddr_in sa;
+    if (CreateSocketAdress(&sa, argv[3], port_no)) {
+      int i;
+      /* look for queue with same address */
+      for (i = 0; i < queue_index; ++i)
+        if (queue_array[i]->pSock->adresse.sin_port == sa.sin_port
+            && queue_array[i]->pSock->adresse.sin_addr.s_addr == sa.sin_addr.s_addr) {
+          char line[132];
+          snprintf(line, 132, "WARNING: AsyncQueue '%s' has same address as %s",
+              argv[1],
+              queue_array[i]->queue_name);
+          SCWrite(pCon, line, eError);
+        }
+      }
+    /* TODO: implement asynchronous connection */
+    channel = NETConnectWithFlags(argv[3], port_no, 0);
+    }
+
+  if (channel == NULL) {
+    char line[132];
+    snprintf(line, 132, "ERROR: AsyncQueue '%s' cannot connect", argv[1]);
+    SCWrite(pCon, line, eError);
+    return 0;
+  }
+
+  pNew = (pAsyncQueue) malloc(sizeof(AsyncQueue));
+  if (pNew == NULL) {
+    char line[132];
+    snprintf(line, 132, "ERROR: AsyncQueue '%s' memory failure", argv[1]);
+    SCWrite(pCon, line, eError);
+    return 0;
+  }
+
+  memset(pNew, 0, sizeof(AsyncQueue));
+  pNew->pDes = CreateDescriptor("AsyncQueue");
+  pNew->queue_name = strdup(argv[1]);
+  pNew->protocol = pPro;
+  pNew->pSock = channel;
+  queue_array[queue_index++] = pNew;
+
+  AQ_Init(pNew);
+  
+  /*
+    create the command
+  */
+  iRet = AddCommand(pSics, argv[1], AsyncQueueAction, AQ_Kill, pNew);
+  if(!iRet)
+  {
+    char line[132];
+    snprintf(line, 123, "ERROR: add command %s failed", argv[1]);
+    SCWrite(pCon, line, eError);
+    AQ_Kill(pNew);
+    return 0;
+  }
+  SCSendOK(pCon);
+  return 1;
+}
+
+/*
+ * \brief make a AsyncQueue from a named rs232 controller
+ *
+ * \param name the name of the SICS "RS232 Controller" object
+ * \param handle the handle to the AsyncQueue object
+ * \return 0 for FAILURE, 1 for SUCCESS
+ */
+int AsyncUnitCreateHost(const char* host, const char* port, pAsyncUnit* handle)
+{
+  int status;
+  pAsyncQueue self = NULL;
+  pAsyncUnit unit = NULL;
+
+  *handle = NULL;
+
+  self = AQ_Create(host, port);
+  if (self == NULL)
+    return 0;
+  status = AQ_Init(self);
+
+  unit = (pAsyncUnit) malloc(sizeof(AsyncUnit));
+  if (unit == NULL) {
+    SICSLogWrite("ERROR: Out of memory in AsyncUnitCreateHost", eError);
+    *handle = NULL;
+    return 0;
+  }
+  memset(unit, 0, sizeof(AsyncUnit));
+  ++self->unit_count;
+  unit->queue = self;
+  unit->next = self->units;
+  self->units = unit;
+  *handle = unit;
+  return 1;
+}
+
+int AsyncUnitCreate(const char* host, pAsyncUnit* handle) {
+  return AsyncUnitCreateHost(host, NULL, handle);
+}
+
+int AsyncUnitDestroy(pAsyncUnit unit)
+{
+  assert(unit);
+  assert(unit->queue);
+  pAsyncQueue self = unit->queue;
+  pAsyncUnit* pNxt = &self->units;
+  while (*pNxt) {
+    if (*pNxt == unit) {
+      *pNxt = (*pNxt)->next;
+      break;
+    }
+    pNxt = &(*pNxt)->next;
+  }
+  --self->unit_count;
+  if (self->unit_count <= 0) {
+    AQ_Kill(self);
+  }
+  free(unit);
+  return 1;
+}
+
diff --git a/asyncqueue.h b/asyncqueue.h
new file mode 100644
index 00000000..c066d284
--- /dev/null
+++ b/asyncqueue.h
@@ -0,0 +1,178 @@
+/*
+ * A S Y N C Q U E U E
+ *
+ * This module manages communications on an asynchronous connection.
+ *
+ * Douglas Clowes, May 2007
+ *
+ */
+#ifndef SICSASYNCQUEUE
+#define SICSASYNCQUEUE
+
+#include "asyncprotocol.h"
+
+#define AQU_TIMEOUT     -1
+#define AQU_DISCONNECT  -2
+#define AQU_RECONNECT   -3
+#define AQU_RETRY_CMD   -4
+#define AQU_POP_CMD     -5
+
+/** \brief create an AsyncUnit attached to a named AsyncQueue.
+ *
+ * \param queueName the name of the AsyncQueue to be used
+ * \param unit pointer to the AsyncUnit created on positive return
+ * \return positive if successful
+ */
+int AsyncUnitCreate(const char* queueName, pAsyncUnit* unit);
+
+/** \brief create an AsyncUnit attached to an anonymous AsyncQueue.
+ *
+ * \param host name or address of the target host
+ * \param port number or service name on the target host 
+ * \param unit pointer to the AsyncUnit created on positive return
+ * \return positive if successful
+ */
+int AsyncUnitCreateHost(const char* host,
+    const char* port,
+    pAsyncUnit* unit);
+
+/** \brief destroys an AsyncUnit
+ *
+ * \param unit pointer to the AsyncUnit to be destroyed
+ */
+int AsyncUnitDestroy(pAsyncUnit unit);
+
+/** \brief Queue a transaction at the head of the associated AsyncQueue
+ *
+ * \param unit AsyncUnit
+ * \param pTxn pointer to transaction
+ */
+int AsyncUnitEnqueueHead(pAsyncUnit unit, pAsyncTxn pTxn);
+
+/** \brief Queue a transaction at the tail of the associated AsyncQueue
+ *
+ * \param unit AsyncUnit
+ * \param pTxn pointer to transaction
+ */
+int AsyncUnitEnqueueTxn(pAsyncUnit unit, pAsyncTxn pTxn);
+
+/** \brief prepare a transaction according to the protocol (default is CRLF)
+ *
+ * \param unit AsyncUnit
+ * \param command text string to be sent
+ * \param cmd_len length of data in command
+ * \param responseHandler function to handle the response
+ * \param context to be used by handler function
+ * \param resp_len maximum length to be allowed for response
+ */
+pAsyncTxn AsyncUnitPrepareTxn(pAsyncUnit unit,
+    const char* command, int cmd_len,
+    AsyncTxnHandler responseHandler, void* context,
+    int rsp_len);
+
+/** \brief prepare and queue a transaction
+ *
+ * \param unit AsyncUnit
+ * \param command text string to be sent
+ * \param cmd_len length of data in command
+ * \param responseHandler function to handle the response
+ * \param context to be used by handler function
+ * \param resp_len maximum length to be allowed for response
+ */
+int AsyncUnitSendTxn(pAsyncUnit unit,
+    const char* command, int cmd_len,
+    AsyncTxnHandler responseHandler, void* context,
+    int rsp_len);
+
+/** \brief send a transaction and wait for the response
+ *
+ * \param unit AsyncUnit
+ * \param command text string to be sent
+ * \param cmd_len length of data in command
+ * \param responseHandler function to handle the response
+ * \param context to be used by handler function
+ * \param resp_len maximum length to be allowed for response
+ */
+int AsyncUnitTransact(pAsyncUnit unit,
+    const char* command, int cmd_len,
+    char* response, int rsp_len);
+
+/** \brief write to the AsyncQueue file descriptor
+ *
+ * The data is transmitted directly to the descriptor without being queued.
+ * This may be used by the protocol transmit function or for retrieving error
+ * text associated with the current transmission.
+ *
+ * \param unit AsyncUnit
+ * \param data to be transmitted
+ * \param buflen lenght of data
+ */
+int AsyncUnitWrite(pAsyncUnit unit, void* buffer, int buflen);
+
+/** \brief registers a notification callback
+ *
+ * The notification callback may notify unsolicited or unusual events
+ *
+ * \param unit AsyncUnit
+ * \param context passed in callback
+ * \param notify function to be called
+ */
+typedef void (*AQU_Notify)(void* context, int event);
+void AsyncUnitSetNotify(pAsyncUnit unit, void* context, AQU_Notify notify);
+
+/** \brief get the intertransaction delay in milliseconds
+ */
+int AsyncUnitGetDelay(pAsyncUnit unit);
+
+/** \brief set the intertransaction delay in milliseconds
+ */
+void AsyncUnitSetDelay(pAsyncUnit unit, int iDelay);
+
+/** \brief get the default transaction timeout in milliseconds
+ */
+int AsyncUnitGetTimeout(pAsyncUnit unit);
+
+/** \brief set the default transaction timeout in milliseconds
+ */
+void AsyncUnitSetTimeout(pAsyncUnit unit, int timeout);
+
+/** \brief get the number of retries
+ */
+int AsyncUnitGetRetries(pAsyncUnit unit);
+
+/** \brief set the number of retries
+ */
+void AsyncUnitSetRetries(pAsyncUnit unit, int retries);
+
+/** \brief get the associated protocol handler
+ */
+pAsyncProtocol AsyncUnitGetProtocol(pAsyncUnit unit);
+
+/** \brief set the associated protocol handler
+ */
+void AsyncUnitSetProtocol(pAsyncUnit unit, pAsyncProtocol protocol);
+
+/** \brief retrieves the socket/channel associated with the AsyncQueue
+ *
+ * \param unit AsyncUnit
+ * \return channel or NULL
+ */
+mkChannel* AsyncUnitGetSocket(pAsyncUnit unit);
+
+/** \brief attempt to reconnect the socket of the associated AsyncQueue
+ *
+ * \param unit pointer to AsyncUnit
+ */
+int AsyncUnitReconnect(pAsyncUnit handle);
+
+/** \brief create an AsyncQueue from the SICS command MakeAsyncQueue
+ */
+int AsyncQueueFactory(SConnection *pCon, SicsInterp *pSics,
+    void *pData, int argc, char *argv[]);
+
+/** \brief SICS command handler for the AsyncQueue object
+ */
+int AsyncQueueAction(SConnection *pCon, SicsInterp *pSics,
+                        void *pData, int argc, char *argv[]);
+
+#endif /* SICSASYNCQUEUE */
diff --git a/conman.c b/conman.c
index 1998b39a..056dc3f0 100644
--- a/conman.c
+++ b/conman.c
@@ -745,6 +745,94 @@ static void writeToLogFiles(SConnection *self, char *buffer)
      }      
      return 1;    
   }
+/*--------------------------------------------------------------------------*/
+  int SCACTWrite(SConnection *self, char *buffer, int iOut)
+  {
+       int i, iPtr, iRet;
+       char pBueffel[1024];
+       char *pPtr = pBueffel;
+       commandContext cx;
+       
+      if(!VerifyConnection(self))
+      {
+        return 0;
+      }
+
+      if (buffer[0] == '\0' && iOut >= eStart && iOut <= eEvent) {
+        return 1; /* do not write empty line */
+      }
+
+     /* log it for any case */
+       if(self->pSock)
+       { 
+         iRet = self->pSock->sockid;
+       }
+       else
+       {
+         iRet = 0;
+       } 
+       sprintf(pBueffel,"Next line intended for socket: %d",iRet);
+       SICSLogWrite(pBueffel,eInternal);
+       SICSLogWrite(buffer,iOut);
+       
+     /* write to commandlog if user or manager privilege */
+     if(SCGetRights(self) <= usUser)
+     {
+          if(self->iMacro != 1)
+          {
+              sprintf(pBueffel,"To sock %d :",iRet);
+              sendingConnection = self;
+              WriteToCommandLog(pBueffel,buffer);
+              sendingConnection = NULL;
+          } 
+          else 
+          {
+             if(iOut == eError || iOut == eWarning)
+             {
+               sprintf(pBueffel,"To sock %d :",iRet);
+               sendingConnection = self;
+               WriteToCommandLog(pBueffel,buffer);
+               sendingConnection = NULL;
+             }
+          }
+     }  
+     
+     /*
+      * copy in ACT
+      */
+     if(strlen(buffer) + 30 > 1024){
+        pPtr = (char *)malloc((strlen(buffer)+30)*sizeof(char));
+        memset(pPtr,0,strlen(buffer)+20);
+     } 
+     cx = SCGetContext(self); 
+     sprintf(pPtr,"%d::>%s<::", cx.transID, buffer);
+     
+     /* put it into the interpreter if present */
+     if(SCinMacro(self))
+     {
+       InterpWrite(pServ->pSics,buffer);
+       /* print it to client if error message */
+       if((iOut== eError) || (iOut == eWarning) )
+       {
+         iRet = doSockWrite(self,pPtr);
+       }
+     }
+     else /* not in interpreter, normal logic */
+     {
+       /* is this really to be printed ? */
+       if(iOut < self->iOutput)
+         return 0;
+      
+       /* first the socket */
+       iRet = doSockWrite(self,pPtr);
+
+       writeToLogFiles(self,buffer);
+     }      
+     if(pPtr != pBueffel){
+        free(pPtr);
+     }
+     return 1;    
+  }
 /*--------------------------------------------------------------------------*/
   int SCWriteWithOutcode(SConnection *self, char *buffer, int iOut)
   {
@@ -964,13 +1052,34 @@ pDynString SCEndBuffering(SConnection *pCon)
       /* put into Serverlog */
        sprintf(pBueffel,"Next line intended for socket: %d",-10);
        SICSLogWrite(pBueffel,eInternal);
+
        SICSLogWrite(buffer,iOut);
+     /* log it for any case */
+       if(self->pSock)
+       { 
+         iRet = self->pSock->sockid;
+       }
+       else
+       {
+         iRet = -10;
+       } 
 
      /* write to commandlog if user or manager privilege */
-     if(SCGetRights(self) <= usUser && self->iMacro != 1)
+     if(SCGetRights(self) <= usUser)
      {
-          sprintf(pBueffel,"To sock %d :",-10);
-          WriteToCommandLog(pBueffel,buffer);
+          if(self->iMacro != 1)
+          {
+              sprintf(pBueffel,"To sock %d :",iRet);
+              WriteToCommandLog(pBueffel,buffer);
+          } 
+          else 
+          {
+             if(iOut == eError || iOut == eWarning)
+             {
+               sprintf(pBueffel,"To sock %d :",iRet);
+               WriteToCommandLog(pBueffel,buffer);
+             }
+          }
      }  
      
      /* put it into the interpreter if present */
@@ -1494,7 +1603,7 @@ pDynString SCEndBuffering(SConnection *pCon)
       config OutCode val             sets an new output code
       config Rights  User Password   sets and verifies new user rights
       config File    Filename        Logs to another file
-      config output  normal | withcode Sets output mode
+      config output  normal | withcode | ACT Sets output mode
       config listen  0 | 1    enables commandlog listen mode
 ---------------------------------------------------------------------------*/
    
@@ -1633,6 +1742,10 @@ pDynString SCEndBuffering(SConnection *pCon)
          {
 	   SCSetWriteFunc(pCon,SCWriteWithOutcode);
          }
+     else if(strcmp(argv[2],"act") == 0)
+         {
+       SCSetWriteFunc(pCon,SCACTWrite);
+         }
 	 else
          {
 	   SCWrite(pCon,"ERROT: output mode not recognised",eError);
diff --git a/conman.h b/conman.h
index af9fd299..757dcbbb 100644
--- a/conman.h
+++ b/conman.h
@@ -123,6 +123,7 @@ typedef int (*writeFunc)(struct __SConnection *pCon,
   int SCNotWrite(SConnection *self, char *buffer, int iOut);
   int SCNormalWrite(SConnection *self, char *buffer, int iOut);
   int SCWriteWithOutcode(SConnection *self, char *buffer, int iOut);
+  int SCACTWrite(SConnection *self, char *buffer, int iOut);
 /*********************** I/O Buffering ***********************************/
   int SCStartBuffering(SConnection *pCon);
   pDynString SCEndBuffering(SConnection *pCon);
diff --git a/exeman.c b/exeman.c
index 177c8c2f..5ce0a74f 100644
--- a/exeman.c
+++ b/exeman.c
@@ -22,7 +22,9 @@
 #include "exebuf.h"
 #include "exeman.i"
 #include "exeman.h"
-
+#include "sicshipadaba.h"
+#include "commandlog.h"
+#include "protocol.h"
 /*-------------------------------------------------------------------*/
 static void KillExeMan(void *data){
   pExeMan self = (pExeMan)data;
@@ -252,6 +254,134 @@ static int runBatchBuffer(pExeMan self, SConnection *pCon,
   return status;
 } 
 /*-------------------------------------------------------------------*/
+static char bufferNode[512];
+
+static int SCHdbWrite(SConnection *self, char *message, int outCode){
+    pHdb node = NULL;
+    char pBueffel[512];
+    commandContext cc;
+    hdbValue v;
+    pDynString val = NULL;
+    writeFunc defWrite = NULL;
+    
+    
+    cc = SCGetContext(self);
+    node = GetHipadabaNode(GetHipadabaRoot(),cc.deviceID);
+    if(node == NULL || strstr(cc.deviceID,bufferNode) == NULL){
+      /*
+       * this means the deviceId is wrong and the output is for another 
+       * operation. 
+       */
+      defWrite = GetProtocolWriteFunc(self);
+      if(defWrite == NULL){
+        defWrite = SCNormalWrite;
+      } 
+      defWrite(self,message,outCode);  
+      return 1;
+    }
+
+    SCFileWrite(self,message,outCode);
+
+    if(SCinMacro(self) && (outCode != eError &&  outCode != eWarning) ){
+        return 1;
+    }
+    
+    v = MakeHdbText(strdup(""));
+    GetHipadabaPar(node,&v,NULL);
+    v.dataType = HIPTEXT;
+    val = CreateDynString(128,128);
+    if(val  == NULL){
+      WriteToCommandLog("INTERNAL ERROR>>",
+       "No memory to append to log in SCHdbWrite");   
+       return 0;
+    }
+    if(v.v.text != NULL){
+        DynStringConcat(val,v.v.text);
+        if(strrchr(v.v.text,(int)'\n') == NULL && strlen(v.v.text) > 2){
+            DynStringConcatChar(val,'\n');
+        }               
+    }
+    DynStringConcat(val,message);
+    if(strrchr(message,(int)'\n') == NULL && strlen(message) > 2){
+        DynStringConcatChar(val,'\n');
+    }               
+    if(v.v.text != NULL){
+        free(v.v.text);
+    }
+    v.v.text = GetCharArray(val);
+    UpdateHipadabaPar(node,v,NULL);
+    DeleteDynString(val);
+    return 1;
+}
+/*--------------------------------------------------------------------*/
+static int runHdbBuffer(pExeMan self, SConnection *pCon, 
+              SicsInterp *pSics, char *name){
+  char pBueffel[512];
+  pExeBuf buffer = NULL;
+  pHdb node = NULL;
+  hdbValue v;
+  int status;
+  commandContext cc;
+  writeFunc oldWrite;
+
+  if(!SCMatchRights(pCon,usUser)) {
+    return 0;
+  }
+  
+  /*
+   * clear log buffer
+   */
+  snprintf(pBueffel,511,"%s/log",name);
+  node = GetHipadabaNode(GetHipadabaRoot(),pBueffel);
+  if(node == NULL){
+    SCWrite(pCon,"ERROR: Hdb node not found or in wrong format",eError);
+    return 0;
+  }
+  v = MakeHdbText(strdup(""));
+  UpdateHipadabaPar(node,v,pCon);
+  /*
+   * prepare context
+   */
+  cc = SCGetContext(pCon);
+  strcpy(cc.deviceID, pBueffel);
+
+  /*
+   * load commands into buffer
+   */ 
+  snprintf(pBueffel,511,"%s/commands",name);
+  node = GetHipadabaNode(GetHipadabaRoot(),pBueffel);
+  if(node == NULL){
+    SCWrite(pCon,"ERROR: Hdb node not found or in wrong format",eError);
+    return 0;
+  }
+
+  GetHipadabaPar(node,&v,pCon);
+  if(v.dataType != HIPTEXT || v.v.text == NULL){
+    SCWrite(pCon,"ERROR: Hdb node is of wrong type or contains no data",eError);
+    return 0;
+    
+  }
+  
+  buffer = exeBufCreate(name);
+  if(!buffer){
+    SCWrite(pCon,"ERROR: out of memory creating batch buffer",eError);
+    return 0;
+  }
+  exeBufAppend(buffer,v.v.text);
+
+  strncpy(bufferNode,name,511);
+  oldWrite = SCGetWriteFunc(pCon);
+  SCSetWriteFunc(pCon,SCHdbWrite);
+  SCPushContext2(pCon,cc);
+  self->exeStackPtr++;
+  DynarPut(self->exeStack,self->exeStackPtr,buffer);
+  status = exeBufProcess(buffer,pSics,pCon,self->pCall,self->echo);
+  self->exeStackPtr--;
+  SCSetWriteFunc(pCon,oldWrite);
+  SCPopContext(pCon);
+  return status;
+} 
+/*-------------------------------------------------------------------*/
 int runExeBatchBuffer(void *pData, SConnection *pCon, 
               SicsInterp *pSics, char *name){
   int status, oldEcho;              
@@ -1090,10 +1220,20 @@ int ExeManagerWrapper(SConnection *pCon, SicsInterp *pSics, void *pData,
         SCPrintf(pCon, eValue, "exe echo = %d", self->echo);
       }
       return 1;
+    }else if(strcmp(argv[1],"runhdb") == 0){
+      if (argc < 2) {
+        SCWrite(pCon,"ERROR: require path to root of queue node",eError);
+        SCSendOK(pCon);
+      } 
+      status = runHdbBuffer(self,pCon,pSics,argv[2]);
+      if(self->exeStackPtr < 0){
+        SCWrite(pCon,"EXE TERMINATED",eWarning);
+      }
+      return status;
     } else {
       status = runBatchBuffer(self,pCon,pSics,pBufferName);
       if(self->exeStackPtr < 0){
-	SCWrite(pCon,"EXE TERMINATED",eWarning);
+    SCWrite(pCon,"EXE TERMINATED",eWarning);
       }
       return status;
     }
diff --git a/make_gen b/make_gen
index 2b55a90c..7dc548a9 100644
--- a/make_gen
+++ b/make_gen
@@ -32,7 +32,8 @@ SOBJ =  network.o ifile.o conman.o SCinter.o splitter.o passwd.o \
        mcstashm.o initializer.o remob.o tclmotdriv.o protocol.o \
        sinfox.o sicslist.o cone.o hipadaba.o sicshipadaba.o statistics.o \
        moregress.o hdbcommand.o multicounter.o regresscter.o histregress.o \
-       sicshdbadapter.o polldriv.o sicspoll.o statemon.o hmslave.o 
+       sicshdbadapter.o polldriv.o sicspoll.o statemon.o hmslave.o \
+       nwatch.o asyncqueue.o asyncprotocol.o 
  
 MOTOROBJ = motor.o  simdriv.o  
 COUNTEROBJ =  countdriv.o simcter.o counter.o
diff --git a/motor.c b/motor.c
index 83795a21..3258b07a 100644
--- a/motor.c
+++ b/motor.c
@@ -171,8 +171,10 @@
      fputs(pBueffel,fd);
      sprintf(pBueffel,"%s AccessCode %f\n",name,ObVal(self->ParArray,USRIGHTS));
      fputs(pBueffel,fd);
-     sprintf(pBueffel,"%s poscount %f\n",name,
-	     ObVal(self->ParArray,POSCOUNT));
+     sprintf(pBueffel,"%s failafter %f\n",name,ObVal(self->ParArray,ECOUNT));
+     fputs(pBueffel,fd);
+     sprintf(pBueffel,"%s maxretry %f\n",name,ObVal(self->ParArray,POSCOUNT));
+     fputs(pBueffel,fd);
      sprintf(pBueffel,"%s movecount %f\n",name,
 	     ObVal(self->ParArray,MOVECOUNT));
      fputs(pBueffel,fd);
diff --git a/napi.h b/napi.h
index f27b05b7..1195de07 100644
--- a/napi.h
+++ b/napi.h
@@ -21,7 +21,7 @@
  
   For further information, see <http://www.neutron.anl.gov/NeXus/>
   
-  $Id: napi.h,v 1.10 2006/03/03 15:30:55 koennecke Exp $
+  $Id: napi.h,v 1.11 2007/06/22 11:44:47 koennecke Exp $
 
  ----------------------------------------------------------------------------*/
   
@@ -117,6 +117,7 @@ typedef struct {
                 char iRef5[1024];     /* HDF5 variable */
                 char iRefd[1024];     /* HDF5 variable */
                 char targetPath[1024]; /* XML path */
+                int linkType;
                } NXlink;
 
 #define NXMAXSTACK 50
diff --git a/napi5.c b/napi5.c
index dafc3a59..3e087125 100644
--- a/napi5.c
+++ b/napi5.c
@@ -3,7 +3,7 @@
   
   Application Program Interface (HDF5) Routines
   
-  Copyright (C) 1997-2002 Mark Koennecke, Przemek Klosowski
+  Copyright (C) 1997-2006 Mark Koennecke, Przemek Klosowski
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -30,18 +30,17 @@
 #include "napi.h"
 #include "napi5.h"
 
+#define NX_UNKNOWN_GROUP "" /* for when no NX_class attr */
+
 extern  void *NXpData;
 
   typedef struct __NexusFile5 {
         struct iStack5 {
-          int *iRefDir;
-          int *iTagDir;
           char irefn[1024];
           int iVref;
           int iCurrentIDX;
         } iStack5[NXMAXSTACK];
         struct iStack5 iAtt5;
-        int iVID;
         int iFID;
         int iCurrentG;
         int iCurrentD;
@@ -82,14 +81,6 @@ static void ignoreError(void *data, char *text){
 
    static void NXI5KillDir (pNexusFile5 self)
   {
-    if (self->iStack5[self->iStackPtr].iRefDir) {
-      free (self->iStack5[self->iStackPtr].iRefDir);
-      self->iStack5[self->iStackPtr].iRefDir = NULL;
-    }
-    if (self->iStack5[self->iStackPtr].iTagDir) {
-      free (self->iStack5[self->iStackPtr].iTagDir);
-      self->iStack5[self->iStackPtr].iTagDir = NULL;
-    }
     self->iStack5[self->iStackPtr].iCurrentIDX = 0;
   }
   
@@ -97,17 +88,26 @@ static void ignoreError(void *data, char *text){
 
   static void NXI5KillAttDir (pNexusFile5 self)
   {
-    if (self->iAtt5.iRefDir) {
-      free (self->iAtt5.iRefDir);
-      self->iAtt5.iRefDir = NULL;
-    }
-    if (self->iAtt5.iTagDir) {
-      free (self->iAtt5.iTagDir);
-      self->iAtt5.iTagDir = NULL;
-    }
     self->iAtt5.iCurrentIDX = 0;
   }
+/*---------------------------------------------------------------------*/
+static void buildCurrentPath(pNexusFile5 self, char *pathBuffer, 
+			     int pathBufferLen){
 
+  memset(pathBuffer,0,pathBufferLen);
+  if(self->iCurrentG != 0) {
+    strcpy(pathBuffer,"/");
+    if(strlen(self->name_ref) + 1 < pathBufferLen){
+      strcat(pathBuffer, self->name_ref);
+    }
+  }
+  if(self->iCurrentD != 0){
+    strcat(pathBuffer,"/");
+    if(strlen(self->iCurrentLD) + strlen(pathBuffer) < pathBufferLen){
+      strcat(pathBuffer,self->iCurrentLD);
+    }
+  }
+}
   /* ---------------------------------------------------------------------- 
   
                           Definition of NeXus API
@@ -117,14 +117,14 @@ static void ignoreError(void *data, char *text){
   NXstatus  NX5open(CONSTCHAR *filename, NXaccess am, 
 				 NXhandle* pHandle)
   {
-  hid_t attr1,aid1, aid2;
+  hid_t attr1,aid1, aid2, iVID;
   pNexusFile5 pNew = NULL;
   char pBuffer[512];
-  char *time_buffer;
+  char *time_buffer = NULL;
   char version_nr[10];
   int iRet;
   unsigned int vers_major, vers_minor, vers_release, am1 ;
-  hid_t fapl;     
+  hid_t fapl = -1;     
   int mdc_nelmts;
 #ifdef H5_WANT_H5_V1_4_COMPAT
   int rdcc_nelmts;
@@ -149,7 +149,6 @@ static void ignoreError(void *data, char *text){
     }
     memset (pNew, 0, sizeof (NexusFile5));
 
-    time_buffer = NXIformatNeXusTime();
 
     /* start HDF5 interface */
     if (am == NXACC_CREATE5) {  
@@ -181,6 +180,9 @@ static void ignoreError(void *data, char *text){
       free (pNew);
       return NX_ERROR;
     }
+    if(fapl != -1) {
+      H5Pclose(fapl);
+    }
 
 /*
  * need to create global attributes         file_name file_time NeXus_version 
@@ -188,15 +190,15 @@ static void ignoreError(void *data, char *text){
  */
     if (am1 != H5F_ACC_RDONLY) 
     {
-        pNew->iVID=H5Gopen(pNew->iFID,"/");
+        iVID=H5Gopen(pNew->iFID,"/");
         aid2 = H5Screate(H5S_SCALAR);
         aid1 = H5Tcopy(H5T_C_S1);
         H5Tset_size(aid1, strlen(NEXUS_VERSION));
         if (am1 == H5F_ACC_RDWR)
         {
-        H5Adelete(pNew->iVID, "NeXus_version"); 
+        H5Adelete(iVID, "NeXus_version"); 
         }
-        attr1= H5Acreate(pNew->iVID, "NeXus_version", aid1, aid2, H5P_DEFAULT);
+        attr1= H5Acreate(iVID, "NeXus_version", aid1, aid2, H5P_DEFAULT);
         if (attr1<0)
         {
           NXIReportError (NXpData, 
@@ -214,15 +216,15 @@ static void ignoreError(void *data, char *text){
        iRet = H5Sclose(aid2); 
        /* Close attribute */
        iRet = H5Aclose(attr1); 
-       H5Gclose(pNew->iVID); 
+       H5Gclose(iVID); 
     }
     if (am1 == H5F_ACC_TRUNC) 
     {
-        pNew->iVID=H5Gopen(pNew->iFID,"/");
+        iVID=H5Gopen(pNew->iFID,"/");
         aid2=H5Screate(H5S_SCALAR);
         aid1 = H5Tcopy(H5T_C_S1);
         H5Tset_size(aid1, strlen(filename));
-        attr1= H5Acreate(pNew->iVID, "file_name", aid1, aid2, H5P_DEFAULT);
+        attr1= H5Acreate(iVID, "file_name", aid1, aid2, H5P_DEFAULT);
         if (attr1 < 0)
         {
           NXIReportError (NXpData, 
@@ -244,7 +246,7 @@ static void ignoreError(void *data, char *text){
         aid2=H5Screate(H5S_SCALAR);
         aid1 = H5Tcopy(H5T_C_S1);
         H5Tset_size(aid1, strlen(version_nr));
-        attr1= H5Acreate(pNew->iVID, "HDF5_Version", aid1, aid2, H5P_DEFAULT);
+        attr1= H5Acreate(iVID, "HDF5_Version", aid1, aid2, H5P_DEFAULT);
         if (attr1 < 0)
         {
           NXIReportError (NXpData, 
@@ -261,11 +263,12 @@ static void ignoreError(void *data, char *text){
 	iRet = H5Sclose(aid2); 
         iRet = H5Aclose(attr1);
 	/*----------- file time */
+	time_buffer = NXIformatNeXusTime();
 	if(time_buffer != NULL){
 	  aid2=H5Screate(H5S_SCALAR);
 	  aid1 = H5Tcopy(H5T_C_S1);
 	  H5Tset_size(aid1, strlen(time_buffer));
-	  attr1=H5Acreate(pNew->iVID, "file_time", aid1, aid2, H5P_DEFAULT);
+	  attr1=H5Acreate(iVID, "file_time", aid1, aid2, H5P_DEFAULT);
 	  if (attr1 < 0)
 	  {
 	      NXIReportError (NXpData, 
@@ -287,7 +290,7 @@ static void ignoreError(void *data, char *text){
 	  iRet = H5Aclose(attr1); 
 	  free(time_buffer);
 	}
-	H5Gclose(pNew->iVID); 
+	H5Gclose(iVID); 
     }
     /* Set HDFgroup access mode */
     if (am1 == H5F_ACC_RDONLY) {
@@ -316,9 +319,9 @@ static void ignoreError(void *data, char *text){
 	   H5Fget_obj_count(pFile->iFID,H5F_OBJ_ALL));
     */
     iRet = H5Fclose(pFile->iFID);
-   
-    /*
-      Please leave this here, it helps debugging HDF5 resource leakages
+
+    /* 
+      leave this here: it helps in debugging leakage problems   
     printf("HDF5 object count after close: %d\n",
 	   H5Fget_obj_count(H5F_OBJ_ALL,H5F_OBJ_ALL));
     printf("HDF5 dataset count after close: %d\n",
@@ -353,7 +356,7 @@ static void ignoreError(void *data, char *text){
   NXstatus  NX5makegroup (NXhandle fid, CONSTCHAR *name, CONSTCHAR *nxclass) 
   {
     pNexusFile5 pFile;
-    hid_t iRet;
+    hid_t iRet, iVID;
     hid_t attr1,aid1, aid2;
     char pBuffer[1024] = "";
     
@@ -372,12 +375,12 @@ static void ignoreError(void *data, char *text){
       NXIReportError (NXpData, "ERROR: HDF could not create Group");
       return NX_ERROR;
     }
-    pFile->iVID = iRet;
+    iVID = iRet;
     strncpy(pFile->name_ref,pBuffer,1023);
     aid2 = H5Screate(H5S_SCALAR);
     aid1 = H5Tcopy(H5T_C_S1);
     H5Tset_size(aid1, strlen(nxclass));
-    attr1= H5Acreate(pFile->iVID, "NX_class", aid1, aid2, H5P_DEFAULT);
+    attr1= H5Acreate(iVID, "NX_class", aid1, aid2, H5P_DEFAULT);
     if (attr1 < 0)
        {
        NXIReportError (NXpData, "ERROR: HDF failed to store class name!");
@@ -392,7 +395,7 @@ static void ignoreError(void *data, char *text){
     iRet=H5Sclose(aid2);
     iRet=H5Tclose(aid1);
     iRet=H5Aclose(attr1);
-    iRet=H5Gclose(pFile->iVID);
+    iRet=H5Gclose(iVID);
     return NX_OK;
   }
   
@@ -405,7 +408,7 @@ static void ignoreError(void *data, char *text){
     strcpy(attr_name,"NX_class");
     return strstr(member_name, attr_name) ? 1 : 0;
   }
-
+  /*------------------------------------------------------------------------*/
   NXstatus  NX5opengroup (NXhandle fid, CONSTCHAR *name, CONSTCHAR *nxclass)
   {
 
@@ -417,93 +420,59 @@ static void ignoreError(void *data, char *text){
     pFile = NXI5assert (fid);
     if (pFile->iCurrentG == 0)
     {
-       iRet = H5Gopen (pFile->iFID, (const char *)name);
-       if (iRet < 0) {
-          sprintf (pBuffer, "ERROR: Group %s does not exist!", name);
-          NXIReportError (NXpData, pBuffer);
-          return NX_ERROR;  
-       }
-       pFile->iCurrentG = iRet;
-       /* check group attribute */
-       iRet = H5Aiterate(pFile->iCurrentG,NULL,attr_check,NULL);
-       if (iRet < 0) {
-          NXIReportError (NXpData, "ERROR iterating through group!");
-          return NX_ERROR;  
-       } else if (iRet == 1) {
-         /* group attribute was found */
-       } else {
-         /* no group attribute available */
-         NXIReportError (NXpData, "No group attribute available");
-         return NX_ERROR;
-       }
-       /* check contents of group attribute */
-       attr1 = H5Aopen_name(pFile->iCurrentG, "NX_class");
-       if (attr1 < 0)
-       {
-          NXIReportError (NXpData, "Error opening group attribute!");
-          return NX_ERROR; 
-       }
-       atype=H5Tcopy(H5T_C_S1);
-       H5Tset_size(atype,128);  
-       iRet = H5Aread(attr1, atype, data);
-       if (strcmp(data, nxclass) == 0) {
-          /* test OK */
-       } else {
-          NXIReportError (NXpData, "Group class is not identical!");
-          iRet = H5Tclose(atype);
-          iRet = H5Aclose(attr1); 
-          return NX_ERROR; 
-       }          
-       iRet = H5Tclose(atype);
-       iRet = H5Aclose(attr1); 
-       pFile->iStack5[pFile->iStackPtr].iVref=0;
-       strcpy(pFile->iStack5[pFile->iStackPtr].irefn,"");
-       strcpy(pFile->name_ref,name);
-       strcpy(pFile->name_tmp,name);
-    } else {
+      strcpy(pBuffer,name);
+    } 
+    else 
+    {
        sprintf(pBuffer,"%s/%s",pFile->name_tmp,name);
-       iRet = H5Gopen (pFile->iFID,(const char *)pBuffer);
-       if (iRet < 0) {
-          sprintf (pBuffer, "ERROR: Group %s does not exist!", pFile->name_tmp);
-          NXIReportError (NXpData, pBuffer);
-          return NX_ERROR;  
-       }
-       pFile->iCurrentG = iRet;
-       strcpy(pFile->name_tmp,pBuffer);
-       strcpy(pFile->name_ref,pBuffer);
-       /* check group attribute */
-       iRet=H5Aiterate(pFile->iCurrentG,NULL,attr_check,NULL);
-       if (iRet < 0) {
+    }
+    iRet = H5Gopen (pFile->iFID,(const char *)pBuffer);
+    if (iRet < 0) {
+      sprintf (pBuffer, "ERROR: Group %s does not exist!", pFile->name_tmp);
+      NXIReportError (NXpData, pBuffer);
+      return NX_ERROR;  
+    }
+    pFile->iCurrentG = iRet;
+    strcpy(pFile->name_tmp,pBuffer);
+    strcpy(pFile->name_ref,pBuffer);
+
+    if ((nxclass != NULL) && (strcmp(nxclass, NX_UNKNOWN_GROUP) != 0))
+    {
+        /* check group attribute */
+        iRet=H5Aiterate(pFile->iCurrentG,NULL,attr_check,NULL);
+        if (iRet < 0) {
           NXIReportError (NXpData, "ERROR iterating through group!");
           return NX_ERROR;  
-       } else if (iRet == 1) {
+        } else if (iRet == 1) {
          /* group attribute was found */
-       } else {
+        } else {
          /* no group attribute available */
          NXIReportError (NXpData, "No group attribute available");
          return NX_ERROR;
-       }
-       /* check contains of group attribute */
-       attr1 = H5Aopen_name(pFile->iCurrentG, "NX_class");
-       if (attr1 < 0)
-       {
-          NXIReportError (NXpData, "Error opening group attribute!");
-          return NX_ERROR; 
-       }
-       atype=H5Tcopy(H5T_C_S1);
-       H5Tset_size(atype,128);  
-       iRet = H5Aread(attr1, atype, data);
-       if (strcmp(data, nxclass) == 0) {
-          /* test OK */
-       } else {
-          NXIReportError (NXpData, "Group class is not identical!");
-          iRet = H5Tclose(atype);
-          iRet = H5Aclose(attr1); 
-          return NX_ERROR; 
-       }          
-       iRet = H5Tclose(atype);
-       iRet = H5Aclose(attr1); 
+        }
+        /* check contents of group attribute */
+        attr1 = H5Aopen_name(pFile->iCurrentG, "NX_class");
+        if (attr1 < 0)
+        {
+              NXIReportError (NXpData, "Error opening NX_class group attribute!");
+              return NX_ERROR; 
+        }
+        atype=H5Tcopy(H5T_C_S1);
+        H5Tset_size(atype,128);  
+        iRet = H5Aread(attr1, atype, data);
+        if (strcmp(data, nxclass) == 0) {
+              /* test OK */
+        } else {
+              NXIReportError (NXpData, "Group class is not identical!");
+              iRet = H5Tclose(atype);
+              iRet = H5Aclose(attr1); 
+              return NX_ERROR; 
+        }          
+        iRet = H5Tclose(atype);
+        iRet = H5Aclose(attr1); 
     }
+
+    /* maintain stack */
     pFile->iStackPtr++;
     pFile->iStack5[pFile->iStackPtr].iVref=pFile->iCurrentG;
     strcpy(pFile->iStack5[pFile->iStackPtr].irefn,name);
@@ -573,30 +542,10 @@ static void ignoreError(void *data, char *text){
     }
     return NX_OK;
   }
-  
- /* --------------------------------------------------------------------- */
-
-  NXstatus  NX5compmakedata (NXhandle fid, CONSTCHAR *name, 
-					  int datatype, 
-					  int rank, int dimensions[],
-					  int compress_type, int chunk_size[])
-  {
-    hid_t datatype1, dataspace, iNew, iRet;
-    hid_t type,cparms;
-    pNexusFile5 pFile;
-    char pBuffer[256];
-    int i, byte_zahl;
-    hsize_t chunkdims[H5S_MAX_RANK];
-    hsize_t mydim[H5S_MAX_RANK], mydim1[H5S_MAX_RANK];  
-    hsize_t size[H5S_MAX_RANK];
-    hsize_t maxdims[H5S_MAX_RANK];
-
-    pFile = NXI5assert (fid);
-  
-    for (i = 0; i < rank; i++)
-       {
-         chunkdims[i]=chunk_size[i];
-       }   
+/*-----------------------------------------------------------------------*/
+static int nxToHDF5Type(int datatype)
+{
+  int type;
     if (datatype == NX_CHAR)
     {
         type=H5T_C_S1;
@@ -633,6 +582,43 @@ static void ignoreError(void *data, char *text){
     {
         type=H5T_NATIVE_DOUBLE;
     }
+    else
+    {
+      NXIReportError (NXpData, "ERROR: nxToHDF5Type: unknown type");
+      type = -1;
+    }
+    return type;
+}
+  
+ /* --------------------------------------------------------------------- */
+
+  NXstatus  NX5compmakedata (NXhandle fid, CONSTCHAR *name, 
+					  int datatype, 
+					  int rank, int dimensions[],
+					  int compress_type, int chunk_size[])
+  {
+    hid_t datatype1, dataspace, iNew, iRet;
+    hid_t type, cparms = -1;
+    pNexusFile5 pFile;
+    char pBuffer[256];
+    int i, byte_zahl = 0;
+    hsize_t chunkdims[H5S_MAX_RANK];
+    hsize_t mydim[H5S_MAX_RANK], mydim1[H5S_MAX_RANK];  
+    hsize_t size[H5S_MAX_RANK];
+    hsize_t maxdims[H5S_MAX_RANK];
+
+    pFile = NXI5assert (fid);
+  
+    for (i = 0; i < rank; i++)
+       {
+         chunkdims[i]=chunk_size[i];
+         mydim[i] = dimensions[i];
+         maxdims[i] = dimensions[i];
+         size[i] = dimensions[i];
+       }   
+
+    type = nxToHDF5Type(datatype);
+
     if (rank <= 0) {
       sprintf (pBuffer, "ERROR: invalid rank specified %s",
                name);
@@ -640,7 +626,7 @@ static void ignoreError(void *data, char *text){
       return NX_ERROR;
     }
     /*
-      Check dimensions for consistency. The first dimension may be 0
+      Check dimensions for consistency. The first dimension may be -1
       thus denoting an unlimited dimension.
     */
     for (i = 1; i < rank; i++) {
@@ -651,30 +637,30 @@ static void ignoreError(void *data, char *text){
         NXIReportError (NXpData, pBuffer);
         return NX_ERROR;
       }
-      mydim[i] = dimensions[i];
-      maxdims[i] = dimensions[i];
     }
     if (datatype == NX_CHAR)
     {
-      byte_zahl=dimensions[0]; 
-      dimensions[0]=rank;
+/* 
+ *  This assumes string lenght is in the last dimensions and
+ *  the logic must be the same as used in NX5getglab and NX5getinfo
+ *
+ *  search for tests on H5T_STRING
+ */
+      byte_zahl=dimensions[rank-1]; 
+      dimensions[rank-1]=1;
       for(i = 0; i < rank; i++)
          {
          mydim1[i] = dimensions[i];
          }
-      dimensions[0] = byte_zahl;
+      dimensions[rank-1] = byte_zahl;
          dataspace=H5Screate_simple(rank,mydim1,NULL);
     } else {
       if (dimensions[0] == NX_UNLIMITED)
       {
-        mydim[0]=1;
+        mydim[0] = 1;
         maxdims[0] = H5S_UNLIMITED;
         dataspace=H5Screate_simple(rank, mydim, maxdims);
       } else {
-        for(i = 0; i < rank; i++)
-        {
-        mydim[i] = dimensions[i];
-        }
         /* dataset creation */
         dataspace=H5Screate_simple(rank, mydim, NULL);  
         }
@@ -683,6 +669,7 @@ static void ignoreError(void *data, char *text){
     if (datatype == NX_CHAR)
     {
        H5Tset_size(datatype1, byte_zahl);
+/*       H5Tset_strpad(H5T_STR_SPACEPAD); */
     }
     if(compress_type == NX_COMP_LZW)
     {
@@ -724,10 +711,7 @@ static void ignoreError(void *data, char *text){
     }
     if (dimensions[0] == NX_UNLIMITED)
     {      
-      for(i = 0; i < rank; i++){  
-          size[i]   = dimensions[i]; 
-      } 
-      size[0] = 1;
+      size[0]   = 1; 
       iNew = H5Dextend (pFile->iCurrentD, size);
       if (iNew < 0) {
         sprintf (pBuffer, "ERROR: cannot create Dataset %s, check arguments",
@@ -736,6 +720,9 @@ static void ignoreError(void *data, char *text){
         return NX_ERROR;
       }
     }
+    if (cparms != -1) {
+	iRet = H5Pclose(cparms);
+    }
     iRet = H5Sclose(dataspace);
     iRet = H5Tclose(datatype1);
     iRet = H5Dclose(pFile->iCurrentD);
@@ -865,7 +852,27 @@ static void ignoreError(void *data, char *text){
     }
     return NX_OK;
   }
-  
+/*------------------------------------------------------------------*/
+static int getAttVID(pNexusFile5 pFile){
+  int vid;
+     if(pFile->iCurrentG == 0 && pFile->iCurrentD == 0){
+       /* global attribute */
+       vid = H5Gopen(pFile->iFID,"/");
+     } else if(pFile->iCurrentD != 0) {
+       /* dataset attribute */
+       vid = pFile->iCurrentD;
+     } else {
+       /* group attribute */;
+       vid = pFile->iCurrentG;
+     }
+     return vid;
+}
+/*---------------------------------------------------------------*/
+static void killAttVID(pNexusFile5 pFile, int vid){
+  if(pFile->iCurrentG == 0 && pFile->iCurrentD == 0){
+    H5Gclose(vid);
+  }
+}
   /* ------------------------------------------------------------------- */
 
   NXstatus  NX5putattr (NXhandle fid, CONSTCHAR *name, void *data, 
@@ -875,111 +882,46 @@ static void ignoreError(void *data, char *text){
     hid_t  attr1, aid1, aid2;
     hid_t type;
     int iRet;
-  
+    int vid;  
+
     pFile = NXI5assert (fid);
-    if (iType == NX_CHAR)
-    {
-        type=H5T_C_S1;
-    }
-    else if (iType == NX_INT8)
-    {
-        type=H5T_NATIVE_CHAR;
-    }
-    else if (iType == NX_UINT8)
-    {
-        type=H5T_NATIVE_UCHAR;
-    }
-    else if (iType == NX_INT16)
-    {
-        type=H5T_NATIVE_SHORT;
-    }
-    else if (iType == NX_UINT16)
-    {
-        type=H5T_NATIVE_USHORT;
-    }
-    else if (iType == NX_INT32)
-    {
-        type=H5T_NATIVE_INT;
-    }
-    else if (iType == NX_UINT32)
-    {
-        type=H5T_NATIVE_UINT;
-    }
-    else if (iType == NX_FLOAT32)
-    {
-        type=H5T_NATIVE_FLOAT;
-    }
-    else if (iType == NX_FLOAT64)
-    {
-        type=H5T_NATIVE_DOUBLE;
-    }
-    if (pFile->iCurrentD != 0) {
-       /* Dataset attribute */
-       aid2=H5Screate(H5S_SCALAR);
-       aid1=H5Tcopy(type);
-       if (iType == NX_CHAR)
-         {
-           H5Tset_size(aid1,datalen); 
-         }         
-       iRet = H5Aopen_name(pFile->iCurrentD, name);
-       if (iRet>0) {
-          H5Aclose(iRet);
-          iRet=H5Adelete(pFile->iCurrentD,name);
-          if (iRet<0) {
-              NXIReportError (NXpData, "ERROR: Old attribute cannot removed! ");
-              return NX_ERROR;
-          }
-       }
-       attr1 = H5Acreate(pFile->iCurrentD, name, aid1, aid2, H5P_DEFAULT);
-       if (attr1 < 0) {
-          NXIReportError (NXpData, "ERROR: Attribute cannot created! ");
-          return NX_ERROR;
-       }   
-       if (H5Awrite(attr1,aid1,data) < 0) 
-       {
-          NXIReportError (NXpData, "ERROR: HDF failed to store attribute ");
-          return NX_ERROR;
-       }
-       /* Close attribute dataspace */
-       iRet=H5Tclose(aid1);
-       iRet=H5Sclose(aid2); 
-       /* Close attribute  */
-       iRet=H5Aclose(attr1); 
-    } else {
-       /* global attribute */
-       pFile->iVID=H5Gopen(pFile->iFID,"/");
-       aid2=H5Screate(H5S_SCALAR);
-       aid1=H5Tcopy(type);
-       if (iType == NX_CHAR)
-         {
-           H5Tset_size(aid1,datalen); 
-         }         
-       iRet = H5Aopen_name(pFile->iVID, name);
-       if (iRet>0) {
-          H5Aclose(iRet);
-          iRet=H5Adelete(pFile->iVID,name);
-          if (iRet<0) {
-              NXIReportError (NXpData, "ERROR: Old attribute cannot removed! ");
-              return NX_ERROR;
-          }
-       } 
-       attr1 = H5Acreate(pFile->iVID, name, aid1, aid2, H5P_DEFAULT);
-       if (attr1 < 0) {
-          NXIReportError (NXpData, "ERROR: Attribute cannot created! ");
-          return NX_ERROR;
-       } 
-       if (H5Awrite(attr1,aid1,data) < 0) 
-       {
-          NXIReportError (NXpData, "ERROR: HDf failed to store attribute ");
-          return NX_ERROR;
-       } 
-       /* Close attribute dataspace */
-       iRet=H5Tclose(aid1);
-       iRet=H5Sclose(aid2); 
-        /* Close attribute */
-       iRet=H5Aclose(attr1); 
-       H5Gclose(pFile->iVID);
+
+    type = nxToHDF5Type(iType);
+   
+    /* determine vid */
+    vid = getAttVID(pFile);
+    aid2=H5Screate(H5S_SCALAR);
+    aid1=H5Tcopy(type);
+    if (iType == NX_CHAR){
+      H5Tset_size(aid1,datalen); 
+    }         
+    iRet = H5Aopen_name(vid, name);
+    if (iRet>0) {
+      H5Aclose(iRet);
+      iRet=H5Adelete(vid,name);
+      if (iRet<0) {
+	NXIReportError (NXpData, "ERROR: Old attribute cannot removed! ");
+	killAttVID(pFile,vid);
+	return NX_ERROR;
+      }
+    }    
+    attr1 = H5Acreate(vid, name, aid1, aid2, H5P_DEFAULT);
+    if (attr1 < 0) {
+      NXIReportError (NXpData, "ERROR: Attribute cannot created! ");
+      killAttVID(pFile,vid);
+      return NX_ERROR;
+    }   
+    if (H5Awrite(attr1,aid1,data) < 0) {
+      NXIReportError (NXpData, "ERROR: HDF failed to store attribute ");
+      killAttVID(pFile,vid);
+      return NX_ERROR;
     }
+    /* Close attribute dataspace */
+    iRet=H5Tclose(aid1);
+    iRet=H5Sclose(aid2); 
+    /* Close attribute  */
+    iRet=H5Aclose(attr1); 
+    killAttVID(pFile,vid);
     return NX_OK;
   }
   
@@ -990,9 +932,9 @@ static void ignoreError(void *data, char *text){
     pNexusFile5 pFile;
     int iRet, i;
     int rank;
-    hssize_t myStart[H5S_MAX_RANK];
+    hsize_t myStart[H5S_MAX_RANK];
     hsize_t mySize[H5S_MAX_RANK];
-    hsize_t size[H5S_MAX_RANK],maxdims[H5S_MAX_RANK];
+    hsize_t size[1],maxdims[H5S_MAX_RANK];
     hid_t   filespace,dataspace; 
   
     pFile = NXI5assert (fid);
@@ -1006,7 +948,6 @@ static void ignoreError(void *data, char *text){
     {
        myStart[i] = iStart[i];
        mySize[i]  = iSize[i];
-       size[i] = iSize[i];
     }
     iRet = H5Sget_simple_extent_dims(pFile->iCurrentS, NULL, maxdims);
     dataspace = H5Screate_simple (rank, mySize, NULL);
@@ -1069,15 +1010,21 @@ static void ignoreError(void *data, char *text){
     if(pFile->iCurrentD <= 0){
       return NX_ERROR;
     }
-    strcpy(sRes->iTag5,"");
-    strcpy(sRes->iRef5,"/");
-    strcat(sRes->iRef5,pFile->name_ref);
-    strcpy(sRes->iRefd,pFile->iCurrentLD);
+
+    /*
+      this means: if the item is already linked: use the target attribute else, 
+      the path to the current node
+    */
     oldErr = NXMGetError();
     NXMSetError(NXpData, ignoreError);
     datalen = 1024;
     memset(&sRes->targetPath,0,datalen*sizeof(char));
-    NX5getattr(fid,"target",&sRes->targetPath,&datalen,&type);
+    if(NX5getattr(fid,"target",&sRes->targetPath,&datalen,&type) != NX_OK)
+    {
+      buildCurrentPath(pFile, sRes->targetPath, 1024);
+    }
+    NXMSetError(NXpData,oldErr);
+    sRes->linkType = 1;
     return NX_OK;
   }
 
@@ -1087,79 +1034,136 @@ static void ignoreError(void *data, char *text){
   {
     pNexusFile5 pFile;
     pFile = NXI5assert (fid);
-     printf("HDF5 link: iTag5 = \"%s\", iRef5 = \"%s\", iRefd = \"%s\"\n", sLink->iTag5, sLink->iRef5, sLink->iRefd);
+     printf("HDF5 link: targetPath = \"%s\", linkType = \"%d\"\n", sLink->targetPath, sLink->linkType);
     return NX_OK;
   }
+/*--------------------------------------------------------------------*/
+static NXstatus NX5settargetattribute(pNexusFile5 pFile, NXlink *sLink)
+{
+  herr_t length, dataID, status, aid2, aid1, attID;
+  char name[] = "target";
 
- /* ------------------------------------------------------------------- */
-  
-  NXstatus  NX5makelink (NXhandle fid, NXlink* sLink)
-  {
+    length = strlen(sLink->targetPath);
+    /*
+      set the target attribute
+    */
+    if(sLink->linkType > 0)
+    {
+      dataID = H5Dopen(pFile->iFID,sLink->targetPath);
+    } else {
+      dataID = H5Gopen(pFile->iFID,sLink->targetPath);
+    }
+    if(dataID < 0)
+    {
+      NXIReportError(NXpData,"Internal error, path to link does not exist");
+      return NX_ERROR;
+    }
+    status = H5Aopen_name(dataID,name);
+    if(status > 0)
+    {
+      H5Aclose(status);
+      status = H5Adelete(dataID,name);
+      if(status < 0)
+      {
+	return NX_OK;
+      }
+    }
+    aid2 = H5Screate(H5S_SCALAR);
+    aid1 = H5Tcopy(H5T_C_S1);
+    H5Tset_size(aid1,strlen(sLink->targetPath));
+    attID = H5Acreate(dataID,name,aid1,aid2,H5P_DEFAULT);
+    if(attID < 0)
+    {
+	return NX_OK;
+    }
+    status = H5Awrite(attID,aid1,sLink->targetPath);
+    H5Tclose(aid1);
+    H5Sclose(aid2); 
+    H5Aclose(attID); 
+    if(sLink->linkType > 0){
+      H5Dclose(dataID);
+    } else {
+      H5Gclose(dataID);
+    }
+    return NX_OK;
+}
+/*---------------------------------------------------------------------*/
+NXstatus NX5makenamedlink(NXhandle fid, CONSTCHAR *name, NXlink *sLink)
+{
     pNexusFile5 pFile;
-/*    int iRet; */
-    herr_t status, dataID, aid1, aid2, attID;
-    int size_type;
-    char buffer[1024];
-    char name[] = "target";
+    char linkTarget[1024];
+    int status;
 
     pFile = NXI5assert (fid);
     if (pFile->iCurrentG == 0) { /* root level, can not link here */
       return NX_ERROR;
     }
-    size_type = strlen(sLink->iRefd); 
-    if (size_type > 0)
+    
+    /*
+      build pathname to link from our current group and the name 
+      of the thing to link
+    */
+    if(strlen(pFile->name_ref) + strlen(name) + 2 < 1024)
     {
-       /* dataset link */
-       strcpy(sLink->iTag5,pFile->name_ref);
-    } else {
-       /* group link */
-       strcpy(buffer,pFile->name_ref);
-       strcat(buffer, sLink->iTag5);
-       strcpy(sLink->iTag5,"/");
-       strcat(sLink->iTag5,buffer);
+      strcpy(linkTarget,"/");
+      strcat(linkTarget,pFile->name_ref);
+      strcat(linkTarget,"/");
+      strcat(linkTarget,name);
     }
-    if (size_type>0)
+    else 
     {
-      strcat(sLink->iRef5,"/");
-      strcat(sLink->iRef5,sLink->iRefd);
+      NXIReportError(NXpData,"Path string to long");
+      return NX_ERROR;
+    } 
+
+    status = H5Glink(pFile->iFID, H5G_LINK_HARD, sLink->targetPath, linkTarget);
+
+    return NX5settargetattribute(pFile,sLink);
+}
+ /* ------------------------------------------------------------------- */
+  
+  NXstatus  NX5makelink (NXhandle fid, NXlink* sLink)
+  {
+    pNexusFile5 pFile;
+    char linkTarget[1024];
+    char *itemName = NULL;
+    int status;
+
+    pFile = NXI5assert (fid);
+    if (pFile->iCurrentG == 0) { /* root level, can not link here */
+      return NX_ERROR;
     }
-    if (size_type>0)
+    
+    /*
+      locate name of the element to link 
+    */
+    itemName = strrchr(sLink->targetPath,'/');
+    if(itemName == NULL){
+      NXIReportError(NXpData,"Bad link structure");
+      return NX_ERROR;
+    }
+    itemName++;
+
+    /*
+      build pathname to link from our current group and the name 
+      of the thing to link
+    */
+    if(strlen(pFile->name_ref) + strlen(itemName) + 2 < 1024)
     {
-      strcat(sLink->iTag5,"/");
-      strcat(sLink->iTag5,sLink->iRefd);
+      strcpy(linkTarget,"/");
+      strcat(linkTarget,pFile->name_ref);
+      strcat(linkTarget,"/");
+      strcat(linkTarget,itemName);
     }
-    status = H5Glink(pFile->iFID, H5G_LINK_HARD, sLink->iRef5, sLink->iTag5);
-    if(size_type > 0)
+    else 
     {
-      dataID = H5Dopen(pFile->iFID,sLink->iRef5);
-      /*
-	remove old attribute if existing
-      */
-      status = H5Aopen_name(dataID,name);
-      if(status > 0)
-      {
-	H5Aclose(status);
-	status = H5Adelete(dataID,name);
-	if(status < 0)
-	{
-	  return NX_OK;
-	}
-      }
-      aid2 = H5Screate(H5S_SCALAR);
-      aid1 = H5Tcopy(H5T_C_S1);
-      H5Tset_size(aid1,strlen(sLink->iRef5));
-      attID = H5Acreate(dataID,name,aid1,aid2,H5P_DEFAULT);
-      if(attID < 0)
-      {
-	return NX_OK;
-      }
-      H5Awrite(attID,aid1,sLink->iRef5);
-      H5Tclose(aid1);
-      H5Sclose(aid2); 
-      H5Aclose(attID); 
-      H5Dclose(dataID);
-    }
-    return NX_OK;
+      NXIReportError(NXpData,"Path string to long");
+      return NX_ERROR;
+    } 
+
+    status = H5Glink(pFile->iFID, H5G_LINK_HARD, sLink->targetPath, linkTarget);
+
+    return NX5settargetattribute(pFile,sLink);
    }
  
   /*----------------------------------------------------------------------*/
@@ -1237,6 +1241,8 @@ static void ignoreError(void *data, char *text){
         self.iNX++;
         *((int*)opdata)=self.iNX;
         break;
+      default:
+	break;
     }
     return 0; 
   }
@@ -1263,7 +1269,7 @@ static void ignoreError(void *data, char *text){
       strcpy (pName,pFile->name_ref);
       attr_id = H5Aopen_name(pFile->iCurrentG,"NX_class");
       if (attr_id<0) {
-         strcpy(pClass,"non");
+         strcpy(pClass, NX_UNKNOWN_GROUP);
       } else {
         atype=H5Tcopy(H5T_C_S1);
         H5Tset_size(atype,64);  
@@ -1277,87 +1283,13 @@ static void ignoreError(void *data, char *text){
     }
     return NX_OK;
   }
- 
-  /*-------------------------------------------------------------------------*/
 
-  NXstatus  NX5getnextentry (NXhandle fid,NXname name, NXname nxclass, int *datatype)
-  {
-    pNexusFile5 pFile;
-    hid_t grp, attr1,type,atype;
-    int iRet,iPtype, i;
-    int idx,data_id,size_id, sign_id;
-    char data[128];
-    char ph_name[1024];
-    info_type op_data;
-    int iRet_iNX=-1;
-    char pBuffer[256];
-     
-    pFile = NXI5assert (fid);
-    op_data.iname = NULL;
-    idx=pFile->iStack5[pFile->iStackPtr].iCurrentIDX;
-    if (strlen(pFile->name_ref) == 0) {
-       /* root group */
-       strcpy(pFile->name_ref,"/");
-    }  
-    iRet=H5Giterate(pFile->iFID,pFile->name_ref,&idx,nxgroup_info,&op_data);
-    strcpy(nxclass,"");
-   
-    if (pFile->iCurrentG == 0) {
-       pFile->iNX=0;
-       iRet_iNX = H5Giterate(pFile->iFID,"/",0,group_info1,&pFile->iNX);
-    } else {
-      pFile->iNX=0;
-      iRet_iNX = H5Giterate(pFile->iFID,pFile->name_ref,0,group_info1, &pFile->iNX);
-    }
-    if (idx == pFile->iNX) {
-       iRet_iNX = 2;   
-    } 
-         
-    if (iRet > 0)
-      {
-        pFile->iStack5[pFile->iStackPtr].iCurrentIDX++;
-        if (op_data.iname != NULL) {
-	  strcpy(name,op_data.iname);
-           free(op_data.iname);
-        } else {
-	  pFile->iStack5[pFile->iStackPtr].iCurrentIDX = 0;   
-	  return NX_EOD;
-	}	  
-        if (op_data.type == H5G_GROUP)
-        {
-           strcpy(ph_name,"");
-           for(i = 1; i < (pFile->iStackPtr + 1); i++)
-           {
-              strcat(ph_name,pFile->iStack5[i].irefn);
-              strcat(ph_name,"/");
-           }
-           strcat(ph_name,name);
-           grp=H5Gopen(pFile->iFID,ph_name);
-           if (grp < 0) {
-              sprintf (pBuffer, "ERROR: Group %s does not exist!", ph_name);
-              NXIReportError (NXpData, pBuffer);
-              return NX_ERROR;  
-           }
-           attr1 = H5Aopen_name(grp, "NX_class");
-           if (attr1 < 0) {
-              H5Gclose(grp);
-              NXIReportError (NXpData, "Error opening group class");
-              return NX_ERROR;  
-           }
-           type=H5T_C_S1;
-           atype=H5Tcopy(type);
-           H5Tset_size(atype,128);  
-           iRet = H5Aread(attr1, atype, data);
-           strcpy(nxclass,data);
-           H5Tclose(atype);
-           H5Gclose(grp);
-	   H5Aclose(attr1);
-        } else if (op_data.type==H5G_DATASET)
-        {
-           grp=H5Dopen(pFile->iCurrentG,name);
-           type=H5Dget_type(grp);
-           atype=H5Tcopy(type);
-           data_id = H5Tget_class(atype);
+/*------------------------------------------------------------------------*/
+static int hdf5ToNXType(int data_id, hid_t atype)
+{
+  int iPtype = -1;
+  hid_t sign_id, size_id;
+
            if (data_id==H5T_STRING)
            {
              iPtype=NX_CHAR;
@@ -1405,61 +1337,24 @@ static void ignoreError(void *data, char *text){
                iPtype=NX_FLOAT64;
             }
         }
-           *datatype=iPtype;
-           strcpy(nxclass, "SDS");
-           H5Tclose(atype);
-	    H5Tclose(type);
-	    H5Dclose(grp);
-	 }
-	  return NX_OK;
-       } 
-       else
-       { 
-	  if (iRet_iNX == 2) {
-	    if (op_data.iname != NULL) {
-	       free(op_data.iname);
-	    }
-	    pFile->iStack5[pFile->iStackPtr].iCurrentIDX = 0;   
-	    return NX_EOD;
-	 } 
-	 if (op_data.iname != NULL) {
-	    free(op_data.iname);
-	 } 
-	 NXIReportError (NXpData, 
-			    "ERROR: Iteration (directory) was not successful");
-	 return NX_ERROR;              
-       }
-   }
+	if (iPtype == -1)
+	{
+         NXIReportError (NXpData, "ERROR: hdf5ToNXtype: invalid type");
+	}
 
-   /*-------------------------------------------------------------------------*/
+	   return iPtype;
+}
+/*--------------------------------------------------------------------------*/
+static int h5MemType(hid_t atype)
+{
+  hid_t data_id, size_id, sign_id, memtype_id = -1;
+ 
+  data_id = H5Tget_class(atype);
 
-   NXstatus  NX5getdata (NXhandle fid, void *data)
-   {
-     pNexusFile5 pFile;
-     int iStart[H5S_MAX_RANK], status;
-     hid_t data_id, memtype_id, size_id, sign_id;    
-     int dims;    
-
-     pFile = NXI5assert (fid);
-     /* check if there is an Dataset open */
-     if (pFile->iCurrentD == 0) 
+       if (data_id==H5T_INTEGER)
      {
-	NXIReportError (NXpData, "ERROR: no Dataset open");
-	return NX_ERROR;
-     }
-     memset (iStart, 0, H5S_MAX_RANK * sizeof(int));
-     /* map datatypes of other plateforms */
-     data_id = H5Tget_class(pFile->iCurrentT);
-     if (data_id==H5T_STRING)
-     {
-	dims = H5Tget_size(pFile->iCurrentT);
-	memtype_id = H5Tcopy(H5T_C_S1);
-	H5Tset_size(memtype_id, dims);
-     }
-     if (data_id==H5T_INTEGER)
-     {
-	size_id=H5Tget_size(pFile->iCurrentT);
-	sign_id=H5Tget_sign(pFile->iCurrentT);
+	size_id=H5Tget_size(atype);
+	sign_id=H5Tget_sign(atype);
 	if (size_id==1)
 	{
 	    if (sign_id==H5T_SGN_2)
@@ -1489,7 +1384,7 @@ static void ignoreError(void *data, char *text){
 	}
       } else if (data_id==H5T_FLOAT)     
 	{
-	  size_id=H5Tget_size(pFile->iCurrentT);
+	  size_id=H5Tget_size(atype);
 	  if (size_id==4)
 	  {
 	     memtype_id = H5T_NATIVE_FLOAT; 
@@ -1497,6 +1392,165 @@ static void ignoreError(void *data, char *text){
 	     memtype_id = H5T_NATIVE_DOUBLE;
 	  }
       }           
+      if (memtype_id == -1)
+      {
+         NXIReportError (NXpData, "ERROR: h5MemType: invalid type");
+      }
+      return memtype_id;
+}
+  /*-------------------------------------------------------------------------*/
+
+  NXstatus  NX5getnextentry (NXhandle fid,NXname name, NXname nxclass, int *datatype)
+  {
+    pNexusFile5 pFile;
+    hid_t grp, attr1,type,atype;
+    int iRet,iPtype, i;
+    int idx,data_id;
+    char data[128];
+    char ph_name[1024];
+    info_type op_data;
+    int iRet_iNX=-1;
+    char pBuffer[256];
+     
+    pFile = NXI5assert (fid);
+    op_data.iname = NULL;
+
+    /*
+      iterate to next entry in group list
+    */
+    idx=pFile->iStack5[pFile->iStackPtr].iCurrentIDX;
+    if (strlen(pFile->name_ref) == 0) {
+       /* root group */
+       strcpy(pFile->name_ref,"/");
+    }  
+    iRet=H5Giterate(pFile->iFID,pFile->name_ref,&idx,nxgroup_info,&op_data);
+    strcpy(nxclass, NX_UNKNOWN_GROUP);
+   
+    /*
+      figure out the number of items in the current group. We need this in order to
+      find out if we are at the end of the search. 
+    */
+    if (pFile->iCurrentG == 0) {
+       pFile->iNX=0;
+       iRet_iNX = H5Giterate(pFile->iFID,"/",0,group_info1,&pFile->iNX);
+    } else {
+      pFile->iNX=0;
+      iRet_iNX = H5Giterate(pFile->iFID,pFile->name_ref,0,group_info1, &pFile->iNX);
+    }
+    if (idx == pFile->iNX) {
+       iRet_iNX = 2;   
+    } 
+         
+    if (iRet > 0)
+      {
+        pFile->iStack5[pFile->iStackPtr].iCurrentIDX++;
+        if (op_data.iname != NULL) {
+	  strcpy(name,op_data.iname);
+           free(op_data.iname);
+        } else {
+	  pFile->iStack5[pFile->iStackPtr].iCurrentIDX = 0;   
+	  return NX_EOD;
+	}	  
+        if (op_data.type == H5G_GROUP)
+        {
+	  /*
+	    open group and find class name attribute 
+	  */
+           strcpy(ph_name,"");
+           for(i = 1; i < (pFile->iStackPtr + 1); i++)
+           {
+              strcat(ph_name,pFile->iStack5[i].irefn);
+              strcat(ph_name,"/");
+           }
+           strcat(ph_name,name);
+           grp=H5Gopen(pFile->iFID,ph_name);
+           if (grp < 0) {
+              sprintf (pBuffer, "ERROR: Group %s does not exist!", ph_name);
+              NXIReportError (NXpData, pBuffer);
+              return NX_ERROR;  
+           }
+           attr1 = H5Aopen_name(grp, "NX_class");
+           if (attr1 < 0) {
+	      strcpy(nxclass, NX_UNKNOWN_GROUP);
+           } else {
+               type=H5T_C_S1;
+               atype=H5Tcopy(type);
+               H5Tset_size(atype,128);  
+               iRet = H5Aread(attr1, atype, data);
+               strcpy(nxclass,data);
+               H5Tclose(atype);
+	       H5Aclose(attr1);
+           }
+           H5Gclose(grp);
+        } else if (op_data.type==H5G_DATASET)
+        {
+	  /*
+	    open dataset and find type
+	  */
+           grp=H5Dopen(pFile->iCurrentG,name);
+           type=H5Dget_type(grp);
+           atype=H5Tcopy(type);
+           data_id = H5Tget_class(atype);
+           iPtype = hdf5ToNXType(data_id, atype);
+           *datatype=iPtype;
+           strcpy(nxclass, "SDS");
+           H5Tclose(atype);
+	    H5Tclose(type);
+	    H5Dclose(grp);
+	 }
+	  return NX_OK;
+       } 
+       else
+       { 
+	 /*
+	   we are at the end of the search: clear the data structure and reset 
+	   iCurrentIDX to 0
+	 */
+	  if (iRet_iNX == 2) {
+	    if (op_data.iname != NULL) {
+	       free(op_data.iname);
+	    }
+	    pFile->iStack5[pFile->iStackPtr].iCurrentIDX = 0;   
+	    return NX_EOD;
+	 } 
+	 if (op_data.iname != NULL) {
+	    free(op_data.iname);
+	 } 
+	 NXIReportError (NXpData, 
+			    "ERROR: Iteration (directory) was not successful");
+	 return NX_ERROR;              
+       }
+   }
+
+   /*-------------------------------------------------------------------------*/
+
+   NXstatus  NX5getdata (NXhandle fid, void *data)
+   {
+     pNexusFile5 pFile;
+     int iStart[H5S_MAX_RANK], status;
+     hid_t data_id, memtype_id;    
+     int dims;    
+
+     pFile = NXI5assert (fid);
+     /* check if there is an Dataset open */
+     if (pFile->iCurrentD == 0) 
+     {
+	NXIReportError (NXpData, "ERROR: no Dataset open");
+	return NX_ERROR;
+     }
+     memset (iStart, 0, H5S_MAX_RANK * sizeof(int));
+     /* map datatypes of other plateforms */
+     data_id = H5Tget_class(pFile->iCurrentT);
+     if (data_id==H5T_STRING)
+     {
+	dims = H5Tget_size(pFile->iCurrentT);
+	memtype_id = H5Tcopy(H5T_C_S1);
+	H5Tset_size(memtype_id, dims);
+     }
+     else 
+     {
+       memtype_id = h5MemType(pFile->iCurrentT);
+     }
 
      /* actually read */    
      status = H5Dread (pFile->iCurrentD, memtype_id, 
@@ -1521,7 +1575,7 @@ static void ignoreError(void *data, char *text){
      pNexusFile5 pFile;
      int i, iRank, mType, iRet;
      hsize_t myDim[H5S_MAX_RANK]; 
-     hid_t data_id,size_id,sign_id;
+     hid_t data_id;
 
      pFile = NXI5assert (fid);
      /* check if there is an Dataset open */
@@ -1532,62 +1586,13 @@ static void ignoreError(void *data, char *text){
 
      /* read information */
      data_id = H5Tget_class(pFile->iCurrentT);
-     if (data_id==H5T_STRING)
-     {
-       mType=NX_CHAR;
-     }
-     if (data_id==H5T_INTEGER)
-     {
-       size_id=H5Tget_size(pFile->iCurrentT);
-       sign_id=H5Tget_sign(pFile->iCurrentT);
-       if (size_id==1)
-       {
-	  if (sign_id==H5T_SGN_2)
-	  {
-	   mType=NX_INT8;
-	  } else {
-	   mType=NX_UINT8;
-	  }
-       } 
-       else if (size_id==2) 
-       {
-	  if (sign_id==H5T_SGN_2)
-	  {
-	   mType=NX_INT16;
-	  } else {
-	   mType=NX_UINT16;
-	  }
-       }
-       else if (size_id==4) 
-       {
-       if (sign_id==H5T_SGN_2)
-	  {
-	   mType=NX_INT32;
-	  } else {
-	   mType=NX_UINT32;
-	  }
-       }
-     } else if (data_id==H5T_FLOAT)     
-       {
-       size_id=H5Tget_size(pFile->iCurrentT);
-       if (size_id==4)
-       {
-       mType=NX_FLOAT32;
-       } 
-       else if (size_id==8) 
-       {
-       mType=NX_FLOAT64;
-       }
-     } 
+     mType = hdf5ToNXType(data_id,pFile->iCurrentT);
      iRank = H5Sget_simple_extent_ndims(pFile->iCurrentS);
      iRet = H5Sget_simple_extent_dims(pFile->iCurrentS, myDim, NULL);   
      /* conversion to proper ints for the platform */ 
      *iType = (int)mType;
-     if (data_id==H5T_STRING) {
-	for (i = 0; i < iRank; i++)
-	{
-	  myDim[i] = H5Tget_size(pFile->iCurrentT);    
-	}
+     if (data_id==H5T_STRING && myDim[iRank-1] == 1) {
+        myDim[iRank-1] = H5Tget_size(pFile->iCurrentT);
      } 
      *rank = (int)iRank;
      for (i = 0; i < iRank; i++)
@@ -1602,12 +1607,12 @@ static void ignoreError(void *data, char *text){
    NXstatus  NX5getslab (NXhandle fid, void *data, int iStart[], int iSize[])
    {
      pNexusFile5 pFile;
-     hssize_t myStart[H5S_MAX_RANK];
+     hsize_t myStart[H5S_MAX_RANK];
      hsize_t mySize[H5S_MAX_RANK];
-     hssize_t mStart[H5S_MAX_RANK];
+     hsize_t mStart[H5S_MAX_RANK];
      hid_t   memspace, iRet, data_id;
-     hid_t   memtype_id, size_id, sign_id;
-     char *tmp_data;
+     hid_t   memtype_id;
+     char *tmp_data = NULL;
      char *data1;
      int i, dims, iRank, mtype = 0;
 
@@ -1627,6 +1632,10 @@ static void ignoreError(void *data, char *text){
 	}
       data_id = H5Tget_class(pFile->iCurrentT);
       if (data_id == H5T_STRING) {
+/* 
+ * FAA 24/1/2007: I don't think this will work for multidimensional
+ * string arrays. 
+*/
 	 mtype = NX_CHAR;
 	 if (mySize[0] == 1) {
 	     mySize[0]  = H5Tget_size(pFile->iCurrentT);
@@ -1662,47 +1671,10 @@ static void ignoreError(void *data, char *text){
 	 memtype_id = H5Tcopy(H5T_C_S1);
 	 H5Tset_size(memtype_id, dims);  
        }
-       if (data_id==H5T_INTEGER)
+       else 
        {
-	 size_id=H5Tget_size(pFile->iCurrentT);
-	 sign_id=H5Tget_sign(pFile->iCurrentT);
-	 if (size_id==1)
-	 {
-	    if (sign_id==H5T_SGN_2)
-	    {
-	       memtype_id = H5T_NATIVE_INT8;
-	    } else {
-	       memtype_id = H5T_NATIVE_UINT8;
-	    }
-	 } 
-	 else if (size_id==2) 
-	 {
-	    if (sign_id==H5T_SGN_2)
-	    {
-	       memtype_id = H5T_NATIVE_INT16;
-	    } else {
-	       memtype_id = H5T_NATIVE_UINT16; 
-	    }
-	 }
-	 else if (size_id==4) 
-	 {
-	   if (sign_id==H5T_SGN_2)
-	   {
-	      memtype_id = H5T_NATIVE_INT32;
-	   } else {
-	      memtype_id = H5T_NATIVE_UINT32; 
-	   }
-	 }
-       } else if (data_id==H5T_FLOAT)     
-	 {
-	   size_id=H5Tget_size(pFile->iCurrentT);
-	   if (size_id==4)
-	   {
-	      memtype_id = H5T_NATIVE_FLOAT; 
-	   } else if (size_id==8) {
-	      memtype_id = H5T_NATIVE_DOUBLE;
-	   }
-       }       
+	 memtype_id = h5MemType(pFile->iCurrentT);
+       }
 
       /* read slab */ 
       if (mtype == NX_CHAR) {
@@ -1738,223 +1710,98 @@ static void ignoreError(void *data, char *text){
 				       int *iLength, int *iType)
    {
      pNexusFile5 pFile;
-     hid_t attr_id,size_id,sign_id;
+     hid_t attr_id;
      hid_t iRet, atype, aspace;
      int iPType,rank;
      char *iname = NULL; 
      unsigned int idx;
      int intern_idx=-1;
+     int vid;
+
 
      pFile = NXI5assert (fileid);
+
+     vid = getAttVID(pFile);
+
      idx=pFile->iAtt5.iCurrentIDX;
      iRet=0;
-     if ((pFile->iCurrentD == 0) && (pFile->iCurrentG==0)) 
-     {
-     /* global attribute */
-	pFile->iVID=H5Gopen(pFile->iFID,"/");
-	intern_idx=H5Aget_num_attrs(pFile->iVID);
-	if (intern_idx > idx) {
-	   iRet=H5Aiterate(pFile->iVID,&idx,attr_info,&iname);
-	} 
-	else
-	{
-	  iRet=0;
-	} 
-	intern_idx=-1;
-	if (iRet < 0) {
-	   NXIReportError (NXpData, "ERROR iterating through ROOT Attr. list!");
-	   return NX_ERROR;  
-	} 
-     } else if (pFile->iCurrentD > 0) { 
-	intern_idx=H5Aget_num_attrs(pFile->iCurrentD);
-	if (intern_idx > idx) {
-	   iRet=H5Aiterate(pFile->iCurrentD,&idx,attr_info,&iname);
-	} 
-	else
-	{
-	  iRet=0;
-	} 
-	intern_idx=-1;
-	if (iRet < 0) {
-	   NXIReportError (NXpData, "ERROR iterating through data Attr. list!");
-	   return NX_ERROR;  
-	}
+     intern_idx=H5Aget_num_attrs(vid);
+     if(intern_idx == idx) {
+       killAttVID(pFile,vid);
+       return NX_EOD;
      }
-     else  
-     {
-	pFile->iAtt5.iCurrentIDX = 0;
-	return NX_EOD;  /* no group attributes */
-     }
-     if (iRet>0)
-       {
-	 pFile->iAtt5.iCurrentIDX++;
-	 strcpy(pName, iname);
-	 if (iname != NULL) {
-	    free(iname);
-	 } 
-	 if ((pFile->iCurrentD == 0) && (pFile->iCurrentG==0)) {
-	    /* global attribute */
-	    pFile->iCurrentA = H5Aopen_name(pFile->iVID, pName);
-	 } else { 
-	    pFile->iCurrentA = H5Aopen_name(pFile->iCurrentD, pName);
-	 }
-	 atype  = H5Aget_type(pFile->iCurrentA);
-	 aspace = H5Aget_space(pFile->iCurrentA);
-	 rank = H5Sget_simple_extent_ndims(aspace);
-	 attr_id = H5Tget_class(atype);
-	 if (attr_id==H5T_STRING) {
-	    iPType=NX_CHAR;
-	    rank = H5Tget_size(atype);
-	 }
-	 if (rank == 0) {
-	    rank++;
-	 }  
-	 if (attr_id==H5T_INTEGER)
-	    {
-	    size_id=H5Tget_size(atype);
-	    sign_id=H5Tget_sign(atype);
-	    if (size_id==1)
-	    {
-	       if (sign_id==H5T_SGN_2)
-	       {
-	       iPType=NX_INT8;
-	       } else {
-	       iPType=NX_UINT8;
-	       }
-	    } 
-	    else if (size_id==2) 
-	    {
-	       if (sign_id==H5T_SGN_2)
-	       {
-	       iPType=NX_INT16;
-	       } else {
-	       iPType=NX_UINT16;
-	       }
-	    }
-	    else if (size_id==4) 
-	    {
-	       if (sign_id==H5T_SGN_2)
-	       {
-	       iPType=NX_INT32;
-	       } else {
-	       iPType=NX_UINT32;
-	       }
-	    }
-	 } else if (attr_id==H5T_FLOAT)     
-	   {
-	   size_id=H5Tget_size(atype);
-	   if (size_id==4)
-	   {
-	   iPType=NX_FLOAT32;
-	   } 
-	   else if (size_id==8) 
-	   {
-	   iPType=NX_FLOAT64;
-	   }
-	 } 
-	 *iType=iPType;
-	 *iLength=rank;
-	 H5Tclose(atype);
-	 H5Sclose(aspace);
-	 H5Aclose(pFile->iCurrentA);
-	 return NX_OK;
-       }      
-       else
-       { 
-	 if ((pFile->iCurrentD == 0) && (pFile->iCurrentG==0)) 
-	 {
-	    /* global attribute */
-	    intern_idx=H5Aget_num_attrs(pFile->iVID);
-	 } else {
-	    if (pFile->iCurrentD>0){
-	       intern_idx=H5Aget_num_attrs(pFile->iCurrentD);
-	    } else {
-	       intern_idx=H5Aget_num_attrs(pFile->iCurrentG);
-	    }
-	 }
-	 if ((intern_idx == 0)||(intern_idx == idx)) {
-	     pFile->iAtt5.iCurrentIDX = 0;
-	     if (iname != NULL) {
-		free(iname);
-	     } 
-	     return NX_EOD;
-	 }
-	 NXIReportError (NXpData, 
-			    "ERROR: Iteration was not successful");
-	 return NX_ERROR;              
+
+     if (intern_idx > idx) {
+       iRet=H5Aiterate(vid,&idx,attr_info,&iname);
+     } else {
+       iRet=0;
+     } 
+     intern_idx=-1;
+     if (iRet < 0) {
+	   NXIReportError (NXpData, "ERROR iterating through attribute list!");
+	   killAttVID(pFile,vid);
+	   return NX_ERROR;  
+     } 
+     pFile->iAtt5.iCurrentIDX++;
+     if (iname != NULL) {
+       if(strcmp(iname, "NX_class") == 0 && pFile->iCurrentG != 0) {
+	 /*
+	   skip NXclass attribute which is internal 
+	 */
+	 killAttVID(pFile, vid);
+	 return NX5getnextattr(fileid, pName, iLength, iType);
        }
+       strcpy(pName, iname);
+       iname = NULL;
+       free(iname);
+     } else {
+       strcpy(pName,"What is this?");
+     }
+     pFile->iCurrentA = H5Aopen_name(vid, pName);
+     atype  = H5Aget_type(pFile->iCurrentA);
+     aspace = H5Aget_space(pFile->iCurrentA);
+     rank = H5Sget_simple_extent_ndims(aspace);
+     attr_id = H5Tget_class(atype);
+     if (attr_id==H5T_STRING) {
+       iPType=NX_CHAR;
+       rank = H5Tget_size(atype);
+     }
+     if (rank == 0) {
+       rank++;
+     }  
+     iPType = hdf5ToNXType(attr_id,atype);
+     *iType=iPType;
+     *iLength=rank;
+     H5Tclose(atype);
+     H5Sclose(aspace);
+     H5Aclose(pFile->iCurrentA);
+  
+     intern_idx=H5Aget_num_attrs(vid);
+
+     killAttVID(pFile,vid);
+     return NX_OK;
    }
+ /*-------------------------------------------------------------------------*/
 
-
-
-   /*-------------------------------------------------------------------------*/
-
-   NXstatus  NX5getattr (NXhandle fid, char *name, void *data, int* datalen, int* iType)
+   NXstatus  NX5getattr (NXhandle fid, char *name, 
+			 void *data, int* datalen, int* iType)
    {
      pNexusFile5 pFile;
-     int iNew, iRet;
-     hid_t type, atype, glob;
+     int iNew, iRet, vid;
+     hid_t type, atype = -1, glob;
      char pBuffer[256];
 
      pFile = NXI5assert (fid);
      type = *iType;
      glob = 0;  
-     if (type == NX_CHAR)
-     {
-	 type=H5T_C_S1;
-     }
-     else if (type == NX_INT8)
-     {
-	 type=H5T_NATIVE_CHAR;
-     }
-     else if (type == NX_UINT8)
-     {
-	 type=H5T_NATIVE_UCHAR;
-     }
-     else if (type == NX_INT16)
-     {
-	 type=H5T_NATIVE_SHORT;
-     }
-     else if (type == NX_UINT16)
-     {
-	 type=H5T_NATIVE_USHORT;
-     }
-     else if (type == NX_INT32)
-     {
-	 type=H5T_NATIVE_INT;
-     }
-     else if (type == NX_UINT32)
-     {
-	 type=H5T_NATIVE_UINT;
-     }
-     else if (type == NX_FLOAT32)
-     {
-	 type=H5T_NATIVE_FLOAT;
-     }
-     else if (type == NX_FLOAT64)
-     {
-	 type=H5T_NATIVE_DOUBLE;
-     }
-     /* find attribute */
-     if (pFile->iCurrentD != 0) 
-       {
-       /* Dataset attribute */
-       iNew = H5Aopen_name(pFile->iCurrentD, name);
-       } 
-       else 
-       {
-	 /* globale and group attributes */
-	 if (pFile->iCurrentG != 0) {
-	  /* group attribute */
-	  iNew = H5Aopen_name(pFile->iCurrentG, name);
-       } else {
-	  /* global attributes */
-	  glob=H5Gopen(pFile->iFID,"/");
-	  iNew = H5Aopen_name(glob, name);
-       }
-     }
+
+     type = nxToHDF5Type(type);
+
+     vid = getAttVID(pFile);
+     iNew = H5Aopen_name(vid, name);
      if (iNew < 0) {
        sprintf (pBuffer, "ERROR: attribute %s not found", name);
+       killAttVID(pFile,vid);
        NXIReportError (NXpData, pBuffer);
        return NX_ERROR;
      }
@@ -1974,14 +1821,13 @@ static void ignoreError(void *data, char *text){
      if (iRet < 0) {
        sprintf (pBuffer, "ERROR: HDF could not read attribute data");
        NXIReportError (NXpData, pBuffer);
+       killAttVID(pFile,vid);
        return NX_ERROR;
      }
 
      iRet = H5Aclose(pFile->iCurrentA);
-     if (glob > 0)
-     {
-     H5Gclose(glob);
-     }
+
+     killAttVID(pFile,vid);
      if (type==H5T_C_S1)
      {
        H5Tclose(atype);
@@ -1994,61 +1840,27 @@ static void ignoreError(void *data, char *text){
    NXstatus  NX5getattrinfo (NXhandle fid, int *iN)
    {
      pNexusFile5 pFile;
-     char *iname = NULL; 
      unsigned int idx;
-     herr_t iRet;
+     int vid;
 
      pFile = NXI5assert (fid);
      idx=0;
      *iN = idx;
-     if (pFile->iCurrentD == 0 && pFile->iCurrentG == 0) {
-       /*
-	 global attribute
-       */
-	pFile->iVID=H5Gopen(pFile->iFID,"/");
-	iRet = H5Aiterate(pFile->iVID,&idx,attr_info,&iname);
-	if (iRet < 0) {
-	   NXIReportError (NXpData, "iterating ERROR!");
-	   return NX_ERROR;  
-	}      
-	idx=H5Aget_num_attrs(pFile->iVID);
 
-	if (idx > 0) {
-	  *iN = idx;
-	} else {
-	  *iN = 1;   
-	}
-	/*
-	if (iname != NULL) {
-	    free(iname);
-	} 
-	*/ 
-	return NX_OK;
-     } 
-     else
-     {
-       if (pFile->iCurrentD>0) {
-	 iRet=H5Aiterate(pFile->iCurrentD,&idx,attr_info,&iname);
+     vid = getAttVID(pFile);
+
+     idx=H5Aget_num_attrs(vid);
+     if (idx > 0) {
+       if(pFile->iCurrentG > 0 && pFile->iCurrentD == 0){
+	 *iN = idx -1; 
        } else {
-	 iRet=H5Aiterate(pFile->iCurrentG,&idx,attr_info,&iname);
+	 *iN = idx;
        }
+     } else {
+       *iN = 0;   
      }
-     if (iRet<0) {
-       NXIReportError (NXpData, "Attribute number cannot be fixed!");
-       return NX_ERROR;
-     }
-     if ((idx==0) && (iRet==0)) {
-	*iN=idx;
-	return NX_OK;
-     }
-       idx=H5Aget_num_attrs(pFile->iCurrentD);
-       if (idx > 0) {
-	  *iN = idx;
-       } else {
-	  *iN = 1;   
-       }
+     killAttVID(pFile,vid);
      return NX_OK;
-
    }
 
 
@@ -2056,25 +1868,27 @@ static void ignoreError(void *data, char *text){
    NXstatus  NX5getgroupID (NXhandle fileid, NXlink* sRes)
   {
     pNexusFile5 pFile;
-    int u;
-    char group_name[64], class_name[64];
+    int datalen, type = NX_CHAR;
+    ErrFunc oldErr;
   
     pFile = NXI5assert (fileid);
     if (pFile->iCurrentG == 0) {
       return NX_ERROR;
     } 
     else {
-      strcpy(sRes->iRef5,"/");
-      NX5getgroupinfo(fileid, &u, group_name,class_name);
-      strcat(sRes->iRef5,group_name);
-      strcpy(sRes->iTag5,"/");
-      strcat(sRes->iTag5, pFile->iCurrentLGG); 
-      strcpy(sRes->iRefd,"");
       /*
-	TODO: once we have group attributes, this should be set to 
-	the groups target attribute
+	this means: if the item is already linked: use the target attribute, else 
+	the path to the current node
       */
-      strcpy(sRes->targetPath, sRes->iTag5);
+      oldErr = NXMGetError();
+      NXMSetError(NXpData, ignoreError);
+      datalen = 1024;
+      memset(sRes->targetPath,0,datalen*sizeof(char));
+      if(NX5getattr(fileid,"target",sRes->targetPath,&datalen,&type) != NX_OK){
+	buildCurrentPath(pFile,sRes->targetPath,1024);
+      }
+      NXMSetError(NXpData,oldErr);
+      sRes->linkType = 0;
       return NX_OK;
     }
     /* not reached */
diff --git a/network.c b/network.c
index 3639cae9..ad127726 100644
--- a/network.c
+++ b/network.c
@@ -609,7 +609,7 @@ int NETReadTillTerm(mkChannel *self, long timeout,
             pBuffer[bufPtr] = '\0';
             return bufPtr;
           } else {
-            matchIndex == 1;
+            matchIndex = 1;
           }
         }
       }
@@ -668,6 +668,89 @@ int NETReadTillTerm(mkChannel *self, long timeout,
           return 1;
           
    }
+/*---------------------------------------------------------------------------*/
+int NETReconnectWithFlags(mkChannel* self, int flags)
+{
+  int iRet;
+  int sock;
+  int oldopts;
+
+  /*
+   * Get the flags and close the old socket
+   */
+  oldopts = fcntl(self->sockid, F_GETFL, 0);
+  close(self->sockid);
+  /* Reopen and try to get it on the olf fd */
+  sock = socket(AF_INET,SOCK_STREAM,0);
+  if (self->sockid != sock) {
+    iRet = fcntl(sock, F_DUPFD, self->sockid);
+    if (iRet != sock)
+      self->sockid = sock;
+    else
+      close(sock);
+    sock = self->sockid;
+  }
+  /* restore the old flags */
+  fcntl(self->sockid, F_SETFL, oldopts);
+  /* set socket non-blocking */
+  oldopts = fcntl(self->sockid, F_GETFL, 0);
+  if (/*(flags & 1) &&*/ !(oldopts & O_NONBLOCK))
+    fcntl(self->sockid, F_SETFL, oldopts | O_NONBLOCK);
+  /* try to reconnect */
+  iRet = connect(self->sockid,
+      (struct sockaddr *)&(self->adresse),
+      sizeof(struct sockaddr_in));
+  if (iRet < 0) {
+    if (errno == EINPROGRESS) {
+      if ((flags & 1)) {
+        iRet = 0; /* in progress */
+      } else {
+        fd_set rmask;
+        fd_set wmask;
+        struct timeval tmo = {1,0};
+
+        FD_ZERO(&rmask);
+        FD_ZERO(&wmask);
+        FD_SET(self->sockid, &rmask);
+        FD_SET(self->sockid, &wmask);
+        iRet = select(self->sockid+1, &rmask, &wmask, NULL, &tmo);
+        if (iRet < 0) /* error */
+          iRet = -1;
+        else if (iRet == 0) /* timeout */
+          iRet = 0; /* in progress */
+        else {
+          char reply[1];
+          if (FD_ISSET(self->sockid, &rmask)) {
+            iRet = recv(self->sockid, reply, 1, MSG_PEEK);
+            if (iRet <= 0)
+              iRet = -1; /* failure */
+          }
+          if (FD_ISSET(self->sockid, &wmask)) {
+            iRet = send(self->sockid, NULL, 0, 0);
+            if (iRet < 0)
+              iRet = -1; /* failure */
+            else
+              iRet = 1; /* success */
+          }
+        }
+      }
+    }
+    else /* other error */
+      iRet = -1; /* error */
+  }
+  else
+    iRet = 1; /* success */
+  
+  if (iRet != 0 && !(oldopts & O_NONBLOCK))
+    fcntl(self->sockid, F_SETFL, oldopts);
+  return iRet;
+}
+
+int NETReconnect(mkChannel* self)
+{
+  return NETReconnectWithFlags(self, 0);
+}
+
 /* ################### UDP -functions ######################################*/
    mkChannel *UDPOpen(int iPort)
    {
diff --git a/network.h b/network.h
index 455d96f5..900d035a 100644
--- a/network.h
+++ b/network.h
@@ -76,10 +76,22 @@
            of hostname are copied to pComposter
         */                		                 
 
+        int NETReconnect(mkChannel* self);
+        /* If a connection has been lost, try to reconnect using the same
+         * socket id if possible. Blocks for up to one second.
+         *  returns 0 if in progress, 1 on success, a negative value on error
+         */
+
+        int NETReconnectWithFlags(mkChannel* self, int flags);
+        /* If a connection has been lost, try to reconnect using the same
+         * socket id if possible. If (flags & 1) do not block, use
+         * NETConnectFinished to check success.
+         *  returns 0 if in progress, 1 on success, a negative value on error
+         */
 /* *********************** DATA TRANSFER ******************************** */
 
 	int NETWrite(mkChannel *self, char *buffer, long lLen);
-	/* writes data to socket self, returns True if succes,
+	/* writes data to socket self, returns True if success,
 	   false otherwise.
 	*/
 	
diff --git a/nserver.c b/nserver.c
index 51c27bad..1da4d8f5 100644
--- a/nserver.c
+++ b/nserver.c
@@ -45,6 +45,8 @@
   extern void StopExit(void); /* in SICSmain.c */
   
   extern int openDevexecLog(); /* in devexec.c */
+  
+  extern void NetWatchInit(void);  /* in nwatch.c */
 /* ========================= Less dreadful file statics =================== */
 
 #define DEFAULTINIFILE "servo.tcl"
@@ -110,6 +112,9 @@
     assert(TaskerInit(&self->pTasker));
      
      pSICSOptions = IFAddOption(pSICSOptions, "ConnectionCount","0");
+   
+    /* initialize the network watcher */
+    NetWatchInit();  
      
     /* initialise the server from script */
     if(file == NULL)
diff --git a/nwatch.c b/nwatch.c
new file mode 100644
index 00000000..bf024ccc
--- /dev/null
+++ b/nwatch.c
@@ -0,0 +1,464 @@
+/*
+ * N E T   W A T C H E R
+ *
+ * This module watches network connections for sockets becoming readable or
+ * writeable and invokes callbacks. It also provides a timer mechanism.
+ *
+ * Douglas Clowes, February 2007
+ *
+ */
+
+#include <stdlib.h>
+#include <assert.h>
+#ifdef CYGNUS
+#include <sys/socket.h>
+#else
+#include <sys/select.h>
+#endif
+#include <sys/time.h>
+#include "fortify.h"
+#include "nwatch.h"
+#include "sics.h"
+
+#define NWMAGIC 51966
+
+/* Net Watcher control structure */
+typedef struct __netwatcher_s {
+  pNWContext  cq_head;  /* head of socket context queue */
+  pNWContext  cq_tail;  /* tail of socket context queue */
+  int         nInvalid; /* number of invalidated entries */
+  pNWTimer    tq_head;  /* head of timer context queue */
+  pNWTimer    tq_tail;  /* tail of timer context queue */
+  long        lMagic;   /* integrity check */
+} NetWatch, *pNetWatch;
+
+/* Singleton pattern */
+static pNetWatch instance = NULL;
+
+static int NetWatchTask(void* pData);
+
+/**
+ * \brief Initialises the Net Watcher singleton and starts the task
+ *
+ * \return 1=success, 0=failure
+ */
+int NetWatchInit(void) {
+  /*
+   * If the singleton has not yet been created, do so now
+   */
+  if (instance == NULL) {
+    instance = (pNetWatch) malloc(sizeof(NetWatch));
+    if (instance == NULL)
+      return 0;
+    memset(instance, 0, sizeof(NetWatch));
+    instance->lMagic = NWMAGIC;
+    TaskRegister(pServ->pTasker, NetWatchTask, NULL, NULL, NULL, 1);
+  }
+  return 1;
+}
+
+/*
+ * The timer context object private definition
+ */
+typedef struct __netwatchtimer {
+  pNWTimer    next;   /* chain to next event */
+  struct timeval tv;  /* time when event is due */
+  pNWCallback func;   /* function to call */
+  void*       cntx;   /* abstract context to pass to callback */
+  long int    tick;   /* millisecond repeat rate */
+  long int    vrfy;   /* integrity check */
+} NWTimer;
+
+/*
+ * \brief private function to insert an entry into the sorted timer queue.
+ *
+ * \param self singleton
+ * \param handle new timer to insert
+ */
+static int NetWatchTimerInsQue(pNetWatch self, pNWTimer handle)
+{
+  /* if the queue is empty, just stick new one in */
+  if (self->tq_head == NULL) {
+    self->tq_head = self->tq_tail = handle;
+    handle->next = NULL;
+    return 1;
+  }
+  /* if new one is not earlier than latest one, insert after latest */
+  if (handle->tv.tv_sec > self->tq_tail->tv.tv_sec ||
+      (handle->tv.tv_sec == self->tq_tail->tv.tv_sec &&
+       handle->tv.tv_usec >= self->tq_tail->tv.tv_usec)) {
+    self->tq_tail->next = handle;
+    self->tq_tail = handle;
+    handle->next = NULL;
+    return 1;
+  }
+  /* if new one is not later than earliest one, insert before earliest */
+  if (handle->tv.tv_sec < self->tq_head->tv.tv_sec ||
+      (handle->tv.tv_sec == self->tq_head->tv.tv_sec &&
+       handle->tv.tv_usec <= self->tq_head->tv.tv_usec)) {
+    handle->next = self->tq_head;
+    self->tq_head = handle;
+    return 1;
+  }
+  else
+  {
+    /* must be in between two so start at the first entry */
+    pNWTimer pNxt = self->tq_head;
+    /* follow chain until the one after this one is greater than new one */
+    while (pNxt->next &&
+        (handle->tv.tv_sec > pNxt->next->tv.tv_sec ||
+         (handle->tv.tv_sec == pNxt->next->tv.tv_sec &&
+          handle->tv.tv_usec > pNxt->next->tv.tv_usec)))
+      pNxt = pNxt->next;
+    /* slip new one in between this one and the next one */
+    handle->next = pNxt->next;
+    pNxt->next = handle ;
+  }
+  return 1;
+}
+
+/*
+ * \brief private function to remove an entry from the sorted timer queue.
+ *
+ * \param self singleton
+ * \param handle existing timer to remove
+ */
+static int NetWatchTimerRemQue(pNetWatch self, pNWTimer handle)
+{
+  /* handle the case of first and possibly only */
+  if (handle == self->tq_head) {
+    self->tq_head = self->tq_head->next;  /* may be NULL */
+    if (handle == self->tq_tail)
+      self->tq_tail = NULL;
+  }
+  /* handle general case */
+  else {
+    pNWTimer pNxt = self->tq_head;
+    while (pNxt) {
+      if (handle == pNxt->next) {
+        pNxt->next = pNxt->next->next;
+        break;
+      }
+      pNxt = pNxt->next;
+    }
+    /* It it was the last entry, point tail to its predecessor */
+    if (handle == self->tq_tail)
+      self->tq_tail = pNxt;
+  }
+  return 1;
+}
+
+int NetWatchRegisterTimer(pNWTimer* handle, int mSec,
+    pNWCallback callback, void* context)
+{
+  pNetWatch self = instance;
+  if(!self || self->lMagic != NWMAGIC)
+    return 0;
+  pNWTimer pNew = (pNWTimer) malloc(sizeof(NWTimer));
+  if (pNew == NULL)
+    return 0;
+  memset(pNew, 0, sizeof(NWTimer));
+  gettimeofday(&pNew->tv, NULL);
+  pNew->tv.tv_sec += mSec / 1000;
+  pNew->tv.tv_usec += 1000 * (mSec % 1000);
+  if (pNew->tv.tv_usec > 1000000) {
+    pNew->tv.tv_sec ++;
+    pNew->tv.tv_usec -= 1000000;
+  }
+  pNew->tick = 0;
+  pNew->func = callback;
+  pNew->cntx = context;
+  pNew->vrfy = NWMAGIC;
+  NetWatchTimerInsQue(self, pNew);
+  *handle = pNew;
+  return 1;
+}
+
+int NetWatchRegisterTimerPeriodic(pNWTimer* handle, int mSecInitial, int mSecPeriod,
+    pNWCallback callback, void* context)
+{
+  if (NetWatchRegisterTimer(handle, mSecInitial, callback, context)) {
+    pNWTimer pNew = *handle;
+    if (pNew == NULL)
+      return 0;
+    if (mSecPeriod > 0)
+      pNew->tick = mSecPeriod;
+    return 1;
+  }
+  return 0;
+}
+
+int NetWatchGetTimerPeriod(pNWTimer handle)
+{
+  if (handle == NULL || handle->vrfy != NWMAGIC)
+    return 0;
+  return handle->tick;
+}
+
+int NetWatchSetTimerPeriod(pNWTimer handle, int mSecPeriod)
+{
+  if (handle == NULL || handle->vrfy != NWMAGIC)
+    return 0;
+  handle->tick = mSecPeriod;
+  return 1;
+}
+
+int NetWatchRemoveTimer(pNWTimer handle)
+{
+  pNetWatch self = instance;
+  if (!self || self->lMagic != NWMAGIC)\
+    return 0;
+  NetWatchTimerRemQue(self, handle);
+  handle->vrfy = 0;
+  free(handle);
+  return 1;
+}
+
+/* private data */
+typedef struct __netwatchcontext {
+  pNWContext  next; /* chain pointer */
+  int         sock; /* socket to watch */
+  int         mode; /* read or write */
+  pNWCallback func; /* user supplied callback function */
+  void*       cntx; /* user supplied callback context */
+  long        vrfy; /* integrity check */
+} NWContext;
+
+/**
+ * \brief private function to insert entry into unsorted queue
+ *
+ * \param self singleton
+ * \param handle entry to insert
+ */
+static int NetWatchContextInsQue(pNetWatch self, pNWContext handle)
+{
+  if (self->cq_head == NULL) /* empty */
+    self->cq_head = self->cq_tail = handle;
+  else {
+    self->cq_tail->next = handle;
+    self->cq_tail = handle;
+  }
+  return 1;
+}
+
+/**
+ * \brief private function to remove entry from unsorted queue
+ *
+ * \param self singleton
+ * \param handle entry to insert
+ */
+static void NetWatchContextRemQue(pNetWatch self, pNWContext handle)
+{
+  if (handle == self->cq_head) { /* if first */
+    self->cq_head = self->cq_head->next;
+    if (handle == self->cq_tail) /* if also last */
+      self->cq_tail = NULL;
+  }
+  else {
+    pNWContext pNxt = self->cq_head;
+    while (pNxt) {
+      if (handle == pNxt->next) {
+        pNxt->next = pNxt->next->next;
+        break;
+      }
+      pNxt = pNxt->next;
+    }
+    if (handle == self->cq_tail) /* if last */
+      self->cq_tail = pNxt;
+  }
+  return;
+}
+
+/**
+ * \brief private function to purge invalid entries
+ *
+ * \param self singleton
+ */
+static void NetWatchContextPrgQue(pNetWatch self)
+{
+  pNWContext pNxt = NULL;
+  /* while the first entry is invalid remove it */
+  while (self->cq_head && self->cq_head->sock < 0) {
+    pNWContext tmp = NULL;
+    tmp = self->cq_head;
+    self->cq_head = self->cq_head->next;
+    tmp->vrfy = 0;
+    free(tmp);
+  }
+  pNxt = self->cq_head;
+  while (pNxt) {
+    if (pNxt->next && pNxt->next->sock < 0) {
+      pNWContext tmp = NULL;
+      tmp = pNxt->next;
+      pNxt->next = pNxt->next->next;
+      tmp->vrfy = 0;
+      free(tmp);
+    }
+    pNxt = pNxt->next;
+  }
+  /* if the queue is empty clear the tail */
+  if (self->cq_head == NULL)
+    self->cq_tail = pNxt;
+  self->nInvalid = 0;
+  return;
+}
+
+int NetWatchRegisterCallback(pNWContext* handle, int iSocket,
+    pNWCallback callback, void* context)
+{
+  pNWContext pNew = NULL;
+  pNetWatch self = instance;
+  if(!self || self->lMagic != NWMAGIC)
+    return 0;
+  if (iSocket < 0 || iSocket > 65535)
+    return 0;
+  pNew = (pNWContext) malloc(sizeof(NWContext));
+  if (pNew == NULL)
+    return 0;
+  memset(pNew, 0, sizeof(NWContext));
+  pNew->sock = iSocket;
+  pNew->mode = nwatch_read;
+  pNew->func = callback;
+  pNew->cntx = context;
+  pNew->vrfy = NWMAGIC;
+  *handle = pNew;
+  NetWatchContextInsQue(self, pNew);
+  return 1;
+}
+
+int NetWatchRemoveCallback(pNWContext handle)
+{
+  pNetWatch self = instance;
+  if (handle == NULL || handle->vrfy != NWMAGIC)
+    return 0;
+  if(!self || self->lMagic != NWMAGIC)
+    return 0;
+  handle->sock = -1;
+  self->nInvalid++;
+  return 1;
+}
+
+int NetWatchGetMode(pNWContext handle)
+{
+  if (handle == NULL || handle->vrfy != NWMAGIC)
+    return 0;
+  return handle->mode;
+}
+
+int NetWatchSetMode(pNWContext handle, int mode)
+{
+  if (handle == NULL || handle->vrfy != NWMAGIC)
+    return 0;
+  handle->mode = mode;
+  return 1;
+}
+
+/**
+ * \brief the registered SICS Task to drive all this
+ */
+int NetWatchTask (void* pData)
+{
+  pNetWatch self = NULL;
+  pNWContext pNWC = NULL;
+  fd_set rMask;
+  fd_set wMask;
+  struct timeval tmo = {0,0};
+  int iRet;
+  int iCount;
+
+  /* Check the singleton */
+  self = (pNetWatch) instance;
+  if(!self || self->lMagic != NWMAGIC)
+    return 0;
+
+  /* Purge the invalidated */
+  if (self->nInvalid > 0)
+    NetWatchContextPrgQue(self);
+
+  /* build the select  mask */
+  FD_ZERO(&rMask);
+  FD_ZERO(&wMask);
+  pNWC = self->cq_head;
+  iCount = -1;
+  while(pNWC) {
+    if (pNWC->sock >= 0 && pNWC->sock <= 65535) {
+      if (pNWC->mode & nwatch_read)
+        FD_SET(pNWC->sock,&rMask);
+      if (pNWC->mode & nwatch_write)
+        FD_SET(pNWC->sock,&wMask);
+      if(pNWC->sock > iCount) {
+        iCount = pNWC->sock;
+      }
+    }
+    pNWC = pNWC->next;
+  }
+
+  iRet = 0;
+  if (iCount >= 0)
+    iRet = select(iCount+1, &rMask, &wMask, NULL, &tmo);
+
+  if(iRet > 0) {
+    /* invoke the active callbacks */
+    iCount = 0;
+    pNWC = self->cq_head;
+    while(pNWC)
+    {
+      if (pNWC->sock >= 0 && pNWC->sock <= 65535) {
+        int action_mode = 0;
+        if ((pNWC->mode & nwatch_read) && FD_ISSET(pNWC->sock, &rMask))
+          action_mode |= nwatch_read;
+        if ((pNWC->mode & nwatch_write) && FD_ISSET(pNWC->sock, &wMask))
+          action_mode |= nwatch_write;
+        if (action_mode != 0) {
+          int iStatus;
+          iStatus = (*pNWC->func)(pNWC->cntx, action_mode);
+        }
+      }
+      pNWC = pNWC->next;
+    }
+  }
+
+  /* Now do the timers */
+  if (self->tq_head) {
+    int iStatus;
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    while (self->tq_head) {
+      pNWTimer pNew = self->tq_head;
+      if (tv.tv_sec < pNew->tv.tv_sec ||
+          (tv.tv_sec == pNew->tv.tv_sec  &&
+           tv.tv_usec < pNew->tv.tv_usec)) {
+        break;
+      }
+      NetWatchTimerRemQue(self, pNew);
+      iStatus = pNew->func(pNew->cntx, 0);
+      /*
+       * If this is a recurrent timer and the function
+       * indicates to keep it going, put it back in
+       */
+      if (pNew->tick && iStatus == 1) {
+        /*
+         * While the expiration time is in the past, increment
+         */
+        gettimeofday(&tv, NULL);
+        while (tv.tv_sec > pNew->tv.tv_sec ||
+            (tv.tv_sec == pNew->tv.tv_sec  &&
+             tv.tv_usec > pNew->tv.tv_usec)) {
+          pNew->tv.tv_usec += 1000 * pNew->tick;
+          if (pNew->tv.tv_usec > 1000000) {
+            pNew->tv.tv_sec += pNew->tv.tv_usec / 1000000;
+            pNew->tv.tv_usec %= 1000000;
+          }
+        }
+        NetWatchTimerInsQue(self, pNew);
+      }
+      else {
+        pNew->vrfy = 0;
+        free(pNew);
+      }
+    }
+  }
+
+  /* done, finally */
+  return 1;
+}
diff --git a/nwatch.h b/nwatch.h
new file mode 100644
index 00000000..fbaeda14
--- /dev/null
+++ b/nwatch.h
@@ -0,0 +1,105 @@
+/*
+ * N E T   W A T C H E R
+ *
+ * This module watches network connections for sockets becoming readable or
+ * writeable and invokes callbacks. It also provides a timer mechanism.
+ *
+ * Douglas Clowes, February 2007
+ *
+ */
+#ifndef SICSNETWATCHER
+#define SICSNETWATCHER
+
+#define nwatch_read 1
+#define nwatch_write 2
+/**
+ * \brief network or timer callback function
+ *
+ * \param context from the network/timer registration
+ * \param mode
+ *    for network, nwatch_read or nwatch_write
+ *    for timer, zero, reserved for future use
+ *
+ * \return normally zero, for future use
+ */
+typedef int (*pNWCallback)(void* context, int mode);
+
+/* the abstract timer object handle */
+typedef struct __netwatchtimer *pNWTimer;
+
+/**
+ * \brief register a one-shot timer event
+ *
+ * \param handle pointer to location to receive the timer object handle
+ * \param mSec milliseconds after which the timer should expire
+ * \param callback function when timer expires
+ * \param context abstract context passed to callback function
+ * \return success=1, failure=0
+ */
+int NetWatchRegisterTimer(pNWTimer* handle, int mSec,
+    pNWCallback callback, void* context);
+
+/**
+ * \brief register a periodic timer
+ *
+ * \param handle pointer to location to receive the timer object handle
+ * \param mSec milliseconds after which the timer should expire
+ * \param mSecPeriod milliseconds after which the timer should repeat
+ * \param callback function when timer expires
+ * \param context abstract context passed to callback function
+ * \return success=1, failure=0
+ */
+int NetWatchRegisterTimerPeriodic(pNWTimer* handle, int mSecInitial, int mSecPeriod,
+    pNWCallback callback, void* context);
+
+int NetWatchGetTimerPeriod(pNWTimer handle);
+int NetWatchSetTimerPeriod(pNWTimer handle, int mSecPeriod);
+/**
+ * \brief remove a registered timer event
+ *
+ * \param handle from the timer registration
+ * \return success=1, failure=0
+ */
+int NetWatchRemoveTimer(pNWTimer handle);
+
+/* the abstract socket object handle */
+typedef struct __netwatchcontext *pNWContext;
+
+/**
+ * \brief register a socket to be watched in read mode
+ *
+ * \param handle pointer to location to receive the socket object handle
+ * \param iSocket file descriptor number of the socket to watch
+ * \param callback function when socket readable/writeable
+ * \param context abstract context passed to callback function
+ * \return success=1, failure=0
+ */
+int NetWatchRegisterCallback(pNWContext* handle, int iSocket,
+    pNWCallback callback, void* context);
+
+/**
+ * \brief remove a socket callback registration
+ *
+ * \param handle from the socket registration
+ * \return success=1, failure=0
+ */
+int NetWatchRemoveCallback(pNWContext handle);
+
+/**
+ * \brief retrieve the mode of a socket callback registration
+ *
+ * \param handle from the socket registration
+ * \return 0=failure else the mode (read and/or write)
+ */
+int NetWatchGetMode(pNWContext handle);
+
+/**
+ * \brief set the mode of a socket callback registration
+ *
+ * \param handle from the socket registration
+ * \param mode read and/or write 
+ * \return 0=failure, 1=success
+ */
+int NetWatchSetMode(pNWContext handle, int mode);
+
+#endif /* SICSNETWATCHER */
diff --git a/ofac.c b/ofac.c
index 3489ef06..ccc8576f 100644
--- a/ofac.c
+++ b/ofac.c
@@ -122,6 +122,8 @@
 #include "multicounter.h"
 #include "sicspoll.h"
 #include "statemon.h"
+#include "asyncqueue.h"
+#include "asyncprotocol.h"
 /*----------------------- Server options creation -------------------------*/
   static int IFServerOption(SConnection *pCon, SicsInterp *pSics, void *pData,
                      int argc, char *argv[])
@@ -250,6 +252,7 @@
      AddCommand(pInter,"help",SicsHelp,KillHelp,NULL);
      AddCommand(pInter,"list",SicsList,NULL,NULL);
      AddCommand(pInter,"InstallHdb",InstallSICSHipadaba,NULL,NULL);
+     MakeProtocol(pInter);
 
      /* commands to do with the executor. Only StopExe carries the
         DeleteFunction in order to avoid double deletion. All the
@@ -326,8 +329,6 @@
 	       McStasReaderFactory,NULL,NULL);
     AddCommand(pInter,"MakeMcStasController",
 	       McStasControllerFactory,NULL,NULL);
-     AddCommand(pInter,"InstallProtocolHandler",
-	       InstallProtocol,NULL,NULL);
      AddCommand(pInter,"InstallSinfox",
            InstallSinfox,NULL,NULL);
      AddCommand(pInter,"MakeCone",
@@ -338,6 +339,8 @@
            InstallSICSPoll,NULL,NULL);
      AddCommand(pInter,"MakeStateMon",
            StateMonFactory,NULL,NULL);
+     AddCommand(pInter,"MakeAsyncProtocol",AsyncProtocolFactory,NULL,NULL);
+     AddCommand(pInter,"MakeAsyncQueue",AsyncQueueFactory,NULL,NULL);
 
     /*
       install site specific commands
@@ -403,11 +406,12 @@
     RemoveCommand(pSics,"MakeTasUB");
     RemoveCommand(pSics,"MakeTasScan");
     RemoveCommand(pSics,"MakemcStasReader");
-    RemoveCommand(pSics,"InstallProtocolHandler");
     RemoveCommand(pSics,"InstallSinfox");
     RemoveCommand(pSics,"MakeCone"); 
     RemoveCommand(pSics,"MakeMultiCounter"); 
     RemoveCommand(pSics,"MakeStateMon"); 
+    RemoveCommand(pSics,"MakeAsyncQueue"); 
+    RemoveCommand(pSics,"MakeAsyncProtocol"); 
     /*
       remove site specific installation commands
     */
diff --git a/protocol.c b/protocol.c
index 98eb6f2e..a7d6b091 100644
--- a/protocol.c
+++ b/protocol.c
@@ -21,8 +21,8 @@
 #define MAXMSG 1024
 #define INIT_STR_SIZE 256
 #define STR_RESIZE_LENGTH   256
-#define NUMPROS 5
-#define PROLISTLEN 6
+#define NUMPROS 6
+#define PROLISTLEN 7
 typedef struct __Protocol {
     pObjectDescriptor pDes;  /* required as first field */
     char *name;              /* protocol handler name */
@@ -106,6 +106,7 @@ pProtocol CreateProtocol(void)
                       "withcode",
                       "sycamore",
                       "json",
+                      "act",
                        NULL
                      };
     pProtocol pNew = NULL;
@@ -217,7 +218,16 @@ int InstallProtocol(SConnection *pCon, SicsInterp *pSics, void *pData,
     SCSendOK(pCon);
     return 1;    
 }
-
+/*------------------------------------------------------------------------*/
+void MakeProtocol(SicsInterp *pSics){
+    pProtocol pNew = NULL;    
+    pNew = CreateProtocol();
+    if(NULL!= pNew)
+    {
+        AddCommand(pSics,"Protocol",ProtocolAction,DeleteProtocol,pNew);
+        AddCommand(pSics,"contextdo",ContextDo,NULL,NULL);
+    }
+}
 /*------------------------------------------------------------------------*/
 static int ProtocolOptions(SConnection* pCon, pProtocol pPro)
 {
@@ -281,6 +291,9 @@ static int ProtocolSet(SConnection* pCon, Protocol* pPro, char *pProName)
       case  4: /* json */
             SCSetWriteFunc(pCon,SCWriteJSON_String);
             break; 
+      case 5:
+            SCSetWriteFunc(pCon,SCACTWrite);
+            break;
       case  0: /* default = psi_sics */
       default:
             SCSetWriteFunc(pCon,pPro->defaultWriter);
@@ -327,6 +340,7 @@ int ProtocolGet(SConnection* pCon, void* pData, char *pProName, int len)
       case  2: /* outcodes */
       case  3: /* sycamore */
       case  4: /* json */
+      case  5: /* act */
             pProName = pPro->pProList[Index];
             return 1;
             break;
@@ -785,3 +799,26 @@ int GetProtocolID(SConnection* pCon)
     }
     return -1;
 }
+/*---------------------------------------------------------------------------*/
+writeFunc GetProtocolWriteFunc(SConnection *pCon){
+    if(pCon != NULL){
+        switch(pCon->iProtocolID){
+            case  2: /* outcodes */
+                return SCWriteWithOutcode;
+                break;
+            case  3: /* sycamore */
+                 return SCWriteSycamore;
+                 break;
+             case  4: /* json */
+                 return SCWriteJSON_String;
+                 break; 
+            case 5:
+                return SCACTWrite;
+                break;
+            default:
+                return SCNormalWrite;
+                break;
+        }
+    }
+    return SCNormalWrite;
+}
diff --git a/protocol.h b/protocol.h
index ff00e813..24d51d72 100644
--- a/protocol.h
+++ b/protocol.h
@@ -19,11 +19,11 @@ static char *pProTags[3] = {
 int InstallProtocol(SConnection *pCon, SicsInterp *pSics, void *pData,
         int argc, char *argv[]);
 void DeleteProtocol(void *pSelf);
+void MakeProtocol(SicsInterp *pSics);
   
 /*--------------------- operations --------------------------------------*/
 int ProtocolAction(SConnection *pCon, SicsInterp *pSics, void *pData,
     int argc, char *argv[]);
-
 /*--------------------- implement protocol sycamore ---------------------*/
 int SCWriteSycamore(SConnection *pCon, char *pBuffer, int iOut);
 
@@ -31,5 +31,6 @@ int SCWriteSycamore(SConnection *pCon, char *pBuffer, int iOut);
 char * GetProtocolName(SConnection *pCon);
 int GetProtocolID(SConnection *pCon);
 int ProtocolGet(SConnection* pCon, void* pData, char *pProName, int len);
+writeFunc GetProtocolWriteFunc(SConnection *pCon);
 /*-----------------------------------------------------------------------*/
 #endif	
diff --git a/sicsdata.c b/sicsdata.c
index 5b274d8a..beb5c7b7 100644
--- a/sicsdata.c
+++ b/sicsdata.c
@@ -180,8 +180,16 @@ static void netEncode(pSICSData self){
 /*---------------------------------------------------------------------*/
 void clearSICSData(pSICSData self){
   assert(self);
+  int clearSize = 8192;
   
   self->dataUsed = 0;
+  if(self->currentDataSize > clearSize){
+    free(self->data);
+    free(self->dataType);
+    self->data = (int *)malloc(clearSize*sizeof(int));
+    self->dataType = (char *)malloc(clearSize*sizeof(char));
+    self->currentDataSize = clearSize;
+  }
   memset(self->data,0,self->currentDataSize*sizeof(int));
   memset(self->dataType,0,self->currentDataSize*sizeof(char));
 }
diff --git a/sicshdbadapter.c b/sicshdbadapter.c
index 44470917..d0974cb7 100644
--- a/sicshdbadapter.c
+++ b/sicshdbadapter.c
@@ -21,6 +21,8 @@
 #include "motor.h"
 #include "HistMem.h"
 #include "sicsvar.h"
+#include "counter.h"
+#include "lld.h"
 #include "sicshipadaba.h"
 #include "sicshdbadapter.h"
 
@@ -411,6 +413,54 @@ static pHdb MakeSicsVarNode(pSicsVariable pVar, char *name){
     node->protected = 1;
     return node;
 }
+/*================ counter =============================================*/
+typedef struct {
+        pHdb node;
+        int monitor; /* -1 == time */
+        pCounter counter;
+} CountEntry;
+static int countList = -10;
+/*---------------------------------------------------------------------*/
+static void updateCountList(){
+    int status;
+    hdbValue v;
+    CountEntry hugo;
+    long monitor;
+    float time;
+    SConnection *pDummy = NULL;
+    
+    if(countList < 0){
+        return;
+    }
+    pDummy = SCCreateDummyConnection(pServ->pSics);
+    if(pDummy == NULL){
+        return;
+    }
+    
+    status = LLDnodePtr2First(countList);
+    while(status != 0){
+        LLDnodeDataTo(countList,&hugo);
+        if(hugo.monitor < 0){
+            time = GetCountTime(hugo.counter,pDummy);
+            v = MakeHdbFloat((double)time);
+            UpdateHipadabaPar(hugo.node,v, NULL);
+        } else {
+            monitor = GetMonitor(hugo.counter, hugo.monitor, pDummy);
+            v = MakeHdbInt((int)monitor);
+            UpdateHipadabaPar(hugo.node,v, NULL);
+        }
+        status = LLDnodePtr2Next(countList);
+    }
+    SCDeleteConnection(pDummy);    
+}
+/*---------------------------------------------------------------------------*/
+static int CounterCallback(int iEvent, void *eventData, void *userData,
+    commandContext cc){
+    if(iEvent == MONITOR || iEvent == COUNTEND || iEvent == COUNTSTART){
+        updateCountList();
+     }
+     return 1;
+}
 /*============== interpreter function ==================================*/
 int SICSHdbAdapter(SConnection *pCon, SicsInterp *pSics, void *pData,
     int argc, char *argv[]){
@@ -423,6 +473,8 @@ int SICSHdbAdapter(SConnection *pCon, SicsInterp *pSics, void *pData,
     pIDrivable pDriv = NULL;
     pSicsVariable pVar = NULL;
     char buffer[512];
+    pCounter pCount = NULL;
+    CountEntry hugo;
     
     root = GetHipadabaRoot();
     assert(root != NULL);
@@ -505,6 +557,31 @@ int SICSHdbAdapter(SConnection *pCon, SicsInterp *pSics, void *pData,
         return 1;
     }
 
+    /**
+     * look for counters
+     */
+     pCount = (pCounter)FindCommandData(pSics,argv[2],"SingleCounter");
+     if(pCount != NULL){
+        hugo.monitor = atoi(argv[3]);
+        hugo.counter = pCount;
+        hugo.node = path;
+        if(countList < 0){
+            countList = LLDcreate(sizeof(CountEntry));
+            RegisterCallback(pCount->pCall, SCGetContext(pCon), 
+                        COUNTSTART, CounterCallback,
+                        NULL, NULL);
+            RegisterCallback(pCount->pCall, SCGetContext(pCon), 
+                        COUNTEND, CounterCallback,
+                        NULL, NULL);
+            RegisterCallback(pCount->pCall, SCGetContext(pCon), 
+                        MONITOR, CounterCallback,
+                        NULL, NULL);
+        }
+        LLDnodeAppendFrom(countList,&hugo);
+        SCSendOK(pCon);
+        return 1;
+     }
+
     snprintf(buffer,511,
         "ERROR: attaching this type of object: %s  at %s not implemented",
         argv[2], argv[1]);
diff --git a/sicshipadaba.c b/sicshipadaba.c
index e4609add..3a7edaaf 100644
--- a/sicshipadaba.c
+++ b/sicshipadaba.c
@@ -229,7 +229,7 @@ static int SICSNotifyCallback(void *userData, void *callData, pHdb node,
     pDynString result = NULL;
     char *pPath = NULL;
     Protocol protocol = normal_protocol;
-    int outCode;
+    int outCode, macro;
        
     cbInfo = (HdbCBInfo *)userData;
     pPath = GetHipadabaPath(node);
@@ -239,11 +239,17 @@ static int SICSNotifyCallback(void *userData, void *callData, pHdb node,
     else
       outCode = eEvent;
 
+    /*
+     * we want our notifications to come even when called from a macro
+     */
+    macro = SCinMacro(cbInfo->pCon);
+    SCsetMacro(cbInfo->pCon,0);
     if(v.arrayLength < 100){
         printedData = formatValue(v);
         if(pPath == NULL || printedData == NULL || result == NULL){
             SCWriteInContext(cbInfo->pCon,"ERROR: out of memory formatting data" ,
                 eEvent,cbInfo->context);
+             SCsetMacro(cbInfo->pCon,macro);   
             /*
             * no need to interrupt something because writing data to a client does
             * not  work
@@ -259,6 +265,7 @@ static int SICSNotifyCallback(void *userData, void *callData, pHdb node,
         SCWriteInContext(cbInfo->pCon,GetCharArray(result),
                     outCode,cbInfo->context);
     }                
+    SCsetMacro(cbInfo->pCon,macro);   
     free(pPath);
     DeleteDynString(result);
     
diff --git a/status.c b/status.c
index 2aaaca2e..95286395 100644
--- a/status.c
+++ b/status.c
@@ -49,6 +49,7 @@
 #include "status.h"
 #include "interrupt.h"
 #include "devexec.h"
+#include "sicshipadaba.h"
 #undef VALUECHANGE
 #define VALUECHANGE 2
 
@@ -197,13 +198,30 @@
      SCPopContext(pCon);
      return 1;
   }  
-   
+/*------------------- The CallBack function for interest ------------------*/
+  static int StatusHDBCallback(int iEvent, void *pEvent, void *pUser,
+                commandContext cc)
+  {
+     pHdb node = NULL;
+     char pBueffel[80];
+     hdbValue v;
+     
+     assert(pUser);
+  
+     node = (pHdb)pUser;
+     v = MakeHdbText(pText[eCode]);
+     if(node != NULL && iEvent == VALUECHANGE){
+         UpdateHipadabaPar(node,v,NULL);
+     } 
+     return 1;
+  }  
 /*-----------------------------------------------------------------------*/   
    int UserStatus(SConnection *pCon, SicsInterp *pSics, void *pData,
                   int argc, char *argv[])
    {
       char pBueffel[512];
       long lID;
+      pHdb node = NULL;
 
       assert(pSics);
       assert(pCon);
@@ -221,12 +239,33 @@
          if(strcmp(argv[1],"interest") == 0)
          {
              lID = RegisterCallback(pCall, SCGetContext(pCon),
-				    VALUECHANGE, StatusCallback,
+                    VALUECHANGE, StatusCallback,
                                     pCon, NULL);
              SCRegister(pCon,pSics, pCall,lID);
              SCSendOK(pCon);
              return 1;                       
          }
+         else if(strcmp(argv[1],"hdbinterest") == 0)
+        {
+           if(argc > 2){
+                 node = GetHipadabaNode(GetHipadabaRoot(),argv[2]);
+                if(node != NULL){
+                    lID = RegisterCallback(pCall, SCGetContext(pCon),
+                        VALUECHANGE, StatusHDBCallback,
+                                        node, NULL);
+                    /* SCRegister(pCon,pSics, pCall,lID); */
+                    SCSendOK(pCon);
+                    return 1;                       
+                } else {
+                    SCWrite(pCon,"ERROR: Hipadaba node not found",eError);
+                    return 0;
+                }
+           }
+        } else {
+            SCWrite(pCon,"ERROR: require node parameter to register status callback",
+                eError);
+            return 0;
+        }
       }
       
       /* else just print value */
diff --git a/val.lis b/val.lis
index 7f0f572f..48112bb2 100644
--- a/val.lis
+++ b/val.lis
@@ -1,458 +1,9944 @@
-==26623== Memcheck, a memory error detector.
-==26623== Copyright (C) 2002-2005, and GNU GPL'd, by Julian Seward et al.
-==26623== Using LibVEX rev 1575, a library for dynamic binary translation.
-==26623== Copyright (C) 2004-2005, and GNU GPL'd, by OpenWorks LLP.
-==26623== Using valgrind-3.1.1, a dynamic binary instrumentation framework.
-==26623== Copyright (C) 2000-2005, and GNU GPL'd, by Julian Seward et al.
-==26623== For more details, rerun with: -v
-==26623== 
+==6691== Memcheck, a memory error detector.
+==6691== Copyright (C) 2002-2007, and GNU GPL'd, by Julian Seward et al.
+==6691== Using LibVEX rev 1732, a library for dynamic binary translation.
+==6691== Copyright (C) 2004-2007, and GNU GPL'd, by OpenWorks LLP.
+==6691== Using valgrind-3.2.3, a dynamic binary instrumentation framework.
+==6691== Copyright (C) 2000-2007, and GNU GPL'd, by Julian Seward et al.
+==6691== For more details, rerun with: -v
+==6691== 
 WARNING: Cannot log(Accepted dummy connection )
-mcstas/dmc/vdmc.tcl:0>> ServerOption ReadTimeOut  10
-mcstas/dmc/vdmc.tcl:1>> ServerOption AcceptTimeOut 10 
-mcstas/dmc/vdmc.tcl:2>> ServerOption ReadUserPasswdTimeout  500000 
-mcstas/dmc/vdmc.tcl:3>> ServerOption LogFileBaseName  "$home/vdmclog"
-mcstas/dmc/vdmc.tcl:4>> ServerOption LogFileDir  $home/
-mcstas/dmc/vdmc.tcl:5>> ServerOption ServerPort 2911
-mcstas/dmc/vdmc.tcl:6>> ServerOption statusfile $home/vdmcstatus.tcl
-mcstas/dmc/vdmc.tcl:7>> ServerOption InterruptPort 3007
-mcstas/dmc/vdmc.tcl:8>> ServerOption TelnetPort 1301
-mcstas/dmc/vdmc.tcl:9>> ServerOption TelWord sicslogin
-mcstas/dmc/vdmc.tcl:10>> SicsUser lnsmanager lnsSICSlns   1
-mcstas/dmc/vdmc.tcl:11>> SicsUser Manager Manager  1
-mcstas/dmc/vdmc.tcl:12>> SicsUser user    looser   2
-mcstas/dmc/vdmc.tcl:13>> SicsUser Spy    007       1
-mcstas/dmc/vdmc.tcl:14>> ClientPut "Installing Motors"
-Installing Motors
-mcstas/dmc/vdmc.tcl:15>> Motor  OmegaM    SIM 0 120 -.1 2.
-mcstas/dmc/vdmc.tcl:16>> Motor  TwoThetaM SIM 30 100 -.1 1.
-mcstas/dmc/vdmc.tcl:17>> Motor  MonoX     SIM -30 30 -.1 3.0
-mcstas/dmc/vdmc.tcl:18>> Motor  MonoY     SIM -30 30 -.1 3.0
-mcstas/dmc/vdmc.tcl:19>> Motor  CurveM    SIM 0 20 -.1 3.0
-mcstas/dmc/vdmc.tcl:20>> Motor  MonoPhi   SIM -30 30 -.1 3.0
-mcstas/dmc/vdmc.tcl:21>> Motor  MonoChi   SIM -30 30 -.1 3.0
-mcstas/dmc/vdmc.tcl:22>> Motor  Table     SIM -180 360 -.1 2.
-mcstas/dmc/vdmc.tcl:23>> Motor  TwoThetaD SIM -10  120 -.1 1.
-mcstas/dmc/vdmc.tcl:24>> MakeMono Mono "PG-002" OmegaM TwoThetaM CurveM
-mcstas/dmc/vdmc.tcl:25>> Mono DD 3.3537
-mcstas/dmc/vdmc.tcl:26>> Mono vk1 -0.025942
-mcstas/dmc/vdmc.tcl:27>> Mono vk2 5.351660
-mcstas/dmc/vdmc.tcl:28>> MakeWaveLength lambda  Mono
-mcstas/dmc/vdmc.tcl:29>> allowexec $home/dmcafter
-mcstas/dmc/vdmc.tcl:30>> allowexec $home/dmc_sics05
-mcstas/dmc/vdmc.tcl:31>> ClientPut "Installing counter"
-Installing counter
-mcstas/dmc/vdmc.tcl:32>> MakeCounter counter mcstas
-mcstas/dmc/vdmc.tcl:33>> counter SetExponent 1
-mcstas/dmc/vdmc.tcl:34>> MakeHM banana mcstas
-mcstas/dmc/vdmc.tcl:35>> banana configure HistMode Normal
-mcstas/dmc/vdmc.tcl:36>> banana configure OverFlowMode    Ceil
-mcstas/dmc/vdmc.tcl:37>> banana configure Rank     1
-mcstas/dmc/vdmc.tcl:38>> banana configure dim0 400
-mcstas/dmc/vdmc.tcl:39>> banana configure BinWidth 4
-mcstas/dmc/vdmc.tcl:40>> banana preset 100.
-mcstas/dmc/vdmc.tcl:41>> banana CountMode Timer
-mcstas/dmc/vdmc.tcl:42>> banana configure Counter counter
-mcstas/dmc/vdmc.tcl:43>> banana configure init 0
-mcstas/dmc/vdmc.tcl:44>> banana init
-mcstas/dmc/vdmc.tcl:45>> banana exponent 3
-mcstas/dmc/vdmc.tcl:46>> SicsAlias OmegaM    A1
-mcstas/dmc/vdmc.tcl:47>> SicsAlias TwoThetaM A2
-mcstas/dmc/vdmc.tcl:48>> SicsAlias Table     A3
-mcstas/dmc/vdmc.tcl:49>> SicsAlias TwoThetaD A4
-mcstas/dmc/vdmc.tcl:50>> SicsAlias MonoX     A5
-mcstas/dmc/vdmc.tcl:51>> SicsAlias MonoY     A6
-mcstas/dmc/vdmc.tcl:52>> SicsAlias MonoPhi   A7
-mcstas/dmc/vdmc.tcl:53>> SicsAlias MonoChi   A8
-mcstas/dmc/vdmc.tcl:54>> SicsAlias CurveM    A9
-mcstas/dmc/vdmc.tcl:55>> DefineAlias TT temperature
-mcstas/dmc/vdmc.tcl:56>> VarMake SicsDataPath Text Internal
-mcstas/dmc/vdmc.tcl:57>> SicsDataPath "$home/"
-mcstas/dmc/vdmc.tcl:58>> SicsDataPath lock
-mcstas/dmc/vdmc.tcl:59>> VarMake DetStepWidth Float Internal
-mcstas/dmc/vdmc.tcl:60>> DetStepWidth 0.2
-mcstas/dmc/vdmc.tcl:61>> DetStepWidth lock
-mcstas/dmc/vdmc.tcl:62>> VarMake Instrument Text Internal 
-mcstas/dmc/vdmc.tcl:63>> Instrument "Virtual DMC driven by McStas"
-mcstas/dmc/vdmc.tcl:64>> Instrument lock 
-mcstas/dmc/vdmc.tcl:65>> VarMake Title Text User
-mcstas/dmc/vdmc.tcl:66>> VarMake User  Text User
-mcstas/dmc/vdmc.tcl:67>> VarMake Collimation Text User
-mcstas/dmc/vdmc.tcl:68>> VarMake SampleIntern Text User
-mcstas/dmc/vdmc.tcl:69>> SampleIntern Kellerit
-mcstas/dmc/vdmc.tcl:70>> VarMake comment1 Text User
-mcstas/dmc/vdmc.tcl:71>> VarMake comment2 Text User
-mcstas/dmc/vdmc.tcl:72>> VarMake comment3 Text User
-mcstas/dmc/vdmc.tcl:73>> VarMake starttime Text User
-mcstas/dmc/vdmc.tcl:74>> starttime ""
-mcstas/dmc/vdmc.tcl:75>> VarMake SicsDataPrefix Text Internal
-mcstas/dmc/vdmc.tcl:76>> SicsDataPrefix vdmc
-mcstas/dmc/vdmc.tcl:77>> MakeDataNumber SicsDataNumber $home/DataNumber
-mcstas/dmc/vdmc.tcl:78>> VarMake SicsDataPostFix Text Internal
-mcstas/dmc/vdmc.tcl:79>> SicsDataPostFix ".xml"
-mcstas/dmc/vdmc.tcl:80>> VarMake Adress Text User
-mcstas/dmc/vdmc.tcl:81>> VarMake phone  Text User
-mcstas/dmc/vdmc.tcl:82>> VarMake fax    Text User
-mcstas/dmc/vdmc.tcl:83>> VarMake email  Text User
-mcstas/dmc/vdmc.tcl:84>> VarMake sample_mur Float User
-mcstas/dmc/vdmc.tcl:85>> VarMake lastdatafile Text User
+sim/rita2/rita2.tcl:0>> ServerOption RedirectFile $loghome/stdrita2
+sim/rita2/rita2.tcl:1>> ServerOption ReadTimeOut  10 
+sim/rita2/rita2.tcl:2>> ServerOption AcceptTimeOut  10 
+sim/rita2/rita2.tcl:3>> ServerOption ReadUserPasswdTimeout  500000
+sim/rita2/rita2.tcl:4>> ServerOption LogFileBaseName  $loghome/rita2log
+sim/rita2/rita2.tcl:5>> ServerOption LogFileDir  $loghome
+sim/rita2/rita2.tcl:6>> TokenInit connan
+sim/rita2/rita2.tcl:7>> SicsUser lnsmanager lnsSICSlns   1
+sim/rita2/rita2.tcl:8>> SicsUser rita2user  07lns1       2
+sim/rita2/rita2.tcl:9>> Motor  omat  SIM -95. 185. -.1 2.0
+sim/rita2/rita2.tcl:10>> SicsAlias omm a1
+sim/rita2/rita2.tcl:11>> SicsAlias 2tm a2
+sim/rita2/rita2.tcl:12>> SicsAlias cum mcv
+sim/rita2/rita2.tcl:13>> SicsAlias om  a3
+sim/rita2/rita2.tcl:14>> SicsAlias 2t  a4
+sim/rita2/rita2.tcl:15>> SicsAlias gl  sgl
+sim/rita2/rita2.tcl:16>> SicsAlias gu  sgu
+sim/rita2/rita2.tcl:17>> SicsAlias omat a5
+sim/rita2/rita2.tcl:18>> SicsAlias oma aa5
+sim/rita2/rita2.tcl:19>> SicsAlias 2ta a6
+sim/rita2/rita2.tcl:20>> anticollision register 2t
+sim/rita2/rita2.tcl:21>> anticollision register tl
+sim/rita2/rita2.tcl:22>> anticollision register tu
+sim/rita2/rita2.tcl:23>> anticollision register gl
+sim/rita2/rita2.tcl:24>> anticollision register gu
+sim/rita2/rita2.tcl:25>> anticollision register m1
+sim/rita2/rita2.tcl:26>> anticollision register m2
+sim/rita2/rita2.tcl:27>> anticollision register m3
+sim/rita2/rita2.tcl:28>> anticollision register m4
+sim/rita2/rita2.tcl:29>> anticollision register 2ta
+sim/rita2/rita2.tcl:30>> anticollision register oma
+sim/rita2/rita2.tcl:31>> anticollision register om
+sim/rita2/rita2.tcl:32>> anticollision register m5
+sim/rita2/rita2.tcl:33>> anticollision register m6
+sim/rita2/rita2.tcl:34>> anticollision register m7
+sim/rita2/rita2.tcl:35>> anticollision register m8
+sim/rita2/rita2.tcl:36>> anticollision register msb
+sim/rita2/rita2.tcl:37>> anticollision register mst
+sim/rita2/rita2.tcl:38>> anticollision register msl
+sim/rita2/rita2.tcl:39>> anticollision register msr
+sim/rita2/rita2.tcl:40>> anticollision register ssb
+sim/rita2/rita2.tcl:41>> anticollision register sst
+sim/rita2/rita2.tcl:42>> anticollision register ssl
+sim/rita2/rita2.tcl:43>> anticollision register ssr
+sim/rita2/rita2.tcl:44>> anticollision register asb
+sim/rita2/rita2.tcl:45>> anticollision register ast
+sim/rita2/rita2.tcl:46>> anticollision register asl
+sim/rita2/rita2.tcl:47>> anticollision register asr
+sim/rita2/rita2.tcl:48>> anticollision register dsb
+sim/rita2/rita2.tcl:49>> anticollision register dsr
+sim/rita2/rita2.tcl:50>> anticollision register ca1
+sim/rita2/rita2.tcl:51>> anticollision register ca2
+sim/rita2/rita2.tcl:52>> anticollision register ca3
+sim/rita2/rita2.tcl:53>> anticollision register ca4
+sim/rita2/rita2.tcl:54>> anticollision register ca5
+sim/rita2/rita2.tcl:55>> anticollision register ca6
+sim/rita2/rita2.tcl:56>> anticollision register ca7
+sim/rita2/rita2.tcl:57>> anticollision register ca8
+sim/rita2/rita2.tcl:58>> anticollision register ca9
+sim/rita2/rita2.tcl:59>> anticollision register a3
+sim/rita2/rita2.tcl:60>> anticollision register a4
+sim/rita2/rita2.tcl:61>> anticollision register aa5
+sim/rita2/rita2.tcl:62>> anticollision register a6
+sim/rita2/rita2.tcl:63>> anticollision register sgu
+sim/rita2/rita2.tcl:64>> anticollision register sgl
+sim/rita2/rita2.tcl:65>> anticollision register lc
+sim/rita2/rita2.tcl:66>> anticollision register rc
+sim/rita2/rita2.tcl:67>> Publish rita2rack User 
+sim/rita2/rita2.tcl:68>> anticollision script rita2rack
+sim/rita2/rita2.tcl:69>> sicsdatafactory new hmtransfer
+sim/rita2/rita2.tcl:70>> VarMake Instrument Text Internal
+sim/rita2/rita2.tcl:71>> Instrument lock
+sim/rita2/rita2.tcl:72>> VarMake title Text User
+sim/rita2/rita2.tcl:73>> VarMake User  Text User
+sim/rita2/rita2.tcl:74>> VarMake sample Text User
+sim/rita2/rita2.tcl:75>> VarMake email Text User
+sim/rita2/rita2.tcl:76>> VarMake fax   Text User
+sim/rita2/rita2.tcl:77>> VarMake phone Text User
+sim/rita2/rita2.tcl:78>> VarMake address Text User
+sim/rita2/rita2.tcl:79>> VarMake affiliation Text User
+sim/rita2/rita2.tcl:80>> VarMake BatchRoot Text User
+sim/rita2/rita2.tcl:81>> VarMake starttime Text User
+sim/rita2/rita2.tcl:82>> BatchRoot $home
+sim/rita2/rita2.tcl:83>> VarMake __manBox Int User
+sim/rita2/rita2.tcl:84>> __manBox 0 
+sim/rita2/rita2.tcl:85>> VarMake SicsDataPath Text Mugger
+sim/rita2/rita2.tcl:86>> SicsDataPath $datahome/
+sim/rita2/rita2.tcl:87>> SicsDataPath lock
+sim/rita2/rita2.tcl:88>> VarMake SicsDataPrefix Text Mugger
+sim/rita2/rita2.tcl:89>> SicsDataPrefix lock
+sim/rita2/rita2.tcl:90>> VarMake SicsDataPostFix Text Mugger
+sim/rita2/rita2.tcl:91>> SicsDataPostFix ".hdf"
+sim/rita2/rita2.tcl:92>> SicsDataPostFix lock
+sim/rita2/rita2.tcl:93>> MakeDataNumber SicsDataNumber $datahome/DataNumber
+sim/rita2/rita2.tcl:94>> sicsdatafactory new hmdata
+sim/rita2/rita2.tcl:95>> sicsdatafactory new scandata
+sim/rita2/rita2.tcl:96>> sicsdatafactory new qhdata
+sim/rita2/rita2.tcl:97>> sicsdatafactory new qkdata
+sim/rita2/rita2.tcl:98>> sicsdatafactory new qldata
+sim/rita2/rita2.tcl:99>> sicsdatafactory new endata
+sim/rita2/rita2.tcl:100>> sicsdatafactory new qmdata
+sim/rita2/rita2.tcl:101>> sicsdatafactory new a4data
+sim/rita2/rita2.tcl:102>> sicsdatafactory new a5data
+sim/rita2/rita2.tcl:103>> sicsdatafactory new a6data
+sim/rita2/rita2.tcl:104>> sicsdatafactory new windowdata
+sim/rita2/rita2.tcl:105>> sicsdatafactory new blangdata
+sim/rita2/rita2.tcl:106>> sicsdatafactory new efdata
+sim/rita2/rita2.tcl:107>> VarMake alf1 Float User
+sim/rita2/rita2.tcl:108>> VarMake alf2 Float User
+sim/rita2/rita2.tcl:109>> VarMake alf3 Float User
+sim/rita2/rita2.tcl:110>> VarMake alf4 Float User
+sim/rita2/rita2.tcl:111>> VarMake bet1 Float User
+sim/rita2/rita2.tcl:112>> VarMake bet2 Float User
+sim/rita2/rita2.tcl:113>> VarMake bet3 Float User
+sim/rita2/rita2.tcl:114>> VarMake bet4 Float User
+sim/rita2/rita2.tcl:115>> VarMake ETAM Float User
+sim/rita2/rita2.tcl:116>> VarMake ETAS Float User
+sim/rita2/rita2.tcl:117>> VarMake ETAA Float User
+sim/rita2/rita2.tcl:118>> VarMake polfile Text User
+sim/rita2/rita2.tcl:119>> VarMake local Text User
+sim/rita2/rita2.tcl:120>> VarMake lastscancommand Text User
+sim/rita2/rita2.tcl:121>> VarMake output Text User
+sim/rita2/rita2.tcl:122>> commandlog auto
+sim/rita2/rita2.tcl:123>> MakeTasUB tasub
+sim/rita2/rita2.tcl:124>> MakeScanCommand iscan counter tas.hdd recover.bin
+sim/rita2/rita2.tcl:125>> MakePeakCenter iscan
+sim/rita2/rita2.tcl:126>> MakeTasScan iscan tasub
 ERROR: duplicate exe manager not created
-mcstas/dmc/vdmc.tcl:86>> commandlog auto
-mcstas/dmc/vdmc.tcl:87>> commandlog intervall 5
-mcstas/dmc/vdmc.tcl:88>> hmake /dmc spy none
-mcstas/dmc/vdmc.tcl:89>> hsetprop /dmc type instrument
-mcstas/dmc/vdmc.tcl:90>> hmake /dmc/experiment spy none
-mcstas/dmc/vdmc.tcl:91>> hattach /dmc/experiment title title
-mcstas/dmc/vdmc.tcl:92>> hattach /dmc/experiment user user
-mcstas/dmc/vdmc.tcl:93>> hattach /dmc/experiment starttime starttime
-mcstas/dmc/vdmc.tcl:94>> hattach /dmc/experiment user user
-mcstas/dmc/vdmc.tcl:95>> hattach /dmc/experiment/user adress address
-mcstas/dmc/vdmc.tcl:96>> hattach /dmc/experiment/user phone phone
-mcstas/dmc/vdmc.tcl:97>> hattach /dmc/experiment/user email email
-mcstas/dmc/vdmc.tcl:98>> hattach /dmc/experiment comment1 comment1
-mcstas/dmc/vdmc.tcl:99>> hattach /dmc/experiment comment2 comment2
-mcstas/dmc/vdmc.tcl:100>> hattach /dmc/experiment comment3 comment3
-mcstas/dmc/vdmc.tcl:101>> hmake /dmc/sinq spy none
-mcstas/dmc/vdmc.tcl:102>> hmakescript /dmc/sinq/proton_monitor "counter getmonitor 4" hdbReadOnly int  
-mcstas/dmc/vdmc.tcl:103>> sicspoll /dmc/sinq/proton_monitor hdb 10
-mcstas/dmc/vdmc.tcl:104>> hmake /dmc/monochromator spy none    
-mcstas/dmc/vdmc.tcl:105>> hattach /dmc/monochromator lambda wavelength
-mcstas/dmc/vdmc.tcl:106>> hattach /dmc/monochromator OmegaM theta
-mcstas/dmc/vdmc.tcl:107>> hattach /dmc/monochromator TwoThetaM two_theta
-mcstas/dmc/vdmc.tcl:108>> hattach /dmc/monochromator MonoX x_translation
-mcstas/dmc/vdmc.tcl:109>> hattach /dmc/monochromator MonoY y_translation
-mcstas/dmc/vdmc.tcl:110>> hattach /dmc/monochromator MonoChi chi
-mcstas/dmc/vdmc.tcl:111>> hattach /dmc/monochromator MonoPhi phi
-mcstas/dmc/vdmc.tcl:112>> hattach /dmc/monochromator CurveM vertical_focusing
-mcstas/dmc/vdmc.tcl:113>> hmakescript /dmc/monochromator/d_value "mono dd" "mono dd" float
-mcstas/dmc/vdmc.tcl:114>> hsetprop /dmc/monochromator/d_value priv manager
-mcstas/dmc/vdmc.tcl:115>> hmakescript /dmc/monochromator/scattering_sense  "mono ss" "mono ss" int
-mcstas/dmc/vdmc.tcl:116>> hsetprop /dmc/monochromator/scattering_sense priv manager
-mcstas/dmc/vdmc.tcl:117>> hmake /dmc/sample spy none
-mcstas/dmc/vdmc.tcl:118>> hmakescript /dmc/sample/name sample sample Text 
-mcstas/dmc/vdmc.tcl:119>> hattach /dmc/sample Table rotation
-mcstas/dmc/vdmc.tcl:120>> hmakescript /dmc/sample/monitor "counter getmonitor 1" hdbReadOnly int  
-mcstas/dmc/vdmc.tcl:121>> hsetprop /dmc/sample/monitor priv internal
-mcstas/dmc/vdmc.tcl:122>> hmake /dmc/detector spy none
-mcstas/dmc/vdmc.tcl:123>> hattach /dmc/detector TwoThetaD two_theta   
-mcstas/dmc/vdmc.tcl:124>> hmakescript /dmc/detector/preset "counter getpreset" hdbReadOnly float
-mcstas/dmc/vdmc.tcl:125>> hsetprop /dmc/detector/preset priv internal
-mcstas/dmc/vdmc.tcl:126>> hmakescript /dmc/detector/countmode "counter getmode" hdbReadOnly  text
-mcstas/dmc/vdmc.tcl:127>> hsetprop /dmc/detector/countmode priv internal
-mcstas/dmc/vdmc.tcl:128>> sicspoll add /dmc/detector/preset hdb 30
-mcstas/dmc/vdmc.tcl:129>> sicspoll add /dmc/detector/countmode hdb 30
-mcstas/dmc/vdmc.tcl:130>> hmake /commands spy none
-mcstas/dmc/vdmc.tcl:131>> hcommand /commands/count count
-mcstas/dmc/vdmc.tcl:132>> hsetprop /commands/count type command
-mcstas/dmc/vdmc.tcl:133>> hmake /commands/count/mode user text
-mcstas/dmc/vdmc.tcl:134>> hmake /commands/count/preset user float
-mcstas/dmc/vdmc.tcl:135>> hset /commands/count/preset 5
-mcstas/dmc/vdmc.tcl:136>> hset /commands/count/mode timer
-mcstas/dmc/vdmc.tcl:137>> ==26623== Invalid read of size 1
-==26623==    at 0x401C434: strcmp (mac_replace_strmem.c:332)
-==26623==    by 0x80E756C: compareHdbValue (hipadaba.c:446)
-==26623==    by 0x80F26EA: pollHdb (polldriv.c:38)
-==26623==    by 0x80F2B96: PollTask (sicspoll.c:132)
-==26623==    by 0x8057B08: TaskSchedule (task.c:211)
-==26623==    by 0x805667C: RunServer (nserver.c:419)
-==26623==    by 0x8056AC5: main (SICSmain.c:59)
-==26623==  Address 0x4330FF0 is 0 bytes inside a block of size 8 free'd
-==26623==    at 0x401B14C: free (vg_replace_malloc.c:235)
-==26623==    by 0x80EB515: readHdbValue (sicshipadaba.c:1333)
-==26623==    by 0x80E95D8: SICSScriptReadCallback (sicshipadaba.c:403)
-==26623==    by 0x80E6B93: InvokeCallbackChain (hipadaba.c:66)
-==26623==    by 0x80E8466: GetHipadabaPar (hipadaba.c:943)
-==26623==    by 0x80F26C5: pollHdb (polldriv.c:37)
-==26623==    by 0x80F2B96: PollTask (sicspoll.c:132)
-==26623==    by 0x8057B08: TaskSchedule (task.c:211)
-==26623==    by 0x805667C: RunServer (nserver.c:419)
-==26623==    by 0x8056AC5: main (SICSmain.c:59)
-==26623== 
-==26623== Use of uninitialised value of size 4
-==26623==    at 0x80D4150: getNextMCNumber (mcreader.c:119)
-==26623==    by 0x80D4505: insertMonitor (mcreader.c:196)
-==26623==    by 0x80D5222: McStasReaderWrapper (mcreader.c:451)
-==26623==    by 0x8058355: SicsUnknownProc (macro.c:184)
-==26623==    by 0x404D7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x406A602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x404E291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x40906B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089512: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089BFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089F61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x80D5BCD: invokeScript (mccontrol.c:167)
-==26623== 
-==26623== Conditional jump or move depends on uninitialised value(s)
-==26623==    at 0x80D4164: getNextMCNumber (mcreader.c:119)
-==26623==    by 0x80D4505: insertMonitor (mcreader.c:196)
-==26623==    by 0x80D5222: McStasReaderWrapper (mcreader.c:451)
-==26623==    by 0x8058355: SicsUnknownProc (macro.c:184)
-==26623==    by 0x404D7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x406A602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x404E291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x40906B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089512: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089BFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089F61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x80D5BCD: invokeScript (mccontrol.c:167)
-==26623== 
-==26623== Conditional jump or move depends on uninitialised value(s)
-==26623==    at 0x412F31D: __strtod_internal (in /lib/tls/libc-2.3.2.so)
-==26623==    by 0x4125270: atof (in /lib/tls/libc-2.3.2.so)
-==26623==    by 0x80D451D: insertMonitor (mcreader.c:197)
-==26623==    by 0x80D5222: McStasReaderWrapper (mcreader.c:451)
-==26623==    by 0x8058355: SicsUnknownProc (macro.c:184)
-==26623==    by 0x404D7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x406A602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x404E291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x40906B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089512: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089BFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089F61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
-==26623== 
-==26623== Conditional jump or move depends on uninitialised value(s)
-==26623==    at 0x412D64D: __strtod_internal (in /lib/tls/libc-2.3.2.so)
-==26623==    by 0x4125270: atof (in /lib/tls/libc-2.3.2.so)
-==26623==    by 0x80D451D: insertMonitor (mcreader.c:197)
-==26623==    by 0x80D5222: McStasReaderWrapper (mcreader.c:451)
-==26623==    by 0x8058355: SicsUnknownProc (macro.c:184)
-==26623==    by 0x404D7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x406A602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x404E291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x40906B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089512: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089BFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089F61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
-==26623== 
-==26623== Conditional jump or move depends on uninitialised value(s)
-==26623==    at 0x412F027: __strtod_internal (in /lib/tls/libc-2.3.2.so)
-==26623==    by 0x4125270: atof (in /lib/tls/libc-2.3.2.so)
-==26623==    by 0x80D451D: insertMonitor (mcreader.c:197)
-==26623==    by 0x80D5222: McStasReaderWrapper (mcreader.c:451)
-==26623==    by 0x8058355: SicsUnknownProc (macro.c:184)
-==26623==    by 0x404D7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x406A602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x404E291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x40906B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089512: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089BFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089F61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
-==26623== 
-==26623== Use of uninitialised value of size 4
-==26623==    at 0x412F11A: __strtod_internal (in /lib/tls/libc-2.3.2.so)
-==26623==    by 0x4125270: atof (in /lib/tls/libc-2.3.2.so)
-==26623==    by 0x80D451D: insertMonitor (mcreader.c:197)
-==26623==    by 0x80D5222: McStasReaderWrapper (mcreader.c:451)
-==26623==    by 0x8058355: SicsUnknownProc (macro.c:184)
-==26623==    by 0x404D7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x406A602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x404E291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x40906B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089512: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089BFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089F61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
-==26623== 
-==26623== Invalid free() / delete / delete[]
-==26623==    at 0x401B14C: free (vg_replace_malloc.c:235)
-==26623==    by 0x80E747D: ReleaseHdbValue (hipadaba.c:409)
-==26623==    by 0x80E6B0E: DeleteNodeData (hipadaba.c:49)
-==26623==    by 0x80E6B48: DeleteNodeData (hipadaba.c:55)
-==26623==    by 0x80E6B48: DeleteNodeData (hipadaba.c:55)
-==26623==    by 0x80E6B48: DeleteNodeData (hipadaba.c:55)
-==26623==    by 0x80E7A10: DeleteHipadabaNode (hipadaba.c:605)
-==26623==    by 0x80EE3DC: killSICSHipadaba (sicshipadaba.c:2504)
-==26623==    by 0x8056653: StopServer (nserver.c:404)
-==26623==    by 0x8056AD6: main (SICSmain.c:61)
-==26623==  Address 0x4291978 is 0 bytes inside a block of size 1,600 free'd
-==26623==    at 0x401B14C: free (vg_replace_malloc.c:235)
-==26623==    by 0x80D67D8: killHMData (hmdata.c:40)
-==26623==    by 0x807C83E: DeleteHistDriver (histdriv.c:102)
-==26623==    by 0x807929E: DeleteHistMemory (histmem.c:499)
-==26623==    by 0x8051BD7: DeleteInterp (SCinter.c:483)
-==26623==    by 0x8056596: StopServer (nserver.c:358)
-==26623==    by 0x8056AD6: main (SICSmain.c:61)
-hmake /Graphics spy none
-mcstas/dmc/vdmc.tcl:138>> hmake /Graphics/powder_diagram spy none
-mcstas/dmc/vdmc.tcl:139>> hsetprop /Graphics/powder_diagram type graphdata
-mcstas/dmc/vdmc.tcl:140>> hsetprop /Graphics/powder_diagram viewer default
-mcstas/dmc/vdmc.tcl:141>> hmake /Graphics/powder_diagram/rank internal int
-mcstas/dmc/vdmc.tcl:142>> hset /Graphics/powder_diagram/rank 1
-mcstas/dmc/vdmc.tcl:143>> hmake /Graphics/powder_diagram/dim internal intar 1
-mcstas/dmc/vdmc.tcl:144>> hset /Graphics/powder_diagram/dim 400
-mcstas/dmc/vdmc.tcl:145>> hmakescript /Graphics/powder_diagram/two_theta maketwotheta hdbReadOnly floatar 400
-mcstas/dmc/vdmc.tcl:146>> sicspoll add /Graphics/powder_diagram/two_theta hdb 30
-mcstas/dmc/vdmc.tcl:147>> hsetprop /Graphics/powder_diagram/two_theta type axis
-mcstas/dmc/vdmc.tcl:148>> hsetprop /Graphics/powder_diagram/two_theta dim 0
-mcstas/dmc/vdmc.tcl:149>> hattach /Graphics/powder_diagram banana counts
-mcstas/dmc/vdmc.tcl:150>> hsetprop /Graphics/powder_diagram/counts type data
-mcstas/dmc/vdmc.tcl:151>> hsetprop /Graphics/powder_diagram/counts priv internal
-mcstas/dmc/vdmc.tcl:152>> sicspoll add /Graphics/powder_diagram/counts hdb 60
+sim/rita2/rita2.tcl:127>> VarMake __ritamode Text Mugger
+sim/rita2/rita2.tcl:128>> VarMake __analyzerdistance Float Mugger #in mm, distance from detector to analyzer, lad
+sim/rita2/rita2.tcl:129>> VarMake __sampledistance Float Mugger # in mm, distance from analyzer to sample, lsa
+sim/rita2/rita2.tcl:130>> VarMake bladedistance Float Mugger    # in mm, distance between equi-distant analyzerblades
+sim/rita2/rita2.tcl:131>> VarMake detectordistance Float Mugger # in mm, distance between equi-distant detecttors, e.g. centers of dectector windows.
+sim/rita2/rita2.tcl:132>> VarMake window1 Text User   #in pixels : w1x1:w1x2:w1y1:w1y2
+sim/rita2/rita2.tcl:133>> VarMake window2 Text User   # same
+sim/rita2/rita2.tcl:134>> VarMake window3 Text User   # same
+sim/rita2/rita2.tcl:135>> VarMake window4 Text User   # same
+sim/rita2/rita2.tcl:136>> VarMake window5 Text User   # same
+sim/rita2/rita2.tcl:137>> VarMake window6 Text User   # same
+sim/rita2/rita2.tcl:138>> VarMake window7 Text User   # same
+sim/rita2/rita2.tcl:139>> VarMake window8 Text User   # same
+sim/rita2/rita2.tcl:140>> VarMake window9 Text User   # same
+sim/rita2/rita2.tcl:141>> VarMake window10 Text User   # same
+sim/rita2/rita2.tcl:142>> VarMake window11 Text User   # same
+sim/rita2/rita2.tcl:143>> VarMake window12 Text User   # same
+sim/rita2/rita2.tcl:144>> VarMake PSDWidth Float Mugger   #in mm
+sim/rita2/rita2.tcl:145>> VarMake PSDHeight FLoat Mugger  #in mm
+sim/rita2/rita2.tcl:146>> VarMake PSDXChannels Int Mugger #in pixels
+sim/rita2/rita2.tcl:147>> VarMake PSDYChannels Int Mugger #in pixels
+sim/rita2/rita2.tcl:148>> VarMake DisplayDrivingMessages Int Mugger # If 1 then display messages about where we are driving towards, else do not.
+sim/rita2/rita2.tcl:149>> VarMake monThreshold Float User
+sim/rita2/rita2.tcl:150>> monThreshold 10000
+RITA-2 scripts successfully loaded
+ERROR: new SICSData not created due to name collision
+RITA-2 scripts successfully loaded
+/afs/psi.ch/user/k/koennecke/src/workspace/sics/sim/rita2/tmp/rita2status.tcl:151>> clientput "Initialization Done"
+Initialization Done
 OK
-OK
-HM scale = 193788348.665
-OK
-==26623== 
-==26623== ERROR SUMMARY: 30656 errors from 8 contexts (suppressed: 29 from 2)
-==26623== malloc/free: in use at exit: 127,433 bytes in 2,230 blocks.
-==26623== malloc/free: 8,188,720 allocs, 8,186,491 frees, 230,654,912 bytes allocated.
-==26623== For counts of detected errors, rerun with: -v
-==26623== searching for pointers to 2,230 not-freed blocks.
-==26623== checked 501,620 bytes.
-==26623== 
-==26623== 
-==26623== 0 bytes in 1 blocks are definitely lost in loss record 1 of 23
-==26623==    at 0x401A639: malloc (vg_replace_malloc.c:149)
-==26623==    by 0x80E709B: makeHdbValue (hipadaba.c:279)
-==26623==    by 0x80EB9CE: MakeHdbNode (sicshipadaba.c:1484)
-==26623==    by 0x8058355: SicsUnknownProc (macro.c:184)
-==26623==    by 0x404D7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089512: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089349: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089BFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089F61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x8058CCB: MacroFileEval (macro.c:535)
-==26623==    by 0x80516E9: InterpExecute (SCinter.c:322)
-==26623==    by 0x805B0F9: InitObjectCommands (ofac.c:458)
-==26623== 
-==26623== 
-==26623== 8 bytes in 1 blocks are definitely lost in loss record 2 of 23
-==26623==    at 0x401A639: malloc (vg_replace_malloc.c:149)
-==26623==    by 0x80E7869: MakeHipadabaNode (hipadaba.c:545)
-==26623==    by 0x80F1E5A: MakeHMDataNode (sicshdbadapter.c:312)
-==26623==    by 0x80F2549: SICSHdbAdapter (sicshdbadapter.c:498)
-==26623==    by 0x8058355: SicsUnknownProc (macro.c:184)
-==26623==    by 0x404D7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089512: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089349: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089BFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089F61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x8058CCB: MacroFileEval (macro.c:535)
-==26623==    by 0x80516E9: InterpExecute (SCinter.c:322)
-==26623== 
-==26623== 
-==26623== 29 (20 direct, 9 indirect) bytes in 1 blocks are definitely lost in loss record 7 of 23
-==26623==    at 0x401A639: malloc (vg_replace_malloc.c:149)
-==26623==    by 0x805B773: CreateDescriptor (obdes.c:64)
-==26623==    by 0x80F3461: InstallSICSPoll (sicspoll.c:338)
-==26623==    by 0x80EE635: InstallSICSHipadaba (sicshipadaba.c:2533)
-==26623==    by 0x8058355: SicsUnknownProc (macro.c:184)
-==26623==    by 0x404D7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089512: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089349: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089BFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089F61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x8058CCB: MacroFileEval (macro.c:535)
-==26623==    by 0x80516E9: InterpExecute (SCinter.c:322)
-==26623== 
-==26623== 
-==26623== 32 bytes in 4 blocks are definitely lost in loss record 8 of 23
-==26623==    at 0x401A639: malloc (vg_replace_malloc.c:149)
-==26623==    by 0x417424F: strdup (in /lib/tls/libc-2.3.2.so)
-==26623==    by 0x80E7107: makeHdbValue (hipadaba.c:293)
-==26623==    by 0x80EBC89: MakeHdbScriptNode (sicshipadaba.c:1561)
-==26623==    by 0x8058355: SicsUnknownProc (macro.c:184)
-==26623==    by 0x404D7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089512: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089349: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089BFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089F61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x8058CCB: MacroFileEval (macro.c:535)
-==26623==    by 0x80516E9: InterpExecute (SCinter.c:322)
-==26623== 
-==26623== 
-==26623== 387 (36 direct, 351 indirect) bytes in 3 blocks are definitely lost in loss record 11 of 23
-==26623==    at 0x401A639: malloc (vg_replace_malloc.c:149)
-==26623==    by 0x8066217: ListInit (lld.c:76)
-==26623==    by 0x80665A9: LLDcreate (lld.c:196)
-==26623==    by 0x8077931: CreateStringDict (stringdict.c:68)
-==26623==    by 0x80584E1: AllowExec (macro.c:249)
-==26623==    by 0x8058355: SicsUnknownProc (macro.c:184)
-==26623==    by 0x404D7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089512: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089349: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089BFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089F61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x8058CCB: MacroFileEval (macro.c:535)
-==26623== 
-==26623== 
-==26623== 137 (36 direct, 101 indirect) bytes in 1 blocks are definitely lost in loss record 13 of 23
-==26623==    at 0x401A639: malloc (vg_replace_malloc.c:149)
-==26623==    by 0x80B0ABB: MakeExeManager (exeman.c:79)
-==26623==    by 0x8058355: SicsUnknownProc (macro.c:184)
-==26623==    by 0x404D7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089512: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089349: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089BFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089F61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x8058CCB: MacroFileEval (macro.c:535)
-==26623==    by 0x80516E9: InterpExecute (SCinter.c:322)
-==26623==    by 0x805B0F9: InitObjectCommands (ofac.c:458)
-==26623==    by 0x8055CEE: InitServer (nserver.c:121)
-==26623== 
-==26623== 
-==26623== 168 bytes in 16 blocks are definitely lost in loss record 14 of 23
-==26623==    at 0x401A639: malloc (vg_replace_malloc.c:149)
-==26623==    by 0x807EAE5: NXwhitespaceCallback (nxio.c:548)
-==26623==    by 0x828F1C0: mxml_write_ws (mxml-file.c:2817)
-==26623==    by 0x828E9B3: mxml_write_node (mxml-file.c:2506)
-==26623==    by 0x828EC74: mxml_write_node (mxml-file.c:2593)
-==26623==    by 0x828EC74: mxml_write_node (mxml-file.c:2593)
-==26623==    by 0x828EC74: mxml_write_node (mxml-file.c:2593)
-==26623==    by 0x828EC74: mxml_write_node (mxml-file.c:2593)
-==26623==    by 0x828EC74: mxml_write_node (mxml-file.c:2593)
-==26623==    by 0x828CA1F: mxmlSaveFile (mxml-file.c:371)
-==26623==    by 0x80C078C: NXXclose (nxxml.c:187)
-==26623==    by 0x80741BB: nxiclose_ (napi.c:291)
-==26623== 
-==26623== 
-==26623== 213 bytes in 8 blocks are definitely lost in loss record 15 of 23
-==26623==    at 0x401A639: malloc (vg_replace_malloc.c:149)
-==26623==    by 0x80E7C52: GetHipadabaPath (hipadaba.c:683)
-==26623==    by 0x80EBD05: MakeHdbScriptNode (sicshipadaba.c:1572)
-==26623==    by 0x8058355: SicsUnknownProc (macro.c:184)
-==26623==    by 0x404D7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089512: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089349: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089BFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089F61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x8058CCB: MacroFileEval (macro.c:535)
-==26623==    by 0x80516E9: InterpExecute (SCinter.c:322)
-==26623==    by 0x805B0F9: InitObjectCommands (ofac.c:458)
-==26623== 
-==26623== 
-==26623== 1,368 bytes in 128 blocks are definitely lost in loss record 19 of 23
-==26623==    at 0x401A639: malloc (vg_replace_malloc.c:149)
-==26623==    by 0x807EB54: NXwhitespaceCallback (nxio.c:561)
-==26623==    by 0x828F1C0: mxml_write_ws (mxml-file.c:2817)
-==26623==    by 0x828E9B3: mxml_write_node (mxml-file.c:2506)
-==26623==    by 0x828EC74: mxml_write_node (mxml-file.c:2593)
-==26623==    by 0x828EC74: mxml_write_node (mxml-file.c:2593)
-==26623==    by 0x828EC74: mxml_write_node (mxml-file.c:2593)
-==26623==    by 0x828EC74: mxml_write_node (mxml-file.c:2593)
-==26623==    by 0x828EC74: mxml_write_node (mxml-file.c:2593)
-==26623==    by 0x828CA1F: mxmlSaveFile (mxml-file.c:371)
-==26623==    by 0x80C078C: NXXclose (nxxml.c:187)
-==26623==    by 0x80741BB: nxiclose_ (napi.c:291)
-==26623== 
-==26623== 
-==26623== 3,200 bytes in 1 blocks are definitely lost in loss record 21 of 23
-==26623==    at 0x401A639: malloc (vg_replace_malloc.c:149)
-==26623==    by 0x80E70D5: makeHdbValue (hipadaba.c:287)
-==26623==    by 0x80EBC89: MakeHdbScriptNode (sicshipadaba.c:1561)
-==26623==    by 0x8058355: SicsUnknownProc (macro.c:184)
-==26623==    by 0x404D7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089512: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089349: (within /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089BFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x4089F61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
-==26623==    by 0x8058CCB: MacroFileEval (macro.c:535)
-==26623==    by 0x80516E9: InterpExecute (SCinter.c:322)
-==26623==    by 0x805B0F9: InitObjectCommands (ofac.c:458)
-==26623== 
-==26623== LEAK SUMMARY:
-==26623==    definitely lost: 5,081 bytes in 164 blocks.
-==26623==    indirectly lost: 461 bytes in 26 blocks.
-==26623==      possibly lost: 0 bytes in 0 blocks.
-==26623==    still reachable: 121,891 bytes in 2,040 blocks.
-==26623==         suppressed: 0 bytes in 0 blocks.
-==26623== Reachable blocks (those to which a pointer was found) are not shown.
-==26623== To see them, rerun with: --show-reachable=yes
+==6691== Conditional jump or move depends on uninitialised value(s)
+==6691==    at 0x806DBEC: NX5open (napi5.c:263)
+==6691==    by 0x8074007: nxiopen_ (napi.c:238)
+==6691==    by 0x80D7781: handleFileOperations (nxscript.c:187)
+==6691==    by 0x80D9D82: NXScriptAction (nxscript.c:1208)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== Syscall param write(buf) points to uninitialised byte(s)
+==6691==    at 0x41C61FE: __write_nocancel (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x81BF3F5: H5FD_sec2_write (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==6691==  Address 0x46C2B28 is 344 bytes inside a block of size 1,672 alloc'd
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x81C28E2: H5FL_malloc (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==6691== 
+==6691== Source and destination overlap in mempcpy(0xBEFF3CB0, 0xBEFF3CB0, 70)
+==6691==    at 0x401D1BB: mempcpy (mc_replace_strmem.c:116)
+==6691==    by 0x4164691: _IO_default_xsputn (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x413D5B6: vfprintf (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x41594DB: vsprintf (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x41440CC: sprintf (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x8054341: OpenVerifyLogFile (servlog.c:250)
+==6691==    by 0x80544BD: SICSLogWrite (servlog.c:311)
+==6691==    by 0x804E3DC: SCNormalWrite (conman.c:701)
+==6691==    by 0x804E011: SCWrite (conman.c:564)
+==6691==    by 0x804F1FF: SCSendOK (conman.c:1232)
+==6691==    by 0x80DB368: putFloat (sicsdata.c:316)
+==6691==    by 0x80DC8E4: SICSDataAction (sicsdata.c:793)
+==6691== 
+==6691== ERROR SUMMARY: 55 errors from 3 contexts (suppressed: 27 from 2)
+==6691== malloc/free: in use at exit: 287,694 bytes in 4,835 blocks.
+==6691== malloc/free: 4,366,532 allocs, 4,361,697 frees, 1,268,258,824 bytes allocated.
+==6691== For counts of detected errors, rerun with: -v
+==6691== searching for pointers to 4,835 not-freed blocks.
+==6691== checked 647,880 bytes.
+==6691== 
+==6691== 
+==6691== 1 bytes in 1 blocks are still reachable in loss record 1 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40849FC: Tcl_CreateNamespace (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D7E0: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 2 bytes in 1 blocks are still reachable in loss record 2 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FFC5: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D791: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2 bytes in 1 blocks are still reachable in loss record 3 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2 bytes in 1 blocks are still reachable in loss record 4 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2 bytes in 1 blocks are still reachable in loss record 5 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406040F: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405C611: Tcl_SwitchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2 bytes in 1 blocks are still reachable in loss record 6 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061000: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40612C3: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40618E1: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061450: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x406154F: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061450: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2 bytes in 1 blocks are still reachable in loss record 7 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2 bytes in 1 blocks are still reachable in loss record 8 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063AF8: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2 bytes in 1 blocks are still reachable in loss record 9 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2 bytes in 1 blocks are still reachable in loss record 10 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x406154F: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061450: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2 bytes in 1 blocks are still reachable in loss record 11 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061000: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40612C3: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40609B0: TclCompileWhileCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2 bytes in 1 blocks are still reachable in loss record 12 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408150D: Tcl_LinkVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061F63: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2 bytes in 1 blocks are still reachable in loss record 13 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408150D: Tcl_LinkVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC28: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC9B: TclCreateExecEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D7FD: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691== 
+==6691== 
+==6691== 3 bytes in 1 blocks are still reachable in loss record 14 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 3 bytes in 1 blocks are indirectly lost in loss record 15 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80B0AD8: MakeExeManager (exeman.c:89)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691== 
+==6691== 
+==6691== 3 bytes in 1 blocks are indirectly lost in loss record 16 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80B0AC2: MakeExeManager (exeman.c:88)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691== 
+==6691== 
+==6691== 3 bytes in 1 blocks are still reachable in loss record 17 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80C6E6B: InstallTasQMMotor (tasdrive.c:726)
+==6691==    by 0x80A8C22: TasUBFactory (tasub.c:333)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 3 bytes in 1 blocks are still reachable in loss record 18 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8079377: MakeHistMemory (histmem.c:557)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 3 bytes in 1 blocks are still reachable in loss record 19 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A21F: InitIniCommands (ofac.c:240)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 3 bytes in 1 blocks are still reachable in loss record 20 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4084C44: Tcl_CreateNamespace (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D7E0: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 4 bytes in 1 blocks are still reachable in loss record 21 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095CB8: Tcl_GetThreadData (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406DF6C: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 4 bytes in 1 blocks are still reachable in loss record 22 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 4 bytes in 1 blocks are still reachable in loss record 23 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 4 bytes in 1 blocks are still reachable in loss record 24 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 4 bytes in 1 blocks are still reachable in loss record 25 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082450: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4081F82: Tcl_ListObjLength (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406E518: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80597D7: TclAction (macro.c:1011)
+==6691== 
+==6691== 
+==6691== 4 bytes in 1 blocks are still reachable in loss record 26 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 4 bytes in 1 blocks are still reachable in loss record 27 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x805828F: SicsUnknownProc (macro.c:205)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4052FE9: Tcl_CatchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 4 bytes in 2 blocks are still reachable in loss record 28 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406040F: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 4 bytes in 1 blocks are still reachable in loss record 29 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095CB8: Tcl_GetThreadData (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409E93D: TclpOpenFileChannel (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40811DD: Tcl_OpenFileChannel (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080F01: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 4 bytes in 1 blocks are still reachable in loss record 30 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805CA5B: MakeDrive (drive.c:491)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 4 bytes in 1 blocks are definitely lost in loss record 31 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80F8E06: CreateCounterDriver (countdriv.c:60)
+==6691==    by 0x80F95F6: NewSIMCounter (simcter.c:325)
+==6691==    by 0x807CC91: CreateSIMHM (histsim.c:260)
+==6691==    by 0x80790C1: CreateHistMemory (histmem.c:459)
+==6691==    by 0x80792E0: MakeHistMemory (histmem.c:545)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 4 bytes in 2 blocks are still reachable in loss record 32 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A96F: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 4 bytes in 1 blocks are still reachable in loss record 33 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A0EB: InitIniCommands (ofac.c:229)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 4 bytes in 1 blocks are still reachable in loss record 34 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80B0BC6: MakeExeManager (exeman.c:108)
+==6691==    by 0x805AF63: InitObjectCommands (ofac.c:450)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 4 bytes in 1 blocks are still reachable in loss record 35 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408E371: Tcl_PkgProvideEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA89: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 4 bytes in 1 blocks are still reachable in loss record 36 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA2D: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 5 bytes in 1 blocks are still reachable in loss record 37 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40509FE: Tcl_AddObjErrorInfo (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A776: Tcl_LogCommandInfo (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406E83E: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 5 bytes in 1 blocks are still reachable in loss record 38 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061000: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40612C3: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 5 bytes in 1 blocks are still reachable in loss record 39 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 5 bytes in 1 blocks are still reachable in loss record 40 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406040F: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 5 bytes in 1 blocks are still reachable in loss record 41 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406020D: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 5 bytes in 1 blocks are still reachable in loss record 42 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 5 bytes in 2 blocks are still reachable in loss record 43 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406040F: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 5 bytes in 1 blocks are still reachable in loss record 44 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40618E1: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061450: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 5 bytes in 1 blocks are still reachable in loss record 45 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8091764: FitFactory (fitcenter.c:390)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 5 bytes in 1 blocks are still reachable in loss record 46 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80F75C3: MotorCreate (motor.c:1061)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 5 bytes in 1 blocks are still reachable in loss record 47 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A360: InitIniCommands (ofac.c:251)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 5 bytes in 1 blocks are still reachable in loss record 48 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A344: InitIniCommands (ofac.c:250)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 5 bytes in 1 blocks are still reachable in loss record 49 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A25B: InitIniCommands (ofac.c:242)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 5 bytes in 1 blocks are still reachable in loss record 50 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A097: InitIniCommands (ofac.c:226)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 5 bytes in 1 blocks are still reachable in loss record 51 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x804D71E: CreateConnection (conman.c:201)
+==6691==    by 0x804D7C9: SCCreateDummyConnection (conman.c:231)
+==6691==    by 0x805853F: MacroInit (macro.c:328)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 5 bytes in 1 blocks are still reachable in loss record 52 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A45F0: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 5 bytes in 1 blocks are still reachable in loss record 53 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A4467: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 6 bytes in 1 blocks are still reachable in loss record 54 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062DF8: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 6 bytes in 1 blocks are still reachable in loss record 55 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 6 bytes in 2 blocks are still reachable in loss record 56 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061000: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40612C3: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D80B: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 6 bytes in 1 blocks are still reachable in loss record 57 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 6 bytes in 1 blocks are still reachable in loss record 58 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40630C9: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405C611: Tcl_SwitchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 6 bytes in 1 blocks are still reachable in loss record 59 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 6 bytes in 1 blocks are still reachable in loss record 60 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805C9CF: MakeDrive (drive.c:479)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 6 bytes in 1 blocks are still reachable in loss record 61 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x808D50B: ScanFactory (scan.c:1239)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 6 bytes in 1 blocks are still reachable in loss record 62 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80A8B59: TasUBFactory (tasub.c:314)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 6 bytes in 1 blocks are still reachable in loss record 63 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x809252D: TokenInit (token.c:52)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 6 bytes in 1 blocks are still reachable in loss record 64 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80FF3BD: AddPsiCommands (psi.c:122)
+==6691==    by 0x805AAC0: InitIniCommands (ofac.c:347)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 6 bytes in 1 blocks are still reachable in loss record 65 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A410: InitIniCommands (ofac.c:262)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 6 bytes in 1 blocks are still reachable in loss record 66 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A2B5: InitIniCommands (ofac.c:245)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 6 bytes in 1 blocks are still reachable in loss record 67 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8149634: LogReaderInit (logreader.c:434)
+==6691==    by 0x80FF13C: SiteInit (psi.c:88)
+==6691==    by 0x805AEDA: InitGeneral (ofac.c:426)
+==6691==    by 0x805AF23: InitObjectCommands (ofac.c:441)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 6 bytes in 1 blocks are still reachable in loss record 68 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A44DE: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 6 bytes in 1 blocks are still reachable in loss record 69 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA09: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 6 bytes in 1 blocks are still reachable in loss record 70 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40675D9: Tcl_CreateEncoding (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4067006: TclInitEncodingSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7B1: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 7 bytes in 1 blocks are still reachable in loss record 71 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 7 bytes in 3 blocks are still reachable in loss record 72 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 7 bytes in 1 blocks are still reachable in loss record 73 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 7 bytes in 1 blocks are still reachable in loss record 74 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 7 bytes in 1 blocks are still reachable in loss record 75 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 7 bytes in 2 blocks are still reachable in loss record 76 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406020D: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 7 bytes in 1 blocks are still reachable in loss record 77 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40609B0: TclCompileWhileCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 7 bytes in 1 blocks are still reachable in loss record 78 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060929: TclCompileWhileCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 7 bytes in 1 blocks are still reachable in loss record 79 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8091787: FitFactory (fitcenter.c:391)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 7 bytes in 1 blocks are still reachable in loss record 80 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A15B: InitIniCommands (ofac.c:233)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 7 bytes in 1 blocks are still reachable in loss record 81 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A13F: InitIniCommands (ofac.c:232)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 7 bytes in 1 blocks are still reachable in loss record 82 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A107: InitIniCommands (ofac.c:230)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 7 bytes in 1 blocks are still reachable in loss record 83 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A0B3: InitIniCommands (ofac.c:227)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 7 bytes in 1 blocks are still reachable in loss record 84 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A07B: InitIniCommands (ofac.c:225)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 7 bytes in 1 blocks are still reachable in loss record 85 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A05F: InitIniCommands (ofac.c:224)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 7 bytes in 1 blocks are still reachable in loss record 86 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059FB7: InitIniCommands (ofac.c:218)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 7 bytes in 1 blocks are still reachable in loss record 87 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x80EF04C: StatisticsInit (statistics.c:163)
+==6691==    by 0x805AEDF: InitGeneral (ofac.c:427)
+==6691==    by 0x805AF23: InitObjectCommands (ofac.c:441)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 88 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 89 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 8 bytes in 4 blocks are still reachable in loss record 90 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082503: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4081CCA: Tcl_ListObjGetElements (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405AFC8: Tcl_StringObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 91 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 92 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40630C9: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406020D: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405C611: Tcl_SwitchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 93 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 94 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are indirectly lost in loss record 95 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x807D0B0: CreateCallBackInterface (callback.c:85)
+==6691==    by 0x80B0AAF: MakeExeManager (exeman.c:87)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 96 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80CE573: TASUBScanFactory (tasscanub.c:1283)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 97 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x808D578: ScanFactory (scan.c:1254)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 98 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80FA7D9: MakeCounter (counter.c:563)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 99 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A44A: InitIniCommands (ofac.c:264)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 100 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A3F3: InitIniCommands (ofac.c:261)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 101 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A3B9: InitIniCommands (ofac.c:259)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 102 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A39C: InitIniCommands (ofac.c:258)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 103 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A2ED: InitIniCommands (ofac.c:247)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 104 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A123: InitIniCommands (ofac.c:231)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 105 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A043: InitIniCommands (ofac.c:223)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 106 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DB2E: Tcl_CallWhenDeleted (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4075566: TclInterpInit (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9AF: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 107 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40904F4: TclHandleCreate (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D68F: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 8 bytes in 1 blocks are still reachable in loss record 108 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40675D9: Tcl_CreateEncoding (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406703E: TclInitEncodingSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7B1: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 9 bytes in 1 blocks are still reachable in loss record 109 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 9 bytes in 1 blocks are still reachable in loss record 110 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 9 bytes in 1 blocks are still reachable in loss record 111 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 9 bytes in 1 blocks are still reachable in loss record 112 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80DA106: MakeNXScript (nxscript.c:1296)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 9 bytes in 1 blocks are still reachable in loss record 113 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8123BBD: MakeFrameFunc (frame.c:243)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 9 bytes in 1 blocks are still reachable in loss record 114 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8084A16: DNFactory (danu.c:407)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 9 bytes in 1 blocks are definitely lost in loss record 115 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80F8DF3: CreateCounterDriver (countdriv.c:59)
+==6691==    by 0x80F95F6: NewSIMCounter (simcter.c:325)
+==6691==    by 0x807CC91: CreateSIMHM (histsim.c:260)
+==6691==    by 0x80790C1: CreateHistMemory (histmem.c:459)
+==6691==    by 0x80792E0: MakeHistMemory (histmem.c:545)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 9 bytes in 1 blocks are still reachable in loss record 116 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A42D: InitIniCommands (ofac.c:263)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 9 bytes in 1 blocks are still reachable in loss record 117 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A3D6: InitIniCommands (ofac.c:260)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 9 bytes in 1 blocks are still reachable in loss record 118 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A2D1: InitIniCommands (ofac.c:246)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 9 bytes in 1 blocks are still reachable in loss record 119 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A1CB: InitIniCommands (ofac.c:237)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 9 bytes in 1 blocks are still reachable in loss record 120 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A177: InitIniCommands (ofac.c:234)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 9 bytes in 1 blocks are still reachable in loss record 121 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059FEF: InitIniCommands (ofac.c:220)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 9 bytes in 1 blocks are still reachable in loss record 122 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059F63: InitIniCommands (ofac.c:214)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 9 bytes in 1 blocks are still reachable in loss record 123 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40675D9: Tcl_CreateEncoding (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4066FB5: TclInitEncodingSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7B1: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 10 bytes in 2 blocks are still reachable in loss record 124 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FFC5: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405C611: Tcl_SwitchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 10 bytes in 3 blocks are still reachable in loss record 125 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 10 bytes in 2 blocks are still reachable in loss record 126 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 10 bytes in 1 blocks are still reachable in loss record 127 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059A70: TclPublish (macro.c:1082)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 10 bytes in 1 blocks are still reachable in loss record 128 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A50E: InitIniCommands (ofac.c:273)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 10 bytes in 1 blocks are still reachable in loss record 129 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A299: InitIniCommands (ofac.c:244)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 10 bytes in 1 blocks are still reachable in loss record 130 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A23B: InitIniCommands (ofac.c:241)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 10 bytes in 1 blocks are still reachable in loss record 131 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A203: InitIniCommands (ofac.c:239)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 10 bytes in 1 blocks are still reachable in loss record 132 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059FD3: InitIniCommands (ofac.c:219)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 10 bytes in 1 blocks are still reachable in loss record 133 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059F9B: InitIniCommands (ofac.c:217)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 10 bytes in 1 blocks are still reachable in loss record 134 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A46DF: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 11 bytes in 1 blocks are still reachable in loss record 135 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 11 bytes in 1 blocks are still reachable in loss record 136 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 11 bytes in 1 blocks are still reachable in loss record 137 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 11 bytes in 1 blocks are still reachable in loss record 138 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80DCC9E: SICSDataFactory (sicsdata.c:854)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4052FE9: Tcl_CatchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 11 bytes in 1 blocks are indirectly lost in loss record 139 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x805B656: CreateDescriptor (obdes.c:69)
+==6691==    by 0x80B0AA2: MakeExeManager (exeman.c:86)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691== 
+==6691== 
+==6691== 11 bytes in 1 blocks are still reachable in loss record 140 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A37C: InitIniCommands (ofac.c:252)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 11 bytes in 1 blocks are still reachable in loss record 141 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A27A: InitIniCommands (ofac.c:243)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 11 bytes in 1 blocks are still reachable in loss record 142 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A1AF: InitIniCommands (ofac.c:236)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 11 bytes in 1 blocks are still reachable in loss record 143 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A193: InitIniCommands (ofac.c:235)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 11 bytes in 1 blocks are still reachable in loss record 144 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A027: InitIniCommands (ofac.c:222)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 11 bytes in 1 blocks are still reachable in loss record 145 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059F7F: InitIniCommands (ofac.c:216)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 11 bytes in 1 blocks are still reachable in loss record 146 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x8051324: AddCmd (SCinter.c:192)
+==6691==    by 0x80EF026: StatisticsInit (statistics.c:161)
+==6691==    by 0x805AEDF: InitGeneral (ofac.c:427)
+==6691==    by 0x805AF23: InitObjectCommands (ofac.c:441)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 11 bytes in 1 blocks are still reachable in loss record 147 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80DDBF2: MakeDriver (initializer.c:177)
+==6691==    by 0x814B4D5: IlmStartup (ilmdriv.c:194)
+==6691==    by 0x80FF11E: SiteInit (psi.c:82)
+==6691==    by 0x805AEDA: InitGeneral (ofac.c:426)
+==6691==    by 0x805AF23: InitObjectCommands (ofac.c:441)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 11 bytes in 1 blocks are still reachable in loss record 148 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80DDBAE: MakeDriver (initializer.c:175)
+==6691==    by 0x814B4D5: IlmStartup (ilmdriv.c:194)
+==6691==    by 0x80FF11E: SiteInit (psi.c:82)
+==6691==    by 0x805AEDA: InitGeneral (ofac.c:426)
+==6691==    by 0x805AF23: InitObjectCommands (ofac.c:441)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 11 bytes in 1 blocks are still reachable in loss record 149 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A4430: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 150 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FFC5: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D791: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 151 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405C611: Tcl_SwitchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 152 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40825A2: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409BDD4: Tcl_LappendObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80597D7: TclAction (macro.c:1011)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 153 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 154 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 155 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061000: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40612C3: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 156 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 157 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 158 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062DF8: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 159 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 160 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 161 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 162 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 163 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 164 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 165 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 166 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 167 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 168 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 169 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 170 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 171 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 172 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 173 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406040F: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 3 blocks are still reachable in loss record 174 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 175 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 176 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 177 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 178 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406020D: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 179 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 180 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 181 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 182 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 3 blocks are still reachable in loss record 183 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 184 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40825A2: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4081F82: Tcl_ListObjLength (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406E518: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80597D7: TclAction (macro.c:1011)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 185 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40825A2: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4081CCA: Tcl_ListObjGetElements (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405AFC8: Tcl_StringObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 186 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 187 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 188 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406040F: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405C611: Tcl_SwitchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 189 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40630C9: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405C611: Tcl_SwitchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 190 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40630C9: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406020D: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405C611: Tcl_SwitchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 191 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061000: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40612C3: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40618E1: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061450: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x406154F: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061450: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 192 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 193 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 194 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063AF8: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 2 blocks are still reachable in loss record 195 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406329F: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 196 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 197 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 198 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 199 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 200 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 201 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40618E1: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061450: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 202 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x406154F: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061450: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 203 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EE99: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 204 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 205 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 206 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40609B0: TclCompileWhileCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 207 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40609B0: TclCompileWhileCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 208 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061000: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40612C3: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40609B0: TclCompileWhileCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 209 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060929: TclCompileWhileCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 210 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8056252: InitServer (nserver.c:260)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 211 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A5A3: Tcl_CreateThreadExitHandler (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4096125: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4096279: Tcl_DeleteTimerHandler (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4078DF4: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4078C31: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4079000: Tcl_Close (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080F8B: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are indirectly lost in loss record 212 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x8066135: ListInit (lld.c:87)
+==6691==    by 0x8066469: LLDcreate (lld.c:196)
+==6691==    by 0x80B0B0E: MakeExeManager (exeman.c:92)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are indirectly lost in loss record 213 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x8066135: ListInit (lld.c:87)
+==6691==    by 0x8066469: LLDcreate (lld.c:196)
+==6691==    by 0x807D0DE: CreateCallBackInterface (callback.c:92)
+==6691==    by 0x80B0AAF: MakeExeManager (exeman.c:87)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are definitely lost in loss record 214 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x80F961B: NewSIMCounter (simcter.c:331)
+==6691==    by 0x807C8FF: SimConfig (histsim.c:80)
+==6691==    by 0x807956D: HistConfigure (histmem.c:604)
+==6691==    by 0x807B00B: HistAction (histmem.c:1259)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are definitely lost in loss record 215 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x80F961B: NewSIMCounter (simcter.c:331)
+==6691==    by 0x807CC91: CreateSIMHM (histsim.c:260)
+==6691==    by 0x80790C1: CreateHistMemory (histmem.c:459)
+==6691==    by 0x80792E0: MakeHistMemory (histmem.c:545)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are definitely lost in loss record 216 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x80F961B: NewSIMCounter (simcter.c:331)
+==6691==    by 0x80FA6A3: MakeCounter (counter.c:528)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 217 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A4E7: Tcl_CreateExitHandler (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409028A: Tcl_Preserve (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B49F: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 218 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A5EE: InitIniCommands (ofac.c:281)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 219 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A0CF: InitIniCommands (ofac.c:228)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 220 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059F47: InitIniCommands (ofac.c:213)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 221 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408F2DD: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408E353: Tcl_PkgProvideEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA89: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 222 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC64: TclCreateExecEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D7FD: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 12 bytes in 1 blocks are still reachable in loss record 223 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095CB8: Tcl_GetThreadData (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7D5: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 13 bytes in 1 blocks are still reachable in loss record 224 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805AA86: InitIniCommands (ofac.c:337)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 13 bytes in 1 blocks are still reachable in loss record 225 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A6EA: InitIniCommands (ofac.c:290)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 13 bytes in 1 blocks are still reachable in loss record 226 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A6B2: InitIniCommands (ofac.c:288)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 13 bytes in 1 blocks are still reachable in loss record 227 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A00B: InitIniCommands (ofac.c:221)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 13 bytes in 1 blocks are still reachable in loss record 228 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80DDBD0: MakeDriver (initializer.c:176)
+==6691==    by 0x814B4D5: IlmStartup (ilmdriv.c:194)
+==6691==    by 0x80FF11E: SiteInit (psi.c:82)
+==6691==    by 0x805AEDA: InitGeneral (ofac.c:426)
+==6691==    by 0x805AF23: InitObjectCommands (ofac.c:441)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 13 bytes in 1 blocks are still reachable in loss record 229 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9E5: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 14 bytes in 1 blocks are still reachable in loss record 230 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80D1968: AntiColliderFactory (anticollider.c:296)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 14 bytes in 1 blocks are still reachable in loss record 231 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80FF315: AddPsiCommands (psi.c:116)
+==6691==    by 0x805AAC0: InitIniCommands (ofac.c:347)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 14 bytes in 1 blocks are still reachable in loss record 232 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40814AD: Tcl_LinkVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC28: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC9B: TclCreateExecEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D7FD: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 15 bytes in 1 blocks are still reachable in loss record 233 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x81620AA: MakeRitaFix (ritastorage.c:77)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 15 bytes in 1 blocks are still reachable in loss record 234 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80849A8: DNFactory (danu.c:400)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 15 bytes in 1 blocks are still reachable in loss record 235 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A8AA: InitIniCommands (ofac.c:306)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 15 bytes in 1 blocks are still reachable in loss record 236 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A325: InitIniCommands (ofac.c:249)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 15 bytes in 1 blocks are still reachable in loss record 237 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A1E7: InitIniCommands (ofac.c:238)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 16 bytes in 1 blocks are still reachable in loss record 238 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409B88F: Tcl_TraceVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409B80F: Tcl_TraceVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4081553: Tcl_LinkVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061F63: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 16 bytes in 1 blocks are still reachable in loss record 239 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A309: InitIniCommands (ofac.c:248)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 16 bytes in 1 blocks are still reachable in loss record 240 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409B88F: Tcl_TraceVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA61: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 16 bytes in 1 blocks are still reachable in loss record 241 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409B88F: Tcl_TraceVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406977B: TclSetupEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9B7: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 16 bytes in 1 blocks are still reachable in loss record 242 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409B88F: Tcl_TraceVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409B80F: Tcl_TraceVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4081553: Tcl_LinkVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC28: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC9B: TclCreateExecEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D7FD: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 17 bytes in 1 blocks are still reachable in loss record 243 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40814AD: Tcl_LinkVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061F63: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 18 bytes in 1 blocks are still reachable in loss record 244 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A4409: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 19 bytes in 1 blocks are still reachable in loss record 245 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A88E: InitIniCommands (ofac.c:305)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 19 bytes in 1 blocks are still reachable in loss record 246 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A270: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A44DE: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 20 bytes in 1 blocks are indirectly lost in loss record 247 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x805B633: CreateDescriptor (obdes.c:64)
+==6691==    by 0x80B0AA2: MakeExeManager (exeman.c:86)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691== 
+==6691== 
+==6691== 20 bytes in 1 blocks are still reachable in loss record 248 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095CB8: Tcl_GetThreadData (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D629: Tcl_AsyncReady (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A520: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691== 
+==6691== 
+==6691== 20 bytes in 1 blocks are still reachable in loss record 249 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408F2C9: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408E353: Tcl_PkgProvideEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA89: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 20 bytes in 1 blocks are still reachable in loss record 250 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A45BF: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 20 bytes in 1 blocks are still reachable in loss record 251 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4069723: TclSetupEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9B7: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 20 bytes in 1 blocks are still reachable in loss record 252 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408861F: Tcl_RegisterObjType (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4088537: TclInitObjSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7A7: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 21 bytes in 1 blocks are still reachable in loss record 253 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A9FA: InitIniCommands (ofac.c:327)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 21 bytes in 1 blocks are still reachable in loss record 254 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A81E: InitIniCommands (ofac.c:301)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 21 bytes in 1 blocks are still reachable in loss record 255 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404E655: Tcl_CreateObjCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80585ED: MacroInit (macro.c:346)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 21 bytes in 1 blocks are still reachable in loss record 256 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A270: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A46DF: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 21 bytes in 1 blocks are still reachable in loss record 257 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408861F: Tcl_RegisterObjType (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4088553: TclInitObjSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7A7: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 22 bytes in 1 blocks are still reachable in loss record 258 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40675AD: Tcl_CreateEncoding (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4067006: TclInitEncodingSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7B1: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 23 bytes in 1 blocks are still reachable in loss record 259 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404E655: Tcl_CreateObjCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x407554C: TclInterpInit (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9AF: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 23 bytes in 1 blocks are still reachable in loss record 260 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408861F: Tcl_RegisterObjType (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4084711: TclInitNamespaceSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7B6: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 23 bytes in 1 blocks are still reachable in loss record 261 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408861F: Tcl_RegisterObjType (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4088545: TclInitObjSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7A7: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 23 bytes in 1 blocks are still reachable in loss record 262 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408861F: Tcl_RegisterObjType (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4088529: TclInitObjSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7A7: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 24 (12 direct, 12 indirect) bytes in 1 blocks are definitely lost in loss record 263 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x80660D7: ListInit (lld.c:76)
+==6691==    by 0x8066469: LLDcreate (lld.c:196)
+==6691==    by 0x807D0DE: CreateCallBackInterface (callback.c:92)
+==6691==    by 0x80B0AAF: MakeExeManager (exeman.c:87)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 20 bytes in 1 blocks are indirectly lost in loss record 264 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x8077E2B: CreateDynar (sdynar.c:24)
+==6691==    by 0x80B0AF1: MakeExeManager (exeman.c:90)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691== 
+==6691== 
+==6691== 24 (12 direct, 12 indirect) bytes in 1 blocks are definitely lost in loss record 265 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x80660D7: ListInit (lld.c:76)
+==6691==    by 0x8066469: LLDcreate (lld.c:196)
+==6691==    by 0x80B0B0E: MakeExeManager (exeman.c:92)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691== 
+==6691== 
+==6691== 13 bytes in 1 blocks are still reachable in loss record 266 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405C611: Tcl_SwitchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 13 bytes in 2 blocks are still reachable in loss record 267 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 13 bytes in 2 blocks are still reachable in loss record 268 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060929: TclCompileWhileCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 14 bytes in 1 blocks are still reachable in loss record 269 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 14 bytes in 2 blocks are still reachable in loss record 270 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 14 bytes in 2 blocks are still reachable in loss record 271 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 14 bytes in 2 blocks are still reachable in loss record 272 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406040F: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 15 bytes in 2 blocks are still reachable in loss record 273 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 15 bytes in 2 blocks are still reachable in loss record 274 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 16 bytes in 1 blocks are still reachable in loss record 275 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095B41: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40953B1: Tcl_AppendObjToObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AC59: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4050A40: Tcl_AddObjErrorInfo (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A776: Tcl_LogCommandInfo (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406E83E: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 16 bytes in 1 blocks are still reachable in loss record 276 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095B41: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409528F: Tcl_AppendToObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055BAB: Tcl_FormatObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 16 bytes in 1 blocks are still reachable in loss record 277 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 16 bytes in 3 blocks are still reachable in loss record 278 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 16 bytes in 3 blocks are still reachable in loss record 279 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406040F: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 16 bytes in 1 blocks are still reachable in loss record 280 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4087D46: Tcl_CreateEventSource (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409610F: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4096279: Tcl_DeleteTimerHandler (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4078DF4: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4078C31: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4079000: Tcl_Close (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080F8B: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 17 bytes in 2 blocks are still reachable in loss record 281 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062DF8: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 18 bytes in 3 blocks are still reachable in loss record 282 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 18 bytes in 1 blocks are still reachable in loss record 283 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406C189: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4054AEF: Tcl_ForObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 19 bytes in 1 blocks are still reachable in loss record 284 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 21 bytes in 3 blocks are still reachable in loss record 285 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 21 bytes in 1 blocks are still reachable in loss record 286 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409B0EA: TclSetElementOfIndexedArray (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406BF85: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 22 bytes in 3 blocks are still reachable in loss record 287 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 22 bytes in 1 blocks are still reachable in loss record 288 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408861F: Tcl_RegisterObjType (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40751AE: Tcl_GetIndexFromObjStruct (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4075147: Tcl_GetIndexFromObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40560BC: Tcl_InfoObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40507B3: Tcl_ExprObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404FA9E: Tcl_ExprBooleanObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055D42: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 23 bytes in 1 blocks are still reachable in loss record 289 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406C065: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4054B58: Tcl_ForObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 1 blocks are still reachable in loss record 290 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405C611: Tcl_SwitchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 291 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062DF8: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 1 blocks are still reachable in loss record 292 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 293 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 294 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 295 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 296 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 297 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061000: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40612C3: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D80B: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 298 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 1 blocks are still reachable in loss record 299 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 300 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 301 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 302 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 303 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 304 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E0DC: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 305 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 1 blocks are still reachable in loss record 306 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 1 blocks are still reachable in loss record 307 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 308 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FFC5: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405C611: Tcl_SwitchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 309 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40825A2: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4081CCA: Tcl_ListObjGetElements (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405C352: Tcl_SwitchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 310 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406329F: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 311 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406040F: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 312 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 1 blocks are still reachable in loss record 313 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 314 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406020D: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 315 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 1 blocks are still reachable in loss record 316 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 317 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 1 blocks are still reachable in loss record 318 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 319 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 1 blocks are still reachable in loss record 320 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40609B0: TclCompileWhileCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 321 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060929: TclCompileWhileCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 1 blocks are still reachable in loss record 322 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060929: TclCompileWhileCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 323 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 324 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406040F: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 2 blocks are still reachable in loss record 325 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4081C63: Tcl_SetListObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4057D56: Tcl_ListObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A83E: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 8 blocks are still reachable in loss record 326 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80C6D53: InstallTasMotor (tasdrive.c:699)
+==6691==    by 0x80A8BBB: TasUBFactory (tasub.c:327)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24 bytes in 1 blocks are still reachable in loss record 327 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404E4BA: Tcl_CreateCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058582: MacroInit (macro.c:334)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 24 bytes in 1 blocks are still reachable in loss record 328 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A270: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A45F0: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 24 bytes in 1 blocks are still reachable in loss record 329 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408861F: Tcl_RegisterObjType (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC01: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC9B: TclCreateExecEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D7FD: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 24 bytes in 1 blocks are still reachable in loss record 330 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40675AD: Tcl_CreateEncoding (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406703E: TclInitEncodingSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7B1: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 24 bytes in 1 blocks are still reachable in loss record 331 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408861F: Tcl_RegisterObjType (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408850D: TclInitObjSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7A7: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 25 bytes in 3 blocks are still reachable in loss record 332 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 25 bytes in 5 blocks are still reachable in loss record 333 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 25 bytes in 1 blocks are still reachable in loss record 334 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A270: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A4467: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 25 bytes in 1 blocks are still reachable in loss record 335 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40675AD: Tcl_CreateEncoding (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4066FB5: TclInitEncodingSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7B1: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 25 bytes in 1 blocks are still reachable in loss record 336 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408861F: Tcl_RegisterObjType (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408856F: TclInitObjSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7A7: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 25 bytes in 1 blocks are still reachable in loss record 337 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408861F: Tcl_RegisterObjType (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4088561: TclInitObjSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7A7: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 26 bytes in 1 blocks are still reachable in loss record 338 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A270: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409BF26: Tcl_LappendObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 26 bytes in 1 blocks are still reachable in loss record 339 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E13A: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 26 bytes in 1 blocks are still reachable in loss record 340 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409CB64: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D182: Tcl_GlobalObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 26 bytes in 1 blocks are still reachable in loss record 341 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40509FE: Tcl_AddObjErrorInfo (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A776: Tcl_LogCommandInfo (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AD53: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 26 bytes in 1 blocks are still reachable in loss record 342 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405099F: Tcl_AddObjErrorInfo (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A776: Tcl_LogCommandInfo (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AD53: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691== 
+==6691== 
+==6691== 26 bytes in 1 blocks are still reachable in loss record 343 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404E4BA: Tcl_CreateCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40907C4: Tcl_ProcObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691== 
+==6691== 
+==6691== 26 bytes in 1 blocks are still reachable in loss record 344 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A270: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A45BF: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 26 bytes in 1 blocks are still reachable in loss record 345 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A270: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9E5: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 26 bytes in 1 blocks are still reachable in loss record 346 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408861F: Tcl_RegisterObjType (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408851B: TclInitObjSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7A7: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 27 bytes in 1 blocks are still reachable in loss record 347 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x805828F: SicsUnknownProc (macro.c:205)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 28 bytes in 1 blocks are still reachable in loss record 348 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D0D1: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 28 bytes in 1 blocks are still reachable in loss record 349 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FF87: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 28 bytes in 1 blocks are still reachable in loss record 350 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082450: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4081CCA: Tcl_ListObjGetElements (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405AFC8: Tcl_StringObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 28 bytes in 1 blocks are still reachable in loss record 351 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D0D1: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 28 bytes in 1 blocks are still reachable in loss record 352 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095CB8: Tcl_GetThreadData (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40960ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4096279: Tcl_DeleteTimerHandler (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4078DF4: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4078C31: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4079000: Tcl_Close (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080F8B: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 28 bytes in 1 blocks are still reachable in loss record 353 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408148F: Tcl_LinkVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061F63: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 28 bytes in 1 blocks are still reachable in loss record 354 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A4430: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691== 
+==6691== 
+==6691== 28 bytes in 1 blocks are still reachable in loss record 355 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA2D: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 28 bytes in 1 blocks are still reachable in loss record 356 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408148F: Tcl_LinkVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC28: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC9B: TclCreateExecEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D7FD: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 28 bytes in 1 blocks are still reachable in loss record 357 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4064B4E: TclRegisterAuxDataType (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4064BF6: TclInitAuxDataTypeTable (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC90: TclCreateExecEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D7FD: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 29 bytes in 1 blocks are still reachable in loss record 358 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FF87: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 29 bytes in 3 blocks are still reachable in loss record 359 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 29 bytes in 1 blocks are still reachable in loss record 360 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4090C1E: TclCreateProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4090714: Tcl_ProcObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691== 
+==6691== 
+==6691== 29 bytes in 1 blocks are still reachable in loss record 361 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4069CA8: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D60B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A4EB: Tcl_GetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A42F: Tcl_ObjGetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406BC66: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 29 bytes in 1 blocks are still reachable in loss record 362 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9E5: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 30 bytes in 1 blocks are still reachable in loss record 363 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FF87: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 30 bytes in 1 blocks are still reachable in loss record 364 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FF87: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 30 bytes in 10 blocks are still reachable in loss record 365 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A96F: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A83E: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 30 bytes in 1 blocks are still reachable in loss record 366 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409B878: Tcl_TraceVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA61: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 30 bytes in 1 blocks are still reachable in loss record 367 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408150D: Tcl_LinkVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC28: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC9B: TclCreateExecEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D7FD: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 31 bytes in 1 blocks are still reachable in loss record 368 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA09: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 369 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A29E: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409BF26: Tcl_LappendObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 370 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409B105: TclSetElementOfIndexedArray (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406BF85: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 371 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409CB64: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D182: Tcl_GlobalObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 372 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x805828F: SicsUnknownProc (macro.c:205)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 373 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406C065: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4054B58: Tcl_ForObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 374 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406C189: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4054AEF: Tcl_ForObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 375 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40509FE: Tcl_AddObjErrorInfo (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A776: Tcl_LogCommandInfo (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AD53: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 376 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405099F: Tcl_AddObjErrorInfo (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A776: Tcl_LogCommandInfo (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AD53: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 377 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40908B3: TclCreateProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4090714: Tcl_ProcObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 378 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4090296: Tcl_Preserve (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B49F: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 379 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408150D: Tcl_LinkVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061F63: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 380 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A29E: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A46DF: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 381 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A29E: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A45F0: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 382 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A29E: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A45BF: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 383 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A29E: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A44DE: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 384 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A29E: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A4467: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 385 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A4430: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 386 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A4409: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 387 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409B878: Tcl_TraceVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA61: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 388 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA2D: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 389 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA09: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 390 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A29E: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9E5: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 391 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9E5: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 392 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4069723: TclSetupEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9B7: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 393 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408150D: Tcl_LinkVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC28: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC9B: TclCreateExecEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D7FD: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 394 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095D3B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095E4C: TclRememberDataKey (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095CDB: Tcl_GetThreadData (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40779DD: TclInitIOSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7AC: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 32 bytes in 1 blocks are still reachable in loss record 395 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095CB8: Tcl_GetThreadData (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40779DD: TclInitIOSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7AC: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 33 bytes in 1 blocks are still reachable in loss record 396 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 33 bytes in 2 blocks are still reachable in loss record 397 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 33 bytes in 2 blocks are still reachable in loss record 398 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 33 bytes in 2 blocks are still reachable in loss record 399 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 33 bytes in 1 blocks are still reachable in loss record 400 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408150D: Tcl_LinkVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061F63: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 34 bytes in 7 blocks are still reachable in loss record 401 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 34 bytes in 10 blocks are still reachable in loss record 402 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8073880: SicsAlias (alias.c:82)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 34 bytes in 1 blocks are still reachable in loss record 403 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A902: Tcl_SetVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A4409: TclpSetVariables (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DA69: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691== 
+==6691== 
+==6691== 34 bytes in 1 blocks are still reachable in loss record 404 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DB9A: Tcl_CallWhenDeleted (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4075566: TclInterpInit (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9AF: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 35 bytes in 5 blocks are still reachable in loss record 405 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 3 blocks are still reachable in loss record 406 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 3 blocks are still reachable in loss record 407 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E0DC: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 3 blocks are still reachable in loss record 408 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 3 blocks are still reachable in loss record 409 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 3 blocks are still reachable in loss record 410 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 3 blocks are still reachable in loss record 411 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 3 blocks are still reachable in loss record 412 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 3 blocks are still reachable in loss record 413 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 3 blocks are still reachable in loss record 414 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 3 blocks are still reachable in loss record 415 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 3 blocks are still reachable in loss record 416 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 3 blocks are still reachable in loss record 417 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 3 blocks are still reachable in loss record 418 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 3 blocks are still reachable in loss record 419 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406040F: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 420 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8056252: InitServer (nserver.c:260)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 7 blocks are still reachable in loss record 421 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4090C90: TclCreateProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4090714: Tcl_ProcObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 422 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80DCC9E: SICSDataFactory (sicsdata.c:854)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4052FE9: Tcl_CatchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 423 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80DA106: MakeNXScript (nxscript.c:1296)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 424 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805CA5B: MakeDrive (drive.c:491)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 425 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805C9CF: MakeDrive (drive.c:479)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are indirectly lost in loss record 426 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x8077EB1: CreateDynar (sdynar.c:37)
+==6691==    by 0x80B0AF1: MakeExeManager (exeman.c:90)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 427 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80CE573: TASUBScanFactory (tasscanub.c:1283)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 428 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8091787: FitFactory (fitcenter.c:391)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 429 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8091764: FitFactory (fitcenter.c:390)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 430 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x808D578: ScanFactory (scan.c:1254)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 431 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x808D50B: ScanFactory (scan.c:1239)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 432 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80C6E6B: InstallTasQMMotor (tasdrive.c:726)
+==6691==    by 0x80A8C22: TasUBFactory (tasub.c:333)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 433 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80A8B59: TasUBFactory (tasub.c:314)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 434 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8123BBD: MakeFrameFunc (frame.c:243)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 435 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x81620AA: MakeRitaFix (ritastorage.c:77)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 436 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8084A16: DNFactory (danu.c:407)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 437 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80849A8: DNFactory (danu.c:400)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 438 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8079377: MakeHistMemory (histmem.c:557)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 439 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80FA7D9: MakeCounter (counter.c:563)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 440 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059A70: TclPublish (macro.c:1082)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 441 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80D1968: AntiColliderFactory (anticollider.c:296)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 442 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80F75C3: MotorCreate (motor.c:1061)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 443 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x809252D: TokenInit (token.c:52)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 444 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80FF3BD: AddPsiCommands (psi.c:122)
+==6691==    by 0x805AAC0: InitIniCommands (ofac.c:347)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 445 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80FF315: AddPsiCommands (psi.c:116)
+==6691==    by 0x805AAC0: InitIniCommands (ofac.c:347)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 446 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805AA86: InitIniCommands (ofac.c:337)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 447 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A9FA: InitIniCommands (ofac.c:327)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 448 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A8AA: InitIniCommands (ofac.c:306)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 449 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A88E: InitIniCommands (ofac.c:305)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 450 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A81E: InitIniCommands (ofac.c:301)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 451 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A6EA: InitIniCommands (ofac.c:290)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 452 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A6B2: InitIniCommands (ofac.c:288)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 453 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A5EE: InitIniCommands (ofac.c:281)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 454 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A50E: InitIniCommands (ofac.c:273)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 455 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A44A: InitIniCommands (ofac.c:264)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 456 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A42D: InitIniCommands (ofac.c:263)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 457 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A410: InitIniCommands (ofac.c:262)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 458 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A3F3: InitIniCommands (ofac.c:261)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 459 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A3D6: InitIniCommands (ofac.c:260)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 460 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A3B9: InitIniCommands (ofac.c:259)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 461 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A39C: InitIniCommands (ofac.c:258)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 462 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A37C: InitIniCommands (ofac.c:252)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 463 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A360: InitIniCommands (ofac.c:251)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 464 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A344: InitIniCommands (ofac.c:250)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 465 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A325: InitIniCommands (ofac.c:249)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 466 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A309: InitIniCommands (ofac.c:248)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 467 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A2ED: InitIniCommands (ofac.c:247)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 468 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A2D1: InitIniCommands (ofac.c:246)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 469 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A2B5: InitIniCommands (ofac.c:245)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 470 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A299: InitIniCommands (ofac.c:244)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 471 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A27A: InitIniCommands (ofac.c:243)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 472 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A25B: InitIniCommands (ofac.c:242)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 473 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A23B: InitIniCommands (ofac.c:241)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 474 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A21F: InitIniCommands (ofac.c:240)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 475 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A203: InitIniCommands (ofac.c:239)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 476 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A1E7: InitIniCommands (ofac.c:238)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 477 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A1CB: InitIniCommands (ofac.c:237)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 478 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A1AF: InitIniCommands (ofac.c:236)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 479 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A193: InitIniCommands (ofac.c:235)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 480 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A177: InitIniCommands (ofac.c:234)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 481 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A15B: InitIniCommands (ofac.c:233)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 482 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A13F: InitIniCommands (ofac.c:232)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 483 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A123: InitIniCommands (ofac.c:231)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 484 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A107: InitIniCommands (ofac.c:230)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 485 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A0EB: InitIniCommands (ofac.c:229)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 486 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A0CF: InitIniCommands (ofac.c:228)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 487 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A0B3: InitIniCommands (ofac.c:227)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 488 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A097: InitIniCommands (ofac.c:226)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 489 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A07B: InitIniCommands (ofac.c:225)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 490 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A05F: InitIniCommands (ofac.c:224)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 491 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A043: InitIniCommands (ofac.c:223)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 492 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A027: InitIniCommands (ofac.c:222)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 493 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x805A00B: InitIniCommands (ofac.c:221)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 494 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059FEF: InitIniCommands (ofac.c:220)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 495 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059FD3: InitIniCommands (ofac.c:219)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 496 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059FB7: InitIniCommands (ofac.c:218)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 497 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059F9B: InitIniCommands (ofac.c:217)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 498 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059F7F: InitIniCommands (ofac.c:216)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 499 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059F63: InitIniCommands (ofac.c:214)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 500 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059F47: InitIniCommands (ofac.c:213)
+==6691==    by 0x805AF7A: InitObjectCommands (ofac.c:451)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 501 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80B0BC6: MakeExeManager (exeman.c:108)
+==6691==    by 0x805AF63: InitObjectCommands (ofac.c:450)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 502 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x80EF04C: StatisticsInit (statistics.c:163)
+==6691==    by 0x805AEDF: InitGeneral (ofac.c:427)
+==6691==    by 0x805AF23: InitObjectCommands (ofac.c:441)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 503 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x8051324: AddCmd (SCinter.c:192)
+==6691==    by 0x80EF026: StatisticsInit (statistics.c:161)
+==6691==    by 0x805AEDF: InitGeneral (ofac.c:427)
+==6691==    by 0x805AF23: InitObjectCommands (ofac.c:441)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 504 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8149634: LogReaderInit (logreader.c:434)
+==6691==    by 0x80FF13C: SiteInit (psi.c:88)
+==6691==    by 0x805AEDA: InitGeneral (ofac.c:426)
+==6691==    by 0x805AF23: InitObjectCommands (ofac.c:441)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 505 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80DDBF2: MakeDriver (initializer.c:177)
+==6691==    by 0x814B4D5: IlmStartup (ilmdriv.c:194)
+==6691==    by 0x80FF11E: SiteInit (psi.c:82)
+==6691==    by 0x805AEDA: InitGeneral (ofac.c:426)
+==6691==    by 0x805AF23: InitObjectCommands (ofac.c:441)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 506 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80DDBD0: MakeDriver (initializer.c:176)
+==6691==    by 0x814B4D5: IlmStartup (ilmdriv.c:194)
+==6691==    by 0x80FF11E: SiteInit (psi.c:82)
+==6691==    by 0x805AEDA: InitGeneral (ofac.c:426)
+==6691==    by 0x805AF23: InitObjectCommands (ofac.c:441)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 507 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80DDBAE: MakeDriver (initializer.c:175)
+==6691==    by 0x814B4D5: IlmStartup (ilmdriv.c:194)
+==6691==    by 0x80FF11E: SiteInit (psi.c:82)
+==6691==    by 0x805AEDA: InitGeneral (ofac.c:426)
+==6691==    by 0x805AF23: InitObjectCommands (ofac.c:441)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 508 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x804D71E: CreateConnection (conman.c:201)
+==6691==    by 0x804D7C9: SCCreateDummyConnection (conman.c:231)
+==6691==    by 0x805853F: MacroInit (macro.c:328)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 509 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40675E7: Tcl_CreateEncoding (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406703E: TclInitEncodingSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7B1: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 510 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40675E7: Tcl_CreateEncoding (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4067006: TclInitEncodingSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7B1: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 36 bytes in 1 blocks are still reachable in loss record 511 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40675E7: Tcl_CreateEncoding (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4066FB5: TclInitEncodingSubsystem (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7B1: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 48 bytes in 4 blocks are still reachable in loss record 512 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4081C63: Tcl_SetListObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4057D56: Tcl_ListObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A83E: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691== 
+==6691== 
+==6691== 52 bytes in 1 blocks are still reachable in loss record 513 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404E51C: Tcl_CreateCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40907C4: Tcl_ProcObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691== 
+==6691== 
+==6691== 52 bytes in 1 blocks are still reachable in loss record 514 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404E6DD: Tcl_CreateObjCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80585ED: MacroInit (macro.c:346)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 52 bytes in 1 blocks are still reachable in loss record 515 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404E51C: Tcl_CreateCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058582: MacroInit (macro.c:334)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 52 bytes in 1 blocks are still reachable in loss record 516 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A1E2: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9E5: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 52 bytes in 1 blocks are still reachable in loss record 517 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A1E2: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4069723: TclSetupEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9B7: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 52 bytes in 1 blocks are still reachable in loss record 518 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404DB6A: Tcl_CallWhenDeleted (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4075566: TclInterpInit (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9AF: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 52 bytes in 1 blocks are still reachable in loss record 519 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404E6DD: Tcl_CreateObjCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x407554C: TclInterpInit (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9AF: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 52 bytes in 1 blocks are still reachable in loss record 520 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095CB8: Tcl_GetThreadData (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4087C4C: TclInitNotifier (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7DA: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 60 bytes in 5 blocks are still reachable in loss record 521 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 64 bytes in 1 blocks are still reachable in loss record 522 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074E46: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074B3C: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406C189: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 64 bytes in 1 blocks are still reachable in loss record 523 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074E46: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074B3C: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060D6C: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40504CF: Tcl_ExprObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404FA9E: Tcl_ExprBooleanObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055D42: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 64 bytes in 1 blocks are still reachable in loss record 524 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074E46: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074B3C: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404EF46: Tcl_CreateMathFunc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D952: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 111 bytes in 14 blocks are still reachable in loss record 525 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80DCC9E: SICSDataFactory (sicsdata.c:854)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 137 (36 direct, 101 indirect) bytes in 1 blocks are definitely lost in loss record 526 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x80B0A53: MakeExeManager (exeman.c:79)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691== 
+==6691== 
+==6691== 37 bytes in 6 blocks are still reachable in loss record 527 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 39 bytes in 2 blocks are still reachable in loss record 528 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409B0EA: TclSetElementOfIndexedArray (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406BF85: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80597D7: TclAction (macro.c:1011)
+==6691== 
+==6691== 
+==6691== 39 bytes in 5 blocks are still reachable in loss record 529 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 40 bytes in 2 blocks are still reachable in loss record 530 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E082: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 40 bytes in 2 blocks are still reachable in loss record 531 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4081C3A: Tcl_SetListObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4057D56: Tcl_ListObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A83E: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 40 bytes in 2 blocks are still reachable in loss record 532 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406C189: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4054B58: Tcl_ForObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 41 bytes in 2 blocks are still reachable in loss record 533 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 41 bytes in 1 blocks are still reachable in loss record 534 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 42 bytes in 3 blocks are still reachable in loss record 535 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 47 bytes in 2 blocks are still reachable in loss record 536 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 47 bytes in 10 blocks are still reachable in loss record 537 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 47 bytes in 3 blocks are still reachable in loss record 538 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 48 bytes in 2 blocks are still reachable in loss record 539 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 48 bytes in 2 blocks are still reachable in loss record 540 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 48 bytes in 2 blocks are still reachable in loss record 541 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 48 bytes in 3 blocks are still reachable in loss record 542 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095B41: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409528F: Tcl_AppendToObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A9D6: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 50 bytes in 2 blocks are still reachable in loss record 543 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E06B: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 50 bytes in 2 blocks are still reachable in loss record 544 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E01A: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 52 bytes in 1 blocks are still reachable in loss record 545 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409B07B: TclSetElementOfIndexedArray (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406BF85: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80597D7: TclAction (macro.c:1011)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691== 
+==6691== 
+==6691== 52 bytes in 1 blocks are still reachable in loss record 546 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A1E2: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406C065: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4054B58: Tcl_ForObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 53 bytes in 2 blocks are still reachable in loss record 547 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 53 bytes in 6 blocks are still reachable in loss record 548 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 54 bytes in 2 blocks are still reachable in loss record 549 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 54 bytes in 2 blocks are still reachable in loss record 550 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E13A: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 55 bytes in 2 blocks are still reachable in loss record 551 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FF87: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EDCB: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40609B0: TclCompileWhileCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 56 bytes in 2 blocks are still reachable in loss record 552 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FF87: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 57 bytes in 8 blocks are still reachable in loss record 553 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 58 bytes in 2 blocks are still reachable in loss record 554 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FF87: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E489: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 60 bytes in 3 blocks are still reachable in loss record 555 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E082: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 60 bytes in 5 blocks are still reachable in loss record 556 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 60 bytes in 5 blocks are still reachable in loss record 557 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 64 bytes in 2 blocks are still reachable in loss record 558 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409B105: TclSetElementOfIndexedArray (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406BF85: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80597D7: TclAction (macro.c:1011)
+==6691== 
+==6691== 
+==6691== 64 bytes in 2 blocks are still reachable in loss record 559 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406C189: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4054B58: Tcl_ForObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 71 bytes in 9 blocks are still reachable in loss record 560 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 72 bytes in 6 blocks are still reachable in loss record 561 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063662: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 72 bytes in 6 blocks are still reachable in loss record 562 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 72 bytes in 6 blocks are still reachable in loss record 563 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 75 bytes in 3 blocks are still reachable in loss record 564 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E06B: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 75 bytes in 3 blocks are still reachable in loss record 565 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E01A: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 75 bytes in 3 blocks are still reachable in loss record 566 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A87B: Tcl_SetObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 78 bytes in 1 blocks are still reachable in loss record 567 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80589B9: MacroFileEval (macro.c:500)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805D312: RestoreStatus (status.c:397)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 84 bytes in 8 blocks are still reachable in loss record 568 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 84 bytes in 7 blocks are still reachable in loss record 569 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 84 bytes in 7 blocks are still reachable in loss record 570 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E0DC: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 84 bytes in 7 blocks are still reachable in loss record 571 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406114E: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061289: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060E0D: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063A78: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EAC1: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 85 bytes in 7 blocks are still reachable in loss record 572 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 89 bytes in 1 blocks are still reachable in loss record 573 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409512D: Tcl_SetObjLength (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095732: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095482: Tcl_AppendObjToObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AC59: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4050A40: Tcl_AddObjErrorInfo (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A776: Tcl_LogCommandInfo (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406E83E: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 96 bytes in 8 blocks are still reachable in loss record 574 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062F53: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063ABE: TclCompileExprWords (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D687: TclCompileExprCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 96 bytes in 8 blocks are still reachable in loss record 575 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 96 bytes in 3 blocks are still reachable in loss record 576 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A87B: Tcl_SetObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 104 bytes in 4 blocks are still reachable in loss record 577 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FF87: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D791: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 108 bytes in 9 blocks are still reachable in loss record 578 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 112 bytes in 4 blocks are still reachable in loss record 579 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E13A: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 114 bytes in 6 blocks are still reachable in loss record 580 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A270: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A87B: Tcl_SetObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 117 bytes in 1 blocks are still reachable in loss record 581 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x8058B3F: MacroFileEval (macro.c:532)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 120 bytes in 5 blocks are still reachable in loss record 582 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 120 bytes in 10 blocks are still reachable in loss record 583 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 137 bytes in 15 blocks are still reachable in loss record 584 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 138 bytes in 6 blocks are still reachable in loss record 585 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A87B: Tcl_SetObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 140 bytes in 7 blocks are still reachable in loss record 586 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E082: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 143 bytes in 5 blocks are still reachable in loss record 587 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FF87: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D1A9: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 144 bytes in 6 blocks are still reachable in loss record 588 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 149 bytes in 6 blocks are still reachable in loss record 589 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F76: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406C189: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 157 bytes in 37 blocks are still reachable in loss record 590 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 168 bytes in 7 blocks are still reachable in loss record 591 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 169 bytes in 47 blocks are still reachable in loss record 592 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A96F: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A83E: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691== 
+==6691== 
+==6691== 171 bytes in 1 blocks are still reachable in loss record 593 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409512D: Tcl_SetObjLength (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095732: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40952EF: Tcl_AppendToObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055BAB: Tcl_FormatObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 172 bytes in 1 blocks are still reachable in loss record 594 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40754CA: TclInterpInit (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9AF: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 175 bytes in 7 blocks are still reachable in loss record 595 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E06B: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 175 bytes in 7 blocks are still reachable in loss record 596 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405E01A: TclCompileForeachCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 179 bytes in 49 blocks are still reachable in loss record 597 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80F75C3: MotorCreate (motor.c:1061)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 180 bytes in 15 blocks are still reachable in loss record 598 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 182 bytes in 3 blocks are still reachable in loss record 599 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B188: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691== 
+==6691== 
+==6691== 188 bytes in 4 blocks are still reachable in loss record 600 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4081C3A: Tcl_SetListObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4057D56: Tcl_ListObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A83E: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691== 
+==6691== 
+==6691== 192 bytes in 12 blocks are still reachable in loss record 601 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095B41: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409528F: Tcl_AppendToObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A9D6: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 192 bytes in 6 blocks are still reachable in loss record 602 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A29E: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A87B: Tcl_SetObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 192 bytes in 6 blocks are still reachable in loss record 603 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406C189: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 192 bytes in 6 blocks are still reachable in loss record 604 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4099F7D: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A87B: Tcl_SetObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 196 bytes in 7 blocks are still reachable in loss record 605 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D0D1: TclCompileCatchCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 200 bytes in 1 blocks are still reachable in loss record 606 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409332C: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4093121: Tcl_AppendResultVA (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40931B5: Tcl_AppendResult (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80580AC: SicsUnknownProc (macro.c:160)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 216 bytes in 18 blocks are still reachable in loss record 607 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 216 bytes in 9 blocks are still reachable in loss record 608 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 228 bytes in 1 blocks are still reachable in loss record 609 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40849DA: Tcl_CreateNamespace (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D7E0: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 256 bytes in 1 blocks are still reachable in loss record 610 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074E46: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074B3C: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A270: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4069723: TclSetupEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9B7: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691== 
+==6691== 
+==6691== 268 bytes in 24 blocks are still reachable in loss record 611 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 288 bytes in 24 blocks are still reachable in loss record 612 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627BA: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 288 bytes in 8 blocks are still reachable in loss record 613 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80C6D53: InstallTasMotor (tasdrive.c:699)
+==6691==    by 0x80A8BBB: TasUBFactory (tasub.c:327)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 312 bytes in 13 blocks are still reachable in loss record 614 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406FE6B: TclSetCmdNameObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40627EB: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 352 bytes in 1 blocks are still reachable in loss record 615 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x4157062: __fopen_internal (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x415712D: fopen@@GLIBC_2.1 (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x8054358: OpenVerifyLogFile (servlog.c:251)
+==6691==    by 0x80544BD: SICSLogWrite (servlog.c:311)
+==6691==    by 0x804E3DC: SCNormalWrite (conman.c:701)
+==6691==    by 0x804E011: SCWrite (conman.c:564)
+==6691==    by 0x804F1FF: SCSendOK (conman.c:1232)
+==6691==    by 0x80DB368: putFloat (sicsdata.c:316)
+==6691==    by 0x80DC8E4: SICSDataAction (sicsdata.c:793)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 352 bytes in 1 blocks are still reachable in loss record 616 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063DAF: TclInitByteCodeObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406207F: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405C611: Tcl_SwitchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 360 bytes in 10 blocks are still reachable in loss record 617 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8073880: SicsAlias (alias.c:82)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 377 bytes in 13 blocks are still reachable in loss record 618 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FF87: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405D8B9: TclCompileForCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 386 bytes in 21 blocks are still reachable in loss record 619 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4060D6C: TclCompileExpr (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40504CF: Tcl_ExprObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404FA9E: Tcl_ExprBooleanObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055D42: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 389 bytes in 4 blocks are still reachable in loss record 620 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408268C: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408897D: Tcl_GetString (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF8E: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691==    by 0x8055CC2: InitServer (nserver.c:121)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 444 bytes in 37 blocks are still reachable in loss record 621 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 484 bytes in 1 blocks are still reachable in loss record 622 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D65F: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 488 bytes in 53 blocks are still reachable in loss record 623 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8054ABA: VarFactory (sicvar.c:208)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 490 bytes in 18 blocks are still reachable in loss record 624 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 504 bytes in 14 blocks are still reachable in loss record 625 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80DCC9E: SICSDataFactory (sicsdata.c:854)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 516 bytes in 43 blocks are still reachable in loss record 626 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 518 bytes in 18 blocks are still reachable in loss record 627 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FF87: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 525 bytes in 25 blocks are still reachable in loss record 628 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404EF46: Tcl_CreateMathFunc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D952: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 565 bytes in 85 blocks are still reachable in loss record 629 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x416F4EF: strdup (in /lib/tls/libc-2.3.2.so)
+==6691==    by 0x80EEE17: StatisticsNew (statistics.c:100)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059A70: TclPublish (macro.c:1082)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 576 bytes in 43 blocks are still reachable in loss record 630 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 636 bytes in 3 blocks are still reachable in loss record 631 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063DAF: TclInitByteCodeObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406207F: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405C611: Tcl_SwitchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 702 bytes in 92 blocks are still reachable in loss record 632 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 776 bytes in 1 blocks are still reachable in loss record 633 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095CB8: Tcl_GetThreadData (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40A49E1: Tcl_InitNotifier (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4087C5B: TclInitNotifier (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406A7DA: TclInitSubsystems (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D653: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 795 bytes in 1 blocks are still reachable in loss record 634 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40829A3: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405EC0A: TclCompileIfCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40639CD: TclCompileCmdWord (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40609B0: TclCompileWhileCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 883 bytes in 29 blocks are still reachable in loss record 635 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FF87: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 900 bytes in 25 blocks are still reachable in loss record 636 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404EF5B: Tcl_CreateMathFunc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D952: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 1,023 bytes in 16 blocks are still reachable in loss record 637 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082503: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4081CCA: Tcl_ListObjGetElements (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405C352: Tcl_SwitchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 1,024 bytes in 1 blocks are still reachable in loss record 638 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082F68: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A73: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 1,024 bytes in 1 blocks are still reachable in loss record 639 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074E46: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074B3C: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404E4BA: Tcl_CreateCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40907C4: Tcl_ProcObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 1,024 bytes in 1 blocks are still reachable in loss record 640 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074E46: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074B3C: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A270: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406C065: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4054B58: Tcl_ForObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 1,104 bytes in 92 blocks are still reachable in loss record 641 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082A3A: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 1,352 bytes in 2 blocks are still reachable in loss record 642 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082450: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4081CCA: Tcl_ListObjGetElements (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405C352: Tcl_SwitchObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 1,404 bytes in 1 blocks are still reachable in loss record 643 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063DAF: TclInitByteCodeObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406207F: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80D13F8: ColliderSetValue (anticollider.c:113)
+==6691== 
+==6691== 
+==6691== 1,585 bytes in 71 blocks are still reachable in loss record 644 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D864: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 1,663 bytes in 57 blocks are still reachable in loss record 645 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40640AD: TclFindCompiledLocal (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x405FF87: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406276A: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 1,764 bytes in 49 blocks are still reachable in loss record 646 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x80F75C3: MotorCreate (motor.c:1061)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 1,908 bytes in 53 blocks are still reachable in loss record 647 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8054ABA: VarFactory (sicvar.c:208)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A349: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 2,400 bytes in 1 blocks are still reachable in loss record 648 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40887B0: TclAllocateFreeObjects (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40934EB: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x4093419: Tcl_ResetResult (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B567: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2,400 bytes in 1 blocks are still reachable in loss record 649 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40887B0: TclAllocateFreeObjects (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082937: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2,400 bytes in 1 blocks are still reachable in loss record 650 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40887B0: TclAllocateFreeObjects (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082937: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2,400 bytes in 1 blocks are still reachable in loss record 651 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40887B0: TclAllocateFreeObjects (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082937: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40628C5: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4062EF2: TclCompileTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406056B: TclCompileSetCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2,400 bytes in 1 blocks are still reachable in loss record 652 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40887B0: TclAllocateFreeObjects (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094C9F: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A96F: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2,400 bytes in 1 blocks are still reachable in loss record 653 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40887B0: TclAllocateFreeObjects (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094C9F: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A96F: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2,400 bytes in 1 blocks are still reachable in loss record 654 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40887B0: TclAllocateFreeObjects (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40896DF: Tcl_NewLongObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406E6D5: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2,400 bytes in 1 blocks are still reachable in loss record 655 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40887B0: TclAllocateFreeObjects (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094C9F: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059E95: Tcl_SplitObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2,400 bytes in 1 blocks are still reachable in loss record 656 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40887B0: TclAllocateFreeObjects (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094C9F: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4069723: TclSetupEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9B7: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 2,400 bytes in 1 blocks are still reachable in loss record 657 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40887B0: TclAllocateFreeObjects (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408873E: Tcl_NewObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D67F: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 2,560 bytes in 80 blocks are still reachable in loss record 658 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40908B3: TclCreateProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4090714: Tcl_ProcObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2,612 bytes in 90 blocks are still reachable in loss record 659 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4090C1E: TclCreateProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4090714: Tcl_ProcObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2,784 bytes in 87 blocks are still reachable in loss record 660 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40908B3: TclCreateProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4090714: Tcl_ProcObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 2,813 bytes in 97 blocks are still reachable in loss record 661 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4090C1E: TclCreateProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4090714: Tcl_ProcObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 3,060 bytes in 85 blocks are still reachable in loss record 662 of 685
+==6691==    at 0x401BC74: calloc (vg_replace_malloc.c:279)
+==6691==    by 0x80EEDB7: StatisticsNew (statistics.c:91)
+==6691==    by 0x8051254: AddCommandWithFlag (SCinter.c:159)
+==6691==    by 0x80512D8: AddCommand (SCinter.c:182)
+==6691==    by 0x8059A70: TclPublish (macro.c:1082)
+==6691==    by 0x80581ED: SicsUnknownProc (macro.c:184)
+==6691==    by 0x404E7EB: TclInvokeStringCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 3,064 bytes in 1 blocks are still reachable in loss record 663 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409BE33: Tcl_LappendObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80597D7: TclAction (macro.c:1011)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691== 
+==6691== 
+==6691== 3,152 bytes in 197 blocks are still reachable in loss record 664 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095B41: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409528F: Tcl_AppendToObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055BAB: Tcl_FormatObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4054B58: Tcl_ForObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 3,233 bytes in 1 blocks are still reachable in loss record 665 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409512D: Tcl_SetObjLength (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095732: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40952EF: Tcl_AppendToObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A9D6: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691==    by 0x80516BD: InterpExecute (SCinter.c:322)
+==6691==    by 0x805AFB9: InitObjectCommands (ofac.c:457)
+==6691== 
+==6691== 
+==6691== 3,692 bytes in 71 blocks are still reachable in loss record 666 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D87D: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 3,973 bytes in 139 blocks are still reachable in loss record 667 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A270: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4069723: TclSetupEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9B7: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 4,034 bytes in 196 blocks are still reachable in loss record 668 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A270: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406C065: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4054B58: Tcl_ForObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 4,160 bytes in 80 blocks are still reachable in loss record 669 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404E51C: Tcl_CreateCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40907C4: Tcl_ProcObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 4,318 bytes in 167 blocks are still reachable in loss record 670 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4074AED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404E4FC: Tcl_CreateCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40907C4: Tcl_ProcObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 4,448 bytes in 139 blocks are still reachable in loss record 671 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A29E: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A95E: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4069723: TclSetupEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9B7: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691== 
+==6691== 
+==6691== 4,524 bytes in 87 blocks are still reachable in loss record 672 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404E51C: Tcl_CreateCommand (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40907C4: Tcl_ProcObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 4,781 bytes in 400 blocks are still reachable in loss record 673 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059EEF: Tcl_SplitObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 4,800 bytes in 2 blocks are still reachable in loss record 674 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40887B0: TclAllocateFreeObjects (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4082937: TclRegisterLiteral (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406280E: TclCompileScript (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4061FF9: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F1F6: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055F54: Tcl_IfObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 5,108 bytes in 9 blocks are still reachable in loss record 675 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063DAF: TclInitByteCodeObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406207F: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 5,599 bytes in 197 blocks are still reachable in loss record 676 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409512D: Tcl_SetObjLength (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095732: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40952EF: Tcl_AppendToObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4055BAB: Tcl_FormatObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4054B58: Tcl_ForObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 5,946 bytes in 137 blocks are still reachable in loss record 677 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A936: Tcl_SetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4069723: TclSetupEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D9B7: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 6,272 bytes in 196 blocks are still reachable in loss record 678 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409D6ED: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A29E: TclLookupVar (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409AA67: Tcl_SetVar2Ex (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409A9F8: Tcl_ObjSetVar2 (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406C065: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4054B58: Tcl_ForObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 6,492 bytes in 8 blocks are still reachable in loss record 679 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063DAF: TclInitByteCodeObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406207F: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80597D7: TclAction (macro.c:1011)
+==6691== 
+==6691== 
+==6691== 7,656 bytes in 20 blocks are still reachable in loss record 680 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4063DAF: TclInitByteCodeObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406207F: TclSetByteCodeFromAny (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406215B: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40918B2: TclProcCompileProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409135C: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 8,000 bytes in 1 blocks are still reachable in loss record 681 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406AC72: TclCreateExecEnv (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404D7FD: Tcl_CreateInterp (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x80584EB: MacroInit (macro.c:319)
+==6691==    by 0x8051065: InitInterp (SCinter.c:101)
+==6691==    by 0x8055C1E: InitServer (nserver.c:106)
+==6691==    by 0x8056912: main (SICSmain.c:46)
+==6691== 
+==6691== 
+==6691== 9,600 bytes in 4 blocks are still reachable in loss record 682 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40887B0: TclAllocateFreeObjects (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4088FDE: Tcl_NewDoubleObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406F022: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x406DFB6: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40507B3: Tcl_ExprObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B954: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x404F291: Tcl_EvalObjEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40916B7: TclObjInterpProc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x406B602: TclExecuteByteCode (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 24,766 bytes in 74 blocks are still reachable in loss record 683 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A96F: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== 
+==6691== 31,707 bytes in 80 blocks are still reachable in loss record 684 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4094CE1: Tcl_NewStringObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A96F: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AF61: Tcl_Eval (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x8058B63: MacroFileEval (macro.c:535)
+==6691== 
+==6691== 
+==6691== 42,898 bytes in 20 blocks are still reachable in loss record 685 of 685
+==6691==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==6691==    by 0x404D3A6: TclpAlloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x40523C8: Tcl_Alloc (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x409512D: Tcl_SetObjLength (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4095732: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x40952EF: Tcl_AppendToObj (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A9D6: Tcl_EvalTokens (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408AB86: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4080FD8: Tcl_EvalFile (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x4059CC1: Tcl_SourceObjCmd (in /usr/lib/libtcl8.3.so)
+==6691==    by 0x408A512: (within /usr/lib/libtcl8.3.so)
+==6691==    by 0x408ABFD: Tcl_EvalEx (in /usr/lib/libtcl8.3.so)
+==6691== 
+==6691== LEAK SUMMARY:
+==6691==    definitely lost: 109 bytes in 8 blocks.
+==6691==    indirectly lost: 125 bytes in 9 blocks.
+==6691==      possibly lost: 0 bytes in 0 blocks.
+==6691==    still reachable: 287,460 bytes in 4,818 blocks.
+==6691==         suppressed: 0 bytes in 0 blocks.