let HTK I/O implementation be a single package

36 files changed, 0 insertions, 11574 deletions

diff --git a/tnet_io/KaldiLib/Common.cc b/tnet_io/KaldiLib/Common.cc
deleted file mode 100644
index 40909ee..0000000
--- a/tnet_io/KaldiLib/Common.cc
+++ /dev/null
@@ -1,277 +0,0 @@
-#include <string>
-#include <stdexcept>
-#include <cmath>
-#include <cfloat>
-#include <cstdio>
-
-#include "Common.h"
-#include "MathAux.h"
-
-
-/// Defines the white chars for string trimming
-#if !defined(WHITE_CHARS)
-#  define WHITE_CHARS " \t"
-#endif
-
-namespace TNet {
-
-#include <ios>
-  
-  // Allocating stream variable used by stream modifier MatrixVectorIostreamControl
-  const int MATRIX_IOS_FORMAT_IWORD = std::ios_base::xalloc();
-
-  //***************************************************************************
-  //***************************************************************************
-  int getHTKstr(char *str)
-  {
-    char termChar = '\0';
-    char *chrptr = str;
-  
-    while (std::isspace(*chrptr)) ++chrptr;
-  
-    if (*chrptr == '\'' || *chrptr == '"') {
-      termChar = *chrptr;
-      chrptr++;
-    }
-  
-    for (; *chrptr; chrptr++) {
-      if (*chrptr == '\'' || *chrptr == '"') {
-        if (termChar == *chrptr) {
-          termChar = '\0';
-          chrptr++;
-          break;
-        }
-      }
-  
-      if (std::isspace(*chrptr) && !termChar) {
-        break;
-      }
-  
-      if (*chrptr == '\\') {
-        ++chrptr;
-        if (*chrptr == '\0' || (*chrptr    >= '0' && *chrptr <= '7' &&
-                              (*++chrptr  <  '0' || *chrptr >  '7' ||
-                              *++chrptr  <  '0' || *chrptr >  '7'))) {
-          return -1;
-        }
-  
-        if (*chrptr  >= '0' && *chrptr  <= '7') {
-          *chrptr = (char)((*chrptr - '0') + (chrptr[-1] - '0') * 8 + (chrptr[-2] - '0') * 64);
-        }
-      }
-      *str++ = *chrptr;
-    }
-  
-    if (termChar) {
-      return -2;
-    }
-  
-    *str = '\0';
-  
-    return 0;
-  }
-  
-
-  //*****************************************************************************
-  //*****************************************************************************
-  void
-  ParseHTKString(const std::string & rIn, std::string & rOut)
-  {
-    int ret_val;
-
-    // the new string will be at most as long as the original, so we allocate
-    // space
-    char* new_str = new char[rIn.size() + 1];
-
-    char* p_htk_str = new_str;
-
-    strcpy(p_htk_str, rIn.c_str());
-    ret_val = getHTKstr(p_htk_str);
-
-    // call the function
-    if (!ret_val) {
-      rOut = p_htk_str;
-    }
-
-    delete [] new_str;
-
-    if (ret_val) {
-      throw std::runtime_error("Error parsing HTK string");
-    }
-  }
-
-  
-
-  //***************************************************************************
-  //***************************************************************************
-  bool 
-  IsBigEndian()
-  {
-    int a = 1;
-    return (bool) ((char *) &a)[0] != 1;
-  }
-  
-
-  //***************************************************************************
-  //***************************************************************************
-  void 
-  MakeHtkFileName(char* pOutFileName,  const char* inFileName,
-               const char* out_dir, const char* out_ext)
-  {
-    const char* base_name;
-    const char* bname_end = NULL;
-    const char* chrptr;
-  
-    //  if (*inFileName == '*' && *++inFileName == '/') ++inFileName;
-    
-    // we don't do anything if file is stdin/out
-    if (!strcmp(inFileName, "-"))
-    {
-      pOutFileName[0] = '-';
-      pOutFileName[1] = '\0';
-      return;
-    }    
-    
-    base_name = strrchr(inFileName, '/');
-    base_name = base_name != NULL ? base_name + 1 : inFileName;
-    
-    if (out_ext) bname_end = strrchr(base_name, '.');
-    if (!bname_end) bname_end = base_name + strlen(base_name);
-  
-  
-    if ((chrptr = strstr(inFileName, "/./")) != NULL) 
-    {
-      // what is in path after /./ serve as base name
-      base_name = chrptr + 3;
-    }
-    /* else if (*inFileName != '/') 
-    {
-      // if inFileName isn't absolut path, don't forget directory structure
-      base_name = inFileName;
-    }*/
-  
-    *pOutFileName = '\0';
-    if (out_dir) 
-    {
-      if (*out_dir) 
-      {
-        strcat(pOutFileName, out_dir);
-        strcat(pOutFileName, "/");
-      }
-      strncat(pOutFileName, base_name, bname_end-base_name);
-    } 
-    else 
-    {
-      strncat(pOutFileName, inFileName, bname_end-inFileName);
-    }
-  
-    if (out_ext && *out_ext) 
-    {
-      strcat(pOutFileName, ".");
-      strcat(pOutFileName, out_ext);
-    }
-  }
-
-  
-  //****************************************************************************
-  //****************************************************************************
-  bool 
-  CloseEnough(const float f1, const float f2, const float nRounds)
-  {
-    bool ret_val = (_ABS((f1 - f2) / (f2 == 0.0f ? 1.0f : f2))
-        < (nRounds * FLT_EPSILON));
-
-    return ret_val;
-  } 
-
-  
-  //****************************************************************************
-  //****************************************************************************
-  bool 
-  CloseEnough(const double f1, const double f2, const double nRounds)
-  {
-    bool ret_val = (_ABS((f1 - f2) / (f2 == 0.0 ? 1.0 : f2))
-        < (nRounds * DBL_EPSILON));
-
-    return ret_val;
-  } 
-
-
-  //****************************************************************************
-  //****************************************************************************
-  char* 
-  ExpandHtkFilterCmd(const char *command, const char *filename, const char* pFilter)
-  {
-
-    char *out, *outend;
-    const char *chrptr = command;
-    int ndollars = 0;
-    int fnlen = strlen(filename);
-
-    while (*chrptr++) ndollars += (*chrptr ==  *pFilter);
-
-    out = (char*) malloc(strlen(command) - ndollars + ndollars * fnlen + 1);
-
-    outend = out;
-
-    for (chrptr = command; *chrptr; chrptr++) {
-      if (*chrptr ==  *pFilter) {
-        strcpy(outend, filename);
-        outend += fnlen;
-      } else {
-        *outend++ = *chrptr;
-      }
-    }
-    *outend = '\0';
-    return out;
-  }
-
-  //***************************************************************************
-  //***************************************************************************
-  char *
-  StrToUpper(char *str)
-  {
-    char *chptr;
-    for (chptr = str; *chptr; chptr++) {
-      *chptr = (char)toupper(*chptr);
-    }
-    return str;
-  }
-  
-
-  //**************************************************************************** 
-  //**************************************************************************** 
-  std::string&
-  Trim(std::string& rStr)
-  {
-    // WHITE_CHARS is defined in common.h
-    std::string::size_type pos = rStr.find_last_not_of(WHITE_CHARS);
-    if(pos != std::string::npos) 
-    {
-      rStr.erase(pos + 1);
-      pos = rStr.find_first_not_of(WHITE_CHARS);
-      if(pos != std::string::npos) rStr.erase(0, pos);
-    }
-    else 
-      rStr.erase(rStr.begin(), rStr.end());
-
-    return rStr;
-  }
-
-
-} // namespace TNet
-
-//#ifdef CYGWIN
-
-void assertf(const char *c, int i, const char *msg){
-  printf("Assertion \"%s\" failed: file \"%s\", line %d\n", msg?msg:"(null)", c?c:"(null)", i);
-  abort();
-}
-
-
-void assertf_throw(const char *c, int i, const char *msg){
-  char buf[2000];
-  snprintf(buf, 1999, "Assertion \"%s\" failed, throwing exception: file \"%s\", line %d\n", msg?msg:"(null)", c?c:"(null)", i);
-  throw std::runtime_error((std::string)buf);
-}
-//#endif
diff --git a/tnet_io/KaldiLib/Common.h b/tnet_io/KaldiLib/Common.h
deleted file mode 100644
index 9cd9658..0000000
--- a/tnet_io/KaldiLib/Common.h
+++ /dev/null
@@ -1,233 +0,0 @@
-#ifndef TNet_Common_h
-#define TNet_Common_h
-
-#include <cstdlib>
-#include <string.h> // C string stuff like strcpy
-#include <string>
-#include <sstream>
-#include <stdexcept>
-
-/* Alignment of critical dynamic data structure
- *
- * Not all platforms support memalign so we provide a stk_memalign wrapper
- * void *stk_memalign( size_t align, size_t size, void **pp_orig )
- * *pp_orig is the pointer that has to be freed afterwards.
- */
-#ifdef HAVE_POSIX_MEMALIGN
-#  define stk_memalign(align,size,pp_orig) \
-     ( !posix_memalign( pp_orig, align, size ) ? *(pp_orig) : NULL )
-#  ifdef STK_MEMALIGN_MANUAL
-#    undef STK_MEMALIGN_MANUAL
-#  endif
-#elif defined(HAVE_MEMALIGN)
-   /* Some systems have memalign() but no declaration for it */
-   //void * memalign( size_t align, size_t size );
-#  define stk_memalign(align,size,pp_orig) \
-     ( *(pp_orig) = memalign( align, size ) )
-#  ifdef STK_MEMALIGN_MANUAL
-#    undef STK_MEMALIGN_MANUAL
-#  endif
-#else /* We don't have any choice but to align manually */
-#  define stk_memalign(align,size,pp_orig) \
-     (( *(pp_orig) = malloc( size + align - 1 )) ? \
-     (void *)( (((unsigned long)*(pp_orig)) + 15) & ~0xFUL ) : NULL )
-#  define STK_MEMALIGN_MANUAL
-#endif
-
-
-#define swap8(a) { \
-  char t=((char*)&a)[0]; ((char*)&a)[0]=((char*)&a)[7]; ((char*)&a)[7]=t;\
-      t=((char*)&a)[1]; ((char*)&a)[1]=((char*)&a)[6]; ((char*)&a)[6]=t;\
-      t=((char*)&a)[2]; ((char*)&a)[2]=((char*)&a)[5]; ((char*)&a)[5]=t;\
-      t=((char*)&a)[3]; ((char*)&a)[3]=((char*)&a)[4]; ((char*)&a)[4]=t;}
-#define swap4(a) { \
-  char t=((char*)&a)[0]; ((char*)&a)[0]=((char*)&a)[3]; ((char*)&a)[3]=t;\
-      t=((char*)&a)[1]; ((char*)&a)[1]=((char*)&a)[2]; ((char*)&a)[2]=t;}
-#define swap2(a) { \
-  char t=((char*)&a)[0]; ((char*)&a)[0]=((char*)&a)[1]; ((char*)&a)[1]=t;}
-
-
-namespace TNet
-{
-  /** **************************************************************************
-   ** **************************************************************************
-   * @brief Aligns a number to a specified base
-   * @param n Number of type @c _T to align
-   * @return Aligned value of type @c _T
-   */
-  template<size_t _align, typename _T>
-    inline _T 
-    align(const _T n)
-    {
-      const _T x(_align - 1); 
-      return (n + x) & ~(x);
-    }
-
-
-  /** 
-   * @brief Returns true if architecture is big endian
-   */
-  bool 
-  IsBigEndian();
-
-
-  /** 
-   * @brief Returns true if two numbers are close enough to each other
-   * 
-   * @param f1  First operand
-   * @param f2  Second operand
-   * @param nRounds Expected number of operations prior to this comparison
-  */
-  bool 
-  CloseEnough(const float f1, const float f2, const float nRounds);
-  
-
-  /** 
-   * @brief Returns true if two numbers are close enough to each other
-   * 
-   * @param f1  First operand
-   * @param f2  Second operand
-   * @param nRounds Expected number of operations prior to this comparison
-  */
-  bool 
-  CloseEnough(const double f1, const double f2, const double nRounds);
-  
-
-  /** 
-   * @brief Parses a HTK-style string into a C++ std::string readable
-   * 
-   * @param rIn  HTK input string
-   * @param rOut output parsed string
-   */
-  void
-  ParseHTKString(const std::string & rIn, std::string & rOut);
-
-  
-  /** 
-   * @brief Synthesize new file name based on name, path, and extension
-   * 
-   * @param pOutFileName  full ouptut file name
-   * @param pInFileName   file name
-   * @param pOutDir       directory
-   * @param pOutExt       extension
-   */
-  void    
-  MakeHtkFileName(char *pOutFileName, const char* pInFileName, const char *pOutDir, 
-      const char *pOutExt);
-  
-
-  /** 
-   * @brief Removes the leading and trailing white chars
-   *
-   * @param rStr Refference to the string to be processed
-   * @return Refference to the original string
-   *
-   * The white characters are determined by the @c WHITE_CHARS macro defined 
-   * above.
-   */
-  std::string&
-  Trim(std::string& rStr);
-
-
-  char*
-  StrToUpper(char* pStr);
-
-  char* 
-  ExpandHtkFilterCmd(const char *command, const char *filename, const char* pFilter);
-  
-  
-  template <class T>
-  std::string to_string(const T& val)
-  {
-    std::stringstream ss;
-    ss << val;
-    return ss.str();
-  }
-  
-  inline void 
-  ExpectKeyword(std::istream &i_stream, const char *kwd)
-  {
-     std::string token;
-     i_stream >> token;
-     if (token != kwd) {
-       throw std::runtime_error(std::string(kwd) + " expected");
-     }
-  }
-  
-  extern const int MATRIX_IOS_FORMAT_IWORD;
-
-  enum MatrixVectorIostreamControlBits {
-    ACCUMULATE_INPUT = 1,
-//  BINARY_OUTPUT    = 2
-  };
-  
-  class MatrixVectorIostreamControl
-  {
-    public:
-      MatrixVectorIostreamControl(enum MatrixVectorIostreamControlBits bitsToBeSet, bool valueToBeSet)
-      : mBitsToBeSet(bitsToBeSet), mValueToBeSet(valueToBeSet) {}
-      
-      static long Flags(std::ios_base &rIos, enum MatrixVectorIostreamControlBits bits)
-      { return rIos.iword(MATRIX_IOS_FORMAT_IWORD); }
-      
-      long mBitsToBeSet;
-      bool mValueToBeSet;
-            
-      friend std::ostream & operator <<(std::ostream &rOs, const MatrixVectorIostreamControl modifier)
-      {
-        if(modifier.mValueToBeSet) {
-          rOs.iword(MATRIX_IOS_FORMAT_IWORD) |= modifier.mBitsToBeSet;
-        } else {
-          rOs.iword(MATRIX_IOS_FORMAT_IWORD) &= ~modifier.mBitsToBeSet;
-        }
-        return rOs;
-      }
-
-      friend std::istream & operator >>(std::istream &rIs, const MatrixVectorIostreamControl modifier)
-      {
-        if(modifier.mValueToBeSet) {
-          rIs.iword(MATRIX_IOS_FORMAT_IWORD) |= modifier.mBitsToBeSet;
-        } else {
-          rIs.iword(MATRIX_IOS_FORMAT_IWORD) &= ~modifier.mBitsToBeSet;
-        }
-        return rIs;
-      }
-  };
-  
-  
-  
-
-} // namespace TNet
-
-#ifdef __ICC
-#pragma warning (disable: 383) // ICPC remark we don't want.
-#pragma warning (disable: 810) // ICPC remark we don't want.
-#pragma warning (disable: 981) // ICPC remark we don't want.
-#pragma warning (disable: 1418) // ICPC remark we don't want.
-#pragma warning (disable: 444) // ICPC remark we don't want.
-#pragma warning (disable: 869) // ICPC remark we don't want.
-#pragma warning (disable: 1287) // ICPC remark we don't want.
-#pragma warning (disable: 279) // ICPC remark we don't want.
-#pragma warning (disable: 981) // ICPC remark we don't want.
-#endif
-
-//#ifdef CYGWIN
-#if 1
-#undef assert
-#ifndef NDEBUG
-#define assert(e)          ((e) ? (void)0 : assertf(__FILE__, __LINE__, #e))
-#else
-#define assert(e)         ((void)0)
-#endif
-void assertf(const char *c, int i, const char *msg); // Just make it possible to break into assert on gdb-- has some kind of bug on cygwin.
-#else
-#include <cassert>
-#endif
-
-#define assert_throw(e)          ((e) ? (void)0 : assertf_throw(__FILE__, __LINE__, #e))
-void assertf_throw(const char *c, int i, const char *msg); 
-
-#define DAN_STYLE_IO
-
-#endif // ifndef TNet_Common_h
-
diff --git a/tnet_io/KaldiLib/Error.h b/tnet_io/KaldiLib/Error.h
deleted file mode 100644
index 2228dde..0000000
--- a/tnet_io/KaldiLib/Error.h
+++ /dev/null
@@ -1,172 +0,0 @@
-//
-// C++ Interface: %{MODULE}
-//
-// Description: 
-//
-//
-// Author: %{AUTHOR} <%{EMAIL}>, (C) %{YEAR}
-//
-// Copyright: See COPYING file that comes with this distribution
-//
-//
-
-/** @file Error.h
- *  This header defines several types and functions relating to the
- *  handling of exceptions in STK.
- */
- 
-#ifndef TNET_Error_h
-#define TNET_Error_h
-
-#include <iostream>
-#include <stdexcept>
-#include <string>
-#include <sstream>
-
-#include <cstdlib>
-#include <execinfo.h>
-#include <cstdarg>
-#include <cstdio>
-
-// THESE MACROS TERRIBLY CLASH WITH STK!!!!
-// WE MUST USE SAME MACROS!
-//
-//#define Error(msg) _Error_(__func__, __FILE__, __LINE__, msg)
-//#define Warning(msg) _Warning_(__func__, __FILE__, __LINE__, msg)
-//#define TraceLog(msg) _TraceLog_(__func__, __FILE__, __LINE__, msg)
-//
-
-#ifndef Error
-  #define Error(...) _Error_(__func__, __FILE__, __LINE__, __VA_ARGS__)
-#endif
-#ifndef PError
-  #define PError(...) _PError_(__func__, __FILE__, __LINE__, __VA_ARGS__)
-#endif
-#ifndef Warning
-  #define Warning(...) _Warning_(__func__, __FILE__, __LINE__, __VA_ARGS__)
-#endif
-#ifndef TraceLog
-  #define TraceLog(...) _TraceLog_(__func__, __FILE__, __LINE__, __VA_ARGS__)
-#endif
-
-namespace TNet {
-  
-
-
-  /** MyException
-   * Custom exception class, gets the stacktrace
-   */
-  class MyException 
-    : public std::runtime_error
-  {
-    public:
-      explicit MyException(const std::string& what_arg) throw();
-      virtual ~MyException() throw();
-
-      const char* what() const throw() 
-      { return mWhat.c_str(); }
-
-    private:
-      std::string mWhat;
-  };
-
-  /** 
-   * MyException:: implemenatation
-   */
-  inline
-  MyException::
-  MyException(const std::string& what_arg) throw()
-    : std::runtime_error(what_arg)
-  {
-    mWhat = what_arg;
-    mWhat += "\nTHE STACKTRACE INSIDE MyException OBJECT IS:\n";
-    
-    void *array[10];
-    size_t size;
-    char **strings;
-    size_t i;
-
-    size = backtrace (array, 10);
-    strings = backtrace_symbols (array, size);
-    
-    //<< 0th string is the MyException ctor, so ignore and start by 1
-    for (i = 1; i < size; i++) { 
-      mWhat += strings[i];
-      mWhat += "\n";
-    }
-
-    free (strings);
-  }
-
-
-  inline
-  MyException::
-  ~MyException() throw()
-  { } 
-
-
-  /**
-   *  @brief Error throwing function (with backtrace)
-   */
-  inline void 
-  _Error_(const char *func, const char *file, int line, const std::string &msg)
-  {
-     std::stringstream ss;
-     ss << "ERROR (" << func << ':' << file  << ':' << line << ") " << msg;
-     throw MyException(ss.str());
-  }
-  
-  /**
-   *  @brief Throw a formatted error
-   */
-  inline void _PError_(const char *func, const char *file, int line, const char *fmt, ...) {
-      va_list ap;
-      char msg[256];
-      va_start(ap, fmt);
-      vsnprintf(msg, sizeof msg, fmt, ap);
-      va_end(ap);
-      _Error_(func, file, line, msg);
-  }
-
-  /**
-   *  @brief Warning handling function
-   */
-  inline void 
-  _Warning_(const char *func, const char *file, int line, const std::string &msg)
-  {
-	std::cout << "WARNING (" << func << ':' << file  << ':' << line << ") " << msg << std::endl;
-  }
-
-  inline void 
-  _TraceLog_(const char *func, const char *file, int line, const std::string &msg)
-  {
-	std::cout << "INFO (" << func << ':' << file  << ':' << line << ") " << msg << std::endl;
-    std::cout.flush();
-  }
-
-  /**
-   * New kaldi error handling:
-   *
-   * class KaldiErrorMessage is invoked from the KALDI_ERROR macro.
-   * The destructor throws an exception.
-   */
-  class KaldiErrorMessage {
-   public:
-    KaldiErrorMessage(const char *func, const char *file, int line) {
-      this->stream() << "ERROR (" 
-                     << func << "():"
-                     << file << ':' << line << ") ";
-    }
-    inline std::ostream &stream() { return ss; }
-    ~KaldiErrorMessage() { throw MyException(ss.str()); }
-   private:
-    std::ostringstream ss;
-  };
-  #define KALDI_ERR TNet::KaldiErrorMessage(__func__, __FILE__, __LINE__).stream() 
-
-
-
-} // namespace TNet
-
-//#define TNET_Error_h
-#endif
diff --git a/tnet_io/KaldiLib/Features.cc b/tnet_io/KaldiLib/Features.cc
deleted file mode 100644
index 64b63e8..0000000
--- a/tnet_io/KaldiLib/Features.cc
+++ /dev/null
@@ -1,1798 +0,0 @@
-
-//enable feature repository profiling
-#define PROFILING 1
-
-#include <sstream>
-#include <map>
-#include <list>
-#include <cstdio>
-
-#include "Features.h"
-#include "Tokenizer.h"
-#include "StkMatch.h"
-#include "Types.h"
-
-
-
-namespace TNet
-{
-  const char 
-  FeatureRepository::
-  mpParmKindNames[13][16] =
-  {
-    {"WAVEFORM"},
-    {"LPC"},
-    {"LPREFC"},
-    {"LPCEPSTRA"},
-    {"LPDELCEP"},
-    {"IREFC"},
-    {"MFCC"},
-    {"FBANK"},
-    {"MELSPEC"},
-    {"USER"},
-    {"DISCRETE"},
-    {"PLP"},
-    {"ANON"}
-  };
-
-  //***************************************************************************
-  //***************************************************************************
-
-  FileListElem::
-  FileListElem(const std::string & rFileName)
-  {
-    std::string::size_type  pos;
-    
-    mLogical = rFileName;
-    mWeight  = 1.0;
-    
-    // some slash-backslash replacement hack
-    for (size_t i = 0; i < mLogical.size(); i++) {
-      if (mLogical[i] == '\\') {
-        mLogical[i] = '/';
-      }
-    }
-        
-    // read sentence weight definition if any ( physical_file.fea[s,e]{weight} )
-    if ((pos = mLogical.find('{')) != std::string::npos)
-    {
-      std::string       tmp_weight(mLogical.begin() + pos + 1, mLogical.end());
-      std::stringstream tmp_ss(tmp_weight);
-
-      tmp_ss >> mWeight;
-      mLogical.erase(pos);
-    }
-
-    // look for "=" symbol and if found, split it
-    if ((pos = mLogical.find('=')) != std::string::npos)
-    {
-      // copy all from mLogical[pos+1] till the end to mPhysical
-      mPhysical.assign(mLogical.begin() + pos + 1, mLogical.end());
-      // erase all from pos + 1 till the end from mLogical
-      mLogical.erase(pos);
-      // trim the leading and trailing spaces
-      Trim(mPhysical);
-      Trim(mLogical);
-    }
-    else
-    {
-      // trim the leading and trailing spaces
-      Trim(mLogical);
-
-      mPhysical = mLogical;
-    }    
-  }    
-
-
-  //###########################################################################
-  //###########################################################################
-  // FeatureRepository section
-  //###########################################################################
-  //###########################################################################
-  
-  //***************************************************************************
-  //***************************************************************************
-  void 
-  FeatureRepository::
-  ReadCepsNormFile(
-    const char *  pFileName, 
-    char **       pLastFileName, 
-    BaseFloat **      vec_buff,
-    int           sampleKind, 
-    CNFileType    type, 
-    int           coefs)
-  {
-    FILE*   fp;
-    int     i;
-    char    s1[64];
-    char    s2[64];
-    const char*   typeStr = (type == CNF_Mean     ? "MEAN" :
-                    type == CNF_Variance ? "VARIANCE" : "VARSCALE");
-  
-    const char*   typeStr2 = (type == CNF_Mean     ? "CMN" :
-                    type == CNF_Variance ? "CVN" : "VarScale");
-  
-    if (*pLastFileName != NULL && !strcmp(*pLastFileName, pFileName)) {
-      return;
-    }
-    free(*pLastFileName);
-    *pLastFileName=strdup(pFileName);
-    *vec_buff = (BaseFloat*) realloc(*vec_buff, coefs * sizeof(BaseFloat));
-  
-    if (*pLastFileName == NULL || *vec_buff== NULL) 
-      throw std::runtime_error("Insufficient memory");
-    
-    if ((fp = fopen(pFileName, "r")) == NULL)  {
-      throw std::runtime_error(std::string("Cannot open ") + typeStr2 
-          + " pFileName: '" + pFileName + "'");
-    }
-    
-    if ((type != CNF_VarScale
-        && (fscanf(fp, " <%64[^>]> <%64[^>]>", s1, s2) != 2
-          || strcmp(StrToUpper(s1), "CEPSNORM")
-          || ReadParmKind(s2, false) != sampleKind))
-        || fscanf(fp, " <%64[^>]> %d", s1, &i) != 2
-        || strcmp(StrToUpper(s1), typeStr)
-        || i != coefs) 
-    {
-      ParmKind2Str(sampleKind, s2);
-
-      //std::cout << "[[[TADY!!!!]]]" << pFileName << "\n" << std::flush;
-
-      throw std::runtime_error(std::string("")
-            + (type == CNF_VarScale ? "" : "<CEPSNORM> <")
-            + (type == CNF_VarScale ? "" : s2)
-            + (type == CNF_VarScale ? "" : ">")
-            + " <" + typeStr + " ... expected in " + typeStr2
-            + " file " + pFileName);
-    }
-    
-    for (i = 0; i < coefs; i++) {
-      if (fscanf(fp, " "FLOAT_FMT, *vec_buff+i) != 1) {
-        if (fscanf(fp, "%64s", s2) == 1) {
-          throw std::runtime_error(std::string("Decimal number expected but '")
-              + s2 + "' found in " + typeStr2 + " file " + pFileName);
-        } 
-        else if (feof(fp)) {
-          throw std::runtime_error(std::string("Unexpected end of ") 
-              + typeStr2 + " file "+ pFileName);
-        } 
-        else {
-          throw std::runtime_error(std::string("Cannot read ") + typeStr2 
-              + " file " + pFileName);
-        }
-      }
-      
-      if (type == CNF_Variance)      
-        (*vec_buff)[i] = BaseFloat(1 / sqrt((*vec_buff)[i]));
-      else if (type == CNF_VarScale) 
-        (*vec_buff)[i] = BaseFloat(sqrt((*vec_buff)[i]));
-    }
-    
-    if (fscanf(fp, "%64s", s2) == 1) 
-    {
-      throw std::runtime_error(std::string("End of file expected but '") 
-          + s2 + "' found in " + typeStr2 + " file " + pFileName);
-    }
-    
-    fclose(fp);
-  } // ReadCepsNormFile(...)
-  
-
-  //***************************************************************************
-  //***************************************************************************
-  void
-  FeatureRepository::
-  HtkFilter(const char* pFilter, const char* pValue, FeatureRepository& rOut)
-  {
-    std::list<FileListElem>::iterator   it;
-    std::string  str;
-
-    rOut.mSwapFeatures    = mSwapFeatures;
-    rOut.mStartFrameExt   = mStartFrameExt;
-    rOut.mEndFrameExt     = mEndFrameExt;
-    rOut.mTargetKind      = mTargetKind;
-    rOut.mDerivOrder      = mDerivOrder;
-    rOut.mDerivWinLengths = mDerivWinLengths;
-
-    rOut.mpCvgFile        = mpCvgFile;
-    rOut.mpCmnPath        = mpCmnPath;
-    rOut.mpCmnMask        = mpCmnMask;
-    rOut.mpCvnPath        = mpCvnPath;
-    rOut.mpCvnMask        = mpCvnMask;
-
-    rOut.mInputQueue.clear();
-
-    // go through all records and check the mask
-    for (it=mInputQueue.begin(); it!= mInputQueue.end(); ++it) {
-      if (pFilter == NULL
-      ||  (ProcessMask(it->Logical(), pFilter, str) && (str == pValue))) {
-        rOut.mInputQueue.push_back(*it);
-      }
-    }
-
-    // set the queue position to the begining
-    rOut.mInputQueueIterator = mInputQueue.end(); 
-
-    rOut.mCurrentIndexFileName  = "";
-    rOut.mCurrentIndexFileDir   = "";
-    rOut.mCurrentIndexFileExt   = "";
-
-    mStream.close();
-    mStream.clear();
-
-    rOut.mpLastFileName = NULL;
-    rOut.mLastFileName  = "";
-    rOut.mpLastCmnFile  = NULL;
-    rOut.mpLastCvnFile  = NULL;
-    rOut.mpLastCvgFile  = NULL;
-    rOut.mpCmn          = NULL;
-    rOut.mpCvn          = NULL;
-    rOut.mpCvg          = NULL;
-    rOut.mpA            = NULL;
-    rOut.mpB            = NULL;
-
-  }
-
-
-  //***************************************************************************
-  //***************************************************************************
-  void
-  FeatureRepository::
-  HtkSelection(const char* pFilter, std::list< std::string >& rOut)
-  {
-    std::map< std::string, bool> aux_map;
-    std::map< std::string, bool>::iterator map_it;
-    std::list<FileListElem>::iterator   it;
-    std::string  str;
-
-    rOut.clear();
-    
-    if(pFilter != NULL) {
-      // go through all records and check the mask
-      for (it=mInputQueue.begin(); it!= mInputQueue.end(); ++it) {
-        if (ProcessMask(it->Logical(), pFilter, str)) {
-          aux_map[str] = true;
-        }
-      }
-    } else {
-      aux_map[std::string("default speaker")] = true;
-    }
-
-    for (map_it = aux_map.begin(); map_it != aux_map.end(); ++map_it) {
-      rOut.push_back(map_it->first);
-    }
-  }
-
-
-  //***************************************************************************
-  //***************************************************************************
-  int     
-  FeatureRepository::
-  ParmKind2Str(unsigned parmKind, char *pOutString)
-  {
-    // :KLUDGE: Absolutely no idea what this is...
-      if ((parmKind & 0x003F) >= sizeof(mpParmKindNames)/sizeof(mpParmKindNames[0])) 
-      return 0;
-  
-    strcpy(pOutString, mpParmKindNames[parmKind & 0x003F]);
-  
-    if (parmKind & PARAMKIND_E) strcat(pOutString, "_E");
-    if (parmKind & PARAMKIND_N) strcat(pOutString, "_N");
-    if (parmKind & PARAMKIND_D) strcat(pOutString, "_D");
-    if (parmKind & PARAMKIND_A) strcat(pOutString, "_A");
-    if (parmKind & PARAMKIND_C) strcat(pOutString, "_C");
-    if (parmKind & PARAMKIND_Z) strcat(pOutString, "_Z");
-    if (parmKind & PARAMKIND_K) strcat(pOutString, "_K");
-    if (parmKind & PARAMKIND_0) strcat(pOutString, "_0");
-    if (parmKind & PARAMKIND_V) strcat(pOutString, "_V");
-    if (parmKind & PARAMKIND_T) strcat(pOutString, "_T");
-    
-    return 1;
-  }
-
-
-  // //***************************************************************************
-  // //***************************************************************************
-  // void
-  // AddFileListToFeatureRepositories(
-  //   const char* pFileName, 
-  //   const char* pFilter, 
-  //   std::queue<FeatureRepository *> &featureRepositoryList)
-  // {
-  //   IStkStream            l_stream;
-  //   std::string           file_name;
-  //   Tokenizer             file_list(pFileName, ",");
-  //   Tokenizer::iterator   p_file_name;
-
-  //   //:TODO: error if empty featureRepositoryList
-  //   
-  //   for (p_file_name = file_list.begin(); p_file_name != file_list.end(); ++p_file_name)
-  //   {
-  //     // get rid of initial and trailing blanks
-  //     Trim(*p_file_name);
-
-  //     // open file name
-  //     l_stream.open(p_file_name->c_str(), std::ios::in, pFilter);
-  //     
-  //     if (!l_stream.good()) {
-  //       //:TODO:
-  //       // Warning or error ... Why warning? -Lukas
-  //       throw std::runtime_error(std::string("Cannot not open list file ") +
-  //           *p_file_name);
-  //     }
-
-  //     // read all lines and parse them
-  //     for(;;)
-  //     {
-  //       l_stream >> file_name;
-  //       //:TODO: if(l_stream.badl()) Error()
-  //       // Reading after last token set the fail bit
-  //       if(l_stream.fail()) 
-  //         break;
-  //       // we can push_back a std::string as new FileListElem object
-  //       // is created using FileListElem(const std::string&) constructor
-  //       // and logical and physical names are correctly extracted
-  //       featureRepositoryList.front()->mInputQueue.push_back(file_name);
-  //       
-  //       //cycle in the featureRepositoryList
-  //       featureRepositoryList.push(featureRepositoryList.front());
-  //       featureRepositoryList.pop();
-  //     }
-  //     l_stream.close();
-  //   }
-  // } // AddFileList(const std::string & rFileName)
-
-
-  //***************************************************************************
-  //***************************************************************************
-  void
-  FeatureRepository::
-  Init(
-      bool                  swap,
-      int                   extLeft,
-      int                   extRight,
-      int                   targetKind,
-      int                   derivOrder,
-      int*                  pDerivWinLen,
-      const char*           pCmnPath,
-      const char*           pCmnMask,
-      const char*           pCvnPath,
-      const char*           pCvnMask,
-      const char*           pCvgFile)
-  {
-    mSwapFeatures       =   swap;         
-    mStartFrameExt      =   extLeft;      
-    mEndFrameExt        =   extRight;     
-    mTargetKind         =   targetKind;   
-    mDerivOrder         =   derivOrder;   
-    mDerivWinLengths    =   pDerivWinLen; 
-    mpCmnPath           =   pCmnPath;     
-    mpCmnMask           =   pCmnMask;     
-    mpCvnPath           =   pCvnPath;     
-    mpCvnMask           =   pCvnMask;     
-    mpCvgFile           =   pCvgFile;    
-  } // Init()
-
-
-  //***************************************************************************
-  //***************************************************************************
-  void
-  FeatureRepository::
-  AddFile(const std::string & rFileName)
-  {
-    mInputQueue.push_back(rFileName);
-  } // AddFile(const std::string & rFileName)
-
-  
-  //***************************************************************************
-  //***************************************************************************
-  void
-  FeatureRepository::
-  AddFileList(const char* pFileName, const char* pFilter)
-  {
-    IStkStream            l_stream;
-    std::string           file_name;
-    Tokenizer             file_list(pFileName, ",");
-    Tokenizer::iterator   p_file_name;
-
-    for (p_file_name = file_list.begin(); p_file_name != file_list.end(); ++p_file_name)
-    {
-      // get rid of spaces
-      Trim(*p_file_name);
-
-      // open the file
-      l_stream.open(p_file_name->c_str(), std::ios::in, pFilter);
-      
-      if (!l_stream.good())
-      {
-        //:TODO:
-        // Warning or error ... Why warning? -Lukas
-        throw std::runtime_error(std::string("Cannot not open list file ") +
-            *p_file_name);
-      }
-      // read all lines and parse them
-      for(;;)
-      {
-        l_stream >> file_name;
-        //:TODO: if(l_stream.badl()) Error()
-        // Reading after last token set the fail bit
-        if(l_stream.fail()) 
-	  break;
-        // we can push_back a std::string as new FileListElem object
-        // is created using FileListElem(const std::string&) constructor
-        // and logical and physical names are correctly extracted
-        mInputQueue.push_back(file_name);
-      }
-      l_stream.close();
-    }
-  } // AddFileList(const std::string & rFileName)
-
-  
-  //***************************************************************************
-  //***************************************************************************
-  void
-  FeatureRepository::
-  MoveNext()
-  {
-    assert (mInputQueueIterator != mInputQueue.end());
-    mInputQueueIterator++;
-  } // ReadFullMatrix(Matrix<BaseFloat>& rMatrix)
-
-
-  //***************************************************************************
-  //***************************************************************************
-  bool
-  FeatureRepository::
-  ReadFullMatrix(Matrix<BaseFloat>& rMatrix)
-  {
-    // clear the matrix
-    rMatrix.Destroy();
-
-    // extract index file name
-    if (!mCurrentIndexFileDir.empty())
-    {
-      char tmp_name[mCurrentIndexFileDir.length() + 
-        mCurrentIndexFileExt.length() + 
-        mInputQueueIterator->Physical().length()]; 
-      
-      MakeHtkFileName(tmp_name, mInputQueueIterator->Physical().c_str(), 
-          mCurrentIndexFileDir.c_str(), mCurrentIndexFileExt.c_str());
-      
-      mCurrentIndexFileName = tmp_name;
-    }
-    else
-      mCurrentIndexFileName = "";
-
-    //get the 3-letter suffix
-    int pos_last_three_chars = mInputQueueIterator->Physical().size() - 3;
-    if (pos_last_three_chars < 0) pos_last_three_chars = 0;
-    //read the gzipped ascii features
-    if (mInputQueueIterator->Physical().substr(pos_last_three_chars) == ".gz") {
-      return ReadGzipAsciiFeatures(*mInputQueueIterator, rMatrix);
-    }
-     
-    // read the matrix and return the result
-    return ReadHTKFeatures(*mInputQueueIterator, rMatrix);
-  } // ReadFullMatrix(Matrix<BaseFloat>& rMatrix)
-
-
-
-  //***************************************************************************
-  //***************************************************************************
-  bool
-  FeatureRepository::
-  WriteFeatureMatrix(const Matrix<BaseFloat>& rMatrix, const std::string& filename, int targetKind, int samplePeriod)
-  {
-    FILE* fp = fopen(filename.c_str(),"w");
-    if(NULL == fp) { Error(std::string("Cannot create file:") + filename); return false; }
-
-    WriteHTKFeatures(fp, samplePeriod, targetKind, mSwapFeatures, const_cast<Matrix<BaseFloat>&>(rMatrix));
-
-    fclose(fp);
-
-    return true;
-  }
-
-
-  //***************************************************************************
-  //***************************************************************************
-  // private:
-  int 
-  FeatureRepository::
-  ReadHTKHeader()
-  {
-    // TODO 
-    // Change this... We should read from StkStream
-    FILE* fp = mStream.fp();
-    
-    if (!fread(&mHeader.mNSamples,     sizeof(INT_32),  1, fp)) return -1;
-    if (!fread(&mHeader.mSamplePeriod, sizeof(INT_32),  1, fp)) return -1;
-    if (!fread(&mHeader.mSampleSize,   sizeof(INT_16),  1, fp)) return -1;
-    if (!fread(&mHeader.mSampleKind,   sizeof(UINT_16), 1, fp)) return -1;
-
-    if (mSwapFeatures) 
-    {
-      swap4(mHeader.mNSamples);
-      swap4(mHeader.mSamplePeriod);
-      swap2(mHeader.mSampleSize);
-      swap2(mHeader.mSampleKind);
-    }
-  
-    if (mHeader.mSamplePeriod < 0 
-    ||  mHeader.mSamplePeriod > 1000000
-    ||  mHeader.mNSamples     < 0 
-    ||  mHeader.mSampleSize   < 0) 
-    {
-      return -1;
-    }
-  
-    return 0;
-  }
-  
-  
-  //***************************************************************************
-  //***************************************************************************
-  // private:
-  int 
-  FeatureRepository::
-  ReadHTKFeature(
-      BaseFloat*    pIn, 
-      size_t    feaLen, 
-      bool      decompress, 
-      BaseFloat*    pScale, 
-      BaseFloat*    pBias)
-  {
-    FILE*  fp = mStream.fp();
-    
-    size_t i;
-    
-    if (decompress) 
-    {
-      INT_16 s;
-  //    BaseFloat pScale = (xmax - xmin) / (2*32767);
-  //    BaseFloat pBias  = (xmax + xmin) / 2;
-  
-      for (i = 0; i < feaLen; i++) 
-      {
-        if (fread(&s, sizeof(INT_16), 1, fp) != 1) 
-          return -1;
-        
-        if (mSwapFeatures) swap2(s);
-        pIn[i] = ((BaseFloat)s + pBias[i]) / pScale[i];
-      }
-      
-      return 0;
-    }
-  
-#if !DOUBLEPRECISION
-    if (fread(pIn, sizeof(FLOAT_32), feaLen, fp) != feaLen) 
-      return -1;
-    
-    if (mSwapFeatures) 
-      for (i = 0; i < feaLen; i++) 
-        swap4(pIn[i]);
-#else
-    float f;
-  
-    for (i = 0; i < feaLen; i++) 
-    {
-      if (fread(&f, sizeof(FLOAT_32), 1, fp) != 1)
-        return -1;
-      
-      if (mSwapFeatures) 
-        swap4(f);
-        
-      pIn[i] = f;
-    }
-#endif
-    return 0;
-  }  // int ReadHTKFeature
-  
-  
-
-  //***************************************************************************
-  //***************************************************************************
-/*  bool 
-  FeatureRepository::
-  ReadHTKFeatures(const std::string& rFileName, Matrix<BaseFloat>& rFeatureMatrix)
-  {
-    std::string           file_name(rFileName);
-    std::string           cmn_file_name;
-    std::string           cvn_file_name;  
-    
-    int                   ext_left  = mStartFrameExt;
-    int                   ext_right = mEndFrameExt;
-    int                   from_frame;
-    int                   to_frame;
-    int                   tot_frames;
-    int                   trg_vec_size;
-    int                   src_vec_size;
-    int                   src_deriv_order;
-    int                   lo_src_tgz_deriv_order;
-    int                   i;
-    int                   j;
-    int                   k;
-    int                   e;
-    int                   coefs;
-    int                   trg_E;
-    int                   trg_0;
-    int                   trg_N;
-    int                   src_E;
-    int                   src_0;
-    int                   src_N;
-    int                   comp;
-    int                   coef_size;
-    char*                 chptr;
-  
-    
-   
-    // read frame range definition if any ( physical_file.fea[s,e] )
-    if ((chptr = strrchr(file_name.c_str(), '[')) == NULL ||
-        ((i=0), sscanf(chptr, "[%d,%d]%n", &from_frame, &to_frame, &i), 
-         chptr[i] != '\0')) 
-    {
-      chptr = NULL;
-    }
-    
-    if (chptr != NULL)                                
-      *chptr = '\0';
-  
-  // Experimental changes...
-  // if ((strcmp(file_name.c_str(), "-"))
-  // &&  (mpLastFileName != NULL) 
-  // &&  (!strcmp(mpLastFileName, file_name.c_str()))) 
-  //   {
-  //     mHeader = mLastHeader;
-  //   } 
-  //   else 
-  //   {
-  //     if (mpLastFileName) 
-  //     {
-  //       //if (mpFp != stdin) 
-  //       //  fclose(mpFp);
-  //       mStream.close();
-  //       
-  //       free(mpLastFileName);
-  //       mpLastFileName = NULL;
-  //     }
-
-    if ((file_name != "-" )
-    &&  (!mLastFileName.empty()) 
-    &&  (mLastFileName == file_name)) 
-    {
-      mHeader = mLastHeader;
-    } 
-    else 
-    {
-      if (!mLastFileName.empty()) 
-      {
-        mStream.close();
-        mLastFileName = "";
-      }
-      
-      
-      // open the feature file
-      mStream.open(file_name.c_str(), ios::binary);
-      if (!mStream.good())
-      {
-        Error("Cannot open feature file: '%s'", file_name.c_str());
-      }
-      
-      
-      if (ReadHTKHeader()) 
-        Error("Invalid HTK header in feature file: '%s'", file_name.c_str());
-      
-      if (mHeader.mSampleKind & PARAMKIND_C) 
-      {
-        // File is in compressed form, scale and pBias vectors
-        // are appended after HTK header.
-  
-        int coefs = mHeader.mSampleSize/sizeof(INT_16);
-        mpA = (BaseFloat*) realloc(mpA, coefs * sizeof(BaseFloat));
-        mpB = (BaseFloat*) realloc(mpB, coefs * sizeof(BaseFloat));
-        if (mpA == NULL || mpB == NULL) Error("Insufficient memory");
-  
-        e  = ReadHTKFeature(mpA, coefs, 0, 0, 0);
-        e |= ReadHTKFeature(mpB, coefs, 0, 0, 0);
-        
-        if (e) 
-          Error("Cannot read feature file: '%s'", file_name.c_str());
-        
-        mHeader.mNSamples -= 2 * sizeof(FLOAT_32) / sizeof(INT_16);
-      }
-      
-      // remember current settings
-      mLastFileName = file_name;
-      mLastHeader   = mHeader;
-    }
-    
-    if (chptr != NULL) 
-      *chptr = '[';
-  
-    if (chptr == NULL) 
-    { // Range [s,e] was not specified
-      from_frame = 0;
-      to_frame   = mHeader.mNSamples-1;
-    }
-    
-    src_deriv_order = PARAMKIND_T & mHeader.mSampleKind ? 3 :
-                      PARAMKIND_A & mHeader.mSampleKind ? 2 :
-                      PARAMKIND_D & mHeader.mSampleKind ? 1 : 0;
-    src_E =  (PARAMKIND_E & mHeader.mSampleKind) != 0;
-    src_0 =  (PARAMKIND_0 & mHeader.mSampleKind) != 0;
-    src_N = ((PARAMKIND_N & mHeader.mSampleKind) != 0) * (src_E + src_0);
-    comp =    PARAMKIND_C & mHeader.mSampleKind;
-    
-    mHeader.mSampleKind &= ~PARAMKIND_C;
-  
-    if (mTargetKind == PARAMKIND_ANON) 
-    {
-      mTargetKind = mHeader.mSampleKind;
-    } 
-    else if ((mTargetKind & 077) == PARAMKIND_ANON) 
-    {
-      mTargetKind &= ~077;
-      mTargetKind |= mHeader.mSampleKind & 077;
-    }
-    
-    trg_E = (PARAMKIND_E & mTargetKind) != 0;
-    trg_0 = (PARAMKIND_0 & mTargetKind) != 0;
-    trg_N =((PARAMKIND_N & mTargetKind) != 0) * (trg_E + trg_0);
-  
-    coef_size     = comp ? sizeof(INT_16) : sizeof(FLOAT_32);
-    coefs         = (mHeader.mSampleSize/coef_size + src_N) / 
-                    (src_deriv_order+1) - src_E - src_0;
-    src_vec_size  = (coefs + src_E + src_0) * (src_deriv_order+1) - src_N;
-  
-    //Is coefs dividable by 1 + number of derivatives specified in header
-    if (src_vec_size * coef_size != mHeader.mSampleSize) 
-    {
-      Error("Invalid HTK header in feature file: '%s'. "
-            "mSampleSize do not match with parmKind", file_name.c_str());
-    }
-    
-    if (mDerivOrder < 0) 
-      mDerivOrder = src_deriv_order;
-  
-  
-    if ((!src_E && trg_E) || (!src_0 && trg_0) || (src_N && !trg_N) ||
-        (trg_N && !trg_E && !trg_0) || (trg_N && !mDerivOrder) ||
-        (src_N && !src_deriv_order && mDerivOrder) ||
-        ((mHeader.mSampleKind & 077) != (mTargetKind & 077) &&
-         (mHeader.mSampleKind & 077) != PARAMKIND_ANON)) 
-    {
-      char srcParmKind[64];
-      char trgParmKind[64];
-      
-      ParmKind2Str(mHeader.mSampleKind, srcParmKind);
-      ParmKind2Str(mTargetKind,       trgParmKind);
-      Error("Cannot convert %s to %s", srcParmKind, trgParmKind);
-    }
-  
-    lo_src_tgz_deriv_order = LOWER_OF(src_deriv_order, mDerivOrder);
-    trg_vec_size  = (coefs + trg_E + trg_0) * (mDerivOrder+1) - trg_N;
-    
-    i =  LOWER_OF(from_frame, mStartFrameExt);
-    from_frame  -= i;
-    ext_left     -= i;
-  
-    i =  LOWER_OF(mHeader.mNSamples-to_frame-1, mEndFrameExt);
-    to_frame    += i;
-    ext_right    -= i;
-  
-    if (from_frame > to_frame || from_frame >= mHeader.mNSamples || to_frame< 0)
-      Error("Invalid frame range for feature file: '%s'", file_name.c_str());
-    
-    tot_frames = to_frame - from_frame + 1 + ext_left + ext_right;
-    
-    // initialize matrix 
-    rFeatureMatrix.Init(tot_frames, trg_vec_size);
-    
-    // fill the matrix with features
-    for (i = 0; i <= to_frame - from_frame; i++) 
-    {
-      BaseFloat* A      = mpA;
-      BaseFloat* B      = mpB;
-      BaseFloat* mxPtr  = rFeatureMatrix[i+ext_left];
-      
-      // seek to the desired position
-      fseek(mStream.fp(), 
-          sizeof(HtkHeader) + (comp ? src_vec_size * 2 * sizeof(FLOAT_32) : 0)
-          + (from_frame + i) * src_vec_size * coef_size, 
-          SEEK_SET);
-  
-      e = ReadHTKFeature(mxPtr, coefs, comp, A, B);
-      
-      mxPtr += coefs; 
-      A     += coefs; 
-      B     += coefs;
-        
-      if (src_0 && !src_N) e |= ReadHTKFeature(mxPtr, 1, comp, A++, B++);
-      if (trg_0 && !trg_N) mxPtr++;
-      if (src_E && !src_N) e |= ReadHTKFeature(mxPtr, 1, comp, A++, B++);
-      if (trg_E && !trg_N) mxPtr++;
-  
-      for (j = 0; j < lo_src_tgz_deriv_order; j++) 
-      {
-        e |= ReadHTKFeature(mxPtr, coefs, comp, A, B);
-        mxPtr += coefs; 
-        A     += coefs; 
-        B     += coefs;
-        
-        if (src_0) e |= ReadHTKFeature(mxPtr, 1, comp, A++, B++);
-        if (trg_0) mxPtr++;
-        if (src_E) e |= ReadHTKFeature(mxPtr, 1, comp, A++, B++);
-        if (trg_E) mxPtr++;
-      }
-      
-      if (e) 
-        Error("Cannot read feature file: '%s' frame %d/%d", file_name.c_str(),
-            i, to_frame - from_frame + 1);
-    }
-  
-    // From now, coefs includes also trg_0 + trg_E !
-    coefs += trg_0 + trg_E; 
-    
-    // If extension of the matrix to the left or to the right is required,
-    // perform it here
-    for (i = 0; i < ext_left; i++) 
-    {
-      memcpy(rFeatureMatrix[i],
-             rFeatureMatrix[ext_left],
-             (coefs * (1+lo_src_tgz_deriv_order) - trg_N) * sizeof(BaseFloat));
-    }
-    
-    for (i = tot_frames - ext_right; i < tot_frames; i++) 
-    {
-      memcpy(rFeatureMatrix[i],
-             rFeatureMatrix[tot_frames - ext_right - 1],
-             (coefs * (1+lo_src_tgz_deriv_order) - trg_N) * sizeof(BaseFloat));
-    }
-
-    // Sentence cepstral mean normalization
-    if( (mpCmnPath == NULL)
-    && !(PARAMKIND_Z & mHeader.mSampleKind) 
-    &&  (PARAMKIND_Z & mTargetKind)) 
-    {
-      // for each coefficient
-      for(j=0; j < coefs; j++) 
-      {          
-        BaseFloat norm = 0.0;
-        for(i=0; i < tot_frames; i++)      // for each frame
-        {
-          norm += rFeatureMatrix[i][j - trg_N];
-          //norm += fea_mx[i*trg_vec_size - trg_N + j];
-        }
-        
-        norm /= tot_frames;
-  
-        for(i=0; i < tot_frames; i++)      // for each frame
-          rFeatureMatrix[i][j - trg_N] -= norm;
-          //fea_mx[i*trg_vec_size - trg_N + j] -= norm;
-      }
-    }
-    
-    // Compute missing derivatives
-    for (; src_deriv_order < mDerivOrder; src_deriv_order++) 
-    { 
-      int winLen = mDerivWinLengths[src_deriv_order];
-      BaseFloat norm = 0.0;
-      
-      for (k = 1; k <= winLen; k++) 
-      {
-        norm += 2 * k * k;
-      }
-      
-      // for each frame
-      for (i=0; i < tot_frames; i++) 
-      {        
-        // for each coefficient
-        for (j=0; j < coefs; j++) 
-        {          
-          //BaseFloat* src = fea_mx + i*trg_vec_size + src_deriv_order*coefs - trg_N + j;
-          BaseFloat* src = &rFeatureMatrix[i][src_deriv_order*coefs - trg_N + j];
-          
-          *(src + coefs) = 0.0;
-          
-          if (i < winLen || i >= tot_frames-winLen) 
-          { // boundaries need special treatment
-            for (k = 1; k <= winLen; k++) 
-            {  
-              *(src+coefs) += k*(src[ LOWER_OF(tot_frames-1-i,k)*rFeatureMatrix.Stride()]
-                                -src[-LOWER_OF(i,             k)*rFeatureMatrix.Stride()]);
-            }
-          } 
-          else 
-          { // otherwise use more efficient code
-            for (k = 1; k <= winLen; k++) 
-            {  
-              *(src+coefs) += k*(src[ k * rFeatureMatrix.Stride()]
-                                -src[-k * rFeatureMatrix.Stride()]);
-            }
-          }
-          *(src + coefs) /= norm;
-        }
-      }
-    }
-    
-    mHeader.mNSamples    = tot_frames;
-    mHeader.mSampleSize  = trg_vec_size * sizeof(FLOAT_32);
-    mHeader.mSampleKind  = mTargetKind & ~(PARAMKIND_D | PARAMKIND_A | PARAMKIND_T);
-  
-
-    ////////////////////////////////////////////////////////////////////////////
-    /////////////// Cepstral mean and variance normalization ///////////////////
-    ////////////////////////////////////////////////////////////////////////////
-    //.........................................................................
-    if (mpCmnPath != NULL
-    &&  mpCmnMask != NULL) 
-    {
-      // retrieve file name
-      ProcessMask(file_name, mpCmnMask, cmn_file_name);
-      // add the path correctly
-      cmn_file_name.insert(0, "/");
-      cmn_file_name.insert(0, mpCmnPath);
-
-      // read the file
-      ReadCepsNormFile(cmn_file_name.c_str(), &mpLastCmnFile, &mpCmn,
-          mHeader.mSampleKind & ~PARAMKIND_Z, CNF_Mean, coefs);
-                      
-      // recompute feature values
-      for (i=0; i < tot_frames; i++) 
-      {
-        for (j=trg_N; j < coefs; j++) 
-        {
-          rFeatureMatrix[i][j - trg_N] -= mpCmn[j];
-        }
-      }
-    }
-  
-    mHeader.mSampleKind |= mDerivOrder==3 ? PARAMKIND_D | PARAMKIND_A | PARAMKIND_T :
-                           mDerivOrder==2 ? PARAMKIND_D | PARAMKIND_A :
-                           mDerivOrder==1 ? PARAMKIND_D : 0;
-  
-    //.........................................................................
-    if (mpCvnPath != NULL
-    &&  mpCvnMask != NULL) 
-    {
-      // retrieve file name
-      ProcessMask(file_name, mpCvnMask, cvn_file_name);
-      // add the path correctly
-      cvn_file_name.insert(0, "/");
-      cvn_file_name.insert(0, mpCvnPath);
-
-      // read the file
-      ReadCepsNormFile(cvn_file_name.c_str(), &mpLastCvnFile, &mpCvn,
-          mHeader.mSampleKind, CNF_Variance, trg_vec_size);
-                      
-      // recompute feature values
-      for (i=0; i < tot_frames; i++) 
-      {
-        for (j=trg_N; j < trg_vec_size; j++) 
-        {
-          rFeatureMatrix[i][j - trg_N] *= mpCvn[j];
-        }
-      }
-    }
-    
-    //.........................................................................
-    // process the global covariance file
-    if (mpCvgFile != NULL) 
-    {
-      ReadCepsNormFile(mpCvgFile, &mpLastCvgFile, &mpCvg,
-                      -1, CNF_VarScale, trg_vec_size);
-                      
-      // recompute feature values
-      for (i=0; i < tot_frames; i++) 
-      {
-        for (j=trg_N; j < trg_vec_size; j++) 
-        {
-          rFeatureMatrix[i][j - trg_N] *= mpCvg[j];
-        }
-      }
-    }
-    
-    return true;
-  }
-*/
-
-  //***************************************************************************
-  //***************************************************************************
-
-
-
-
-  
-  //***************************************************************************
-  //***************************************************************************
-  bool 
-  FeatureRepository::
-  ReadHTKFeatures(const FileListElem&    rFileNameRecord, 
-                        Matrix<BaseFloat>&        rFeatureMatrix)
-  {
-    std::string           file_name(rFileNameRecord.Physical());
-    std::string           cmn_file_name;
-    std::string           cvn_file_name;  
-    
-    int                   ext_left  = mStartFrameExt;
-    int                   ext_right = mEndFrameExt;
-    int                   from_frame;
-    int                   to_frame;
-    int                   tot_frames;
-    int                   trg_vec_size;
-    int                   src_vec_size;
-    int                   src_deriv_order;
-    int                   lo_src_tgz_deriv_order;
-    int                   i;
-    int                   j;
-    int                   k;
-    int                   e;
-    int                   coefs;
-    int                   trg_E;
-    int                   trg_0;
-    int                   trg_N;
-    int                   src_E;
-    int                   src_0;
-    int                   src_N;
-    int                   comp;
-    int                   coef_size;
-    char*                 chptr;
-  
-
-  TIMER_START(mTim);
-   
-    // read frame range definition if any ( physical_file.fea[s,e] )
-    if ((chptr = strrchr((char*)file_name.c_str(), '[')) == NULL ||
-        ((i=0), sscanf(chptr, "[%d,%d]%n", &from_frame, &to_frame, &i), 
-         chptr[i] != '\0')) 
-    {
-      chptr = NULL;
-    }
-    
-    if (chptr != NULL)                                
-      *chptr = '\0';
-  
-
-    if ((file_name != "-" )
-    &&  (!mLastFileName.empty()) 
-    &&  (mLastFileName == file_name)) 
-    {
-      mHeader = mLastHeader;
-    } 
-    else 
-    {
-      if (!mLastFileName.empty()) 
-      {
-        mStream.close();
-        mLastFileName = "";
-      }
-      
-      
-      // open the feature file
-      mStream.open(file_name.c_str(), std::ios::binary);
-      if (!mStream.good())
-      {
-        throw std::runtime_error(std::string("Cannot open feature file: '") 
-            + file_name.c_str() + "'");
-      }
-      
-      
-      if (ReadHTKHeader())  {
-        throw std::runtime_error(std::string("Invalid HTK header in feature file: '") 
-            + file_name.c_str() + "'");
-      }
-      
-      if (mHeader.mSampleKind & PARAMKIND_C) 
-      {
-        // File is in compressed form, scale and pBias vectors
-        // are appended after HTK header.
-	    coefs = mHeader.mSampleSize/sizeof(INT_16);
-
-        mpA = (BaseFloat*) realloc(mpA, coefs * sizeof(BaseFloat));
-        mpB = (BaseFloat*) realloc(mpB, coefs * sizeof(BaseFloat));
-
-        if (mpA == NULL || mpB == NULL) {
-          throw std::runtime_error("Insufficient memory");
-        }
-  
-        e  = ReadHTKFeature(mpA, coefs, 0, 0, 0);
-        e |= ReadHTKFeature(mpB, coefs, 0, 0, 0);
-        
-        if (e) {
-          throw std::runtime_error(std::string("Cannot read feature file: '") 
-              + file_name.c_str() + "'");
-        }
-        
-        mHeader.mNSamples -= 2 * sizeof(FLOAT_32) / sizeof(INT_16);
-      }
-      
-      // remember current settings
-      mLastFileName = file_name;
-      mLastHeader   = mHeader;
-    }
-    
-    if (chptr != NULL) {
-      *chptr = '[';
-    }
-  
-    if (chptr == NULL) { 
-      // Range [s,e] was not specified
-      from_frame = 0;
-      to_frame   = mHeader.mNSamples-1;
-    }
-    
-    src_deriv_order = PARAMKIND_T & mHeader.mSampleKind ? 3 :
-                      PARAMKIND_A & mHeader.mSampleKind ? 2 :
-                      PARAMKIND_D & mHeader.mSampleKind ? 1 : 0;
-    src_E =  (PARAMKIND_E & mHeader.mSampleKind) != 0;
-    src_0 =  (PARAMKIND_0 & mHeader.mSampleKind) != 0;
-    src_N = ((PARAMKIND_N & mHeader.mSampleKind) != 0) * (src_E + src_0);
-    comp =    PARAMKIND_C & mHeader.mSampleKind;
-    
-    mHeader.mSampleKind &= ~PARAMKIND_C;
-  
-    if (mTargetKind == PARAMKIND_ANON) 
-    {
-      mTargetKind = mHeader.mSampleKind;
-    } 
-    else if ((mTargetKind & 077) == PARAMKIND_ANON) 
-    {
-      mTargetKind &= ~077;
-      mTargetKind |= mHeader.mSampleKind & 077;
-    }
-    
-    trg_E = (PARAMKIND_E & mTargetKind) != 0;
-    trg_0 = (PARAMKIND_0 & mTargetKind) != 0;
-    trg_N =((PARAMKIND_N & mTargetKind) != 0) * (trg_E + trg_0);
-  
-    coef_size     = comp ? sizeof(INT_16) : sizeof(FLOAT_32);
-    coefs         = (mHeader.mSampleSize/coef_size + src_N) / 
-                    (src_deriv_order+1) - src_E - src_0;
-    src_vec_size  = (coefs + src_E + src_0) * (src_deriv_order+1) - src_N;
-  
-    //Is coefs dividable by 1 + number of derivatives specified in header
-    if (src_vec_size * coef_size != mHeader.mSampleSize) 
-    {
-      throw std::runtime_error(std::string("Invalid HTK header in feature file: '") 
-            + file_name + "' mSampleSize do not match with parmKind");
-    }
-    
-    if (mDerivOrder < 0) 
-      mDerivOrder = src_deriv_order;
-  
-  
-    if ((!src_E && trg_E) || (!src_0 && trg_0) || (src_N && !trg_N) ||
-        (trg_N && !trg_E && !trg_0) || (trg_N && !mDerivOrder) ||
-        (src_N && !src_deriv_order && mDerivOrder) ||
-        ((mHeader.mSampleKind & 077) != (mTargetKind & 077) &&
-         (mHeader.mSampleKind & 077) != PARAMKIND_ANON)) 
-    {
-      char srcParmKind[64];
-      char trgParmKind[64];
-      memset(srcParmKind,0,64);
-      memset(trgParmKind,0,64);
-      
-      ParmKind2Str(mHeader.mSampleKind, srcParmKind);
-      ParmKind2Str(mTargetKind,       trgParmKind);
-      throw std::runtime_error(std::string("Cannot convert ") + srcParmKind 
-          + " to " + trgParmKind);
-    }
-  
-    lo_src_tgz_deriv_order = std::min(src_deriv_order, mDerivOrder);
-    trg_vec_size  = (coefs + trg_E + trg_0) * (mDerivOrder+1) - trg_N;
-    
-    i =  std::min(from_frame, mStartFrameExt);
-    from_frame  -= i;
-    ext_left     -= i;
-  
-    i =  std::min(mHeader.mNSamples-to_frame-1, mEndFrameExt);
-    to_frame    += i;
-    ext_right    -= i;
-  
-    if (from_frame > to_frame || from_frame >= mHeader.mNSamples || to_frame< 0)
-      throw std::runtime_error(std::string("Invalid frame range for feature file: '")
-            + file_name.c_str() + "'");
-    
-    tot_frames = to_frame - from_frame + 1 + ext_left + ext_right;
-   
-    
-   TIMER_END(mTim,mTimeOpen);
-
-
-    // initialize matrix 
-    rFeatureMatrix.Init(tot_frames, trg_vec_size, false);
-    
-    // fill the matrix with features
-    for (i = 0; i <= to_frame - from_frame; i++) 
-    {
-      BaseFloat* A      = mpA;
-      BaseFloat* B      = mpB;
-      BaseFloat* mxPtr  = rFeatureMatrix.pRowData(i+ext_left);
-
-    TIMER_START(mTim);      
-      // seek to the desired position
-      fseek(mStream.fp(), 
-          sizeof(HtkHeader) + (comp ? src_vec_size * 2 * sizeof(FLOAT_32) : 0)
-          + (from_frame + i) * src_vec_size * coef_size, 
-          SEEK_SET);
-    TIMER_END(mTim,mTimeSeek);
- 
-    TIMER_START(mTim);
-      // read 
-      e = ReadHTKFeature(mxPtr, coefs, comp, A, B);
-    TIMER_END(mTim,mTimeRead);
-      
-      mxPtr += coefs; 
-      A     += coefs; 
-      B     += coefs;
-        
-      if (src_0 && !src_N) e |= ReadHTKFeature(mxPtr, 1, comp, A++, B++);
-      if (trg_0 && !trg_N) mxPtr++;
-      if (src_E && !src_N) e |= ReadHTKFeature(mxPtr, 1, comp, A++, B++);
-      if (trg_E && !trg_N) mxPtr++;
-  
-      for (j = 0; j < lo_src_tgz_deriv_order; j++) 
-      {
-        e |= ReadHTKFeature(mxPtr, coefs, comp, A, B);
-        mxPtr += coefs; 
-        A     += coefs; 
-        B     += coefs;
-        
-        if (src_0) e |= ReadHTKFeature(mxPtr, 1, comp, A++, B++);
-        if (trg_0) mxPtr++;
-        if (src_E) e |= ReadHTKFeature(mxPtr, 1, comp, A++, B++);
-        if (trg_E) mxPtr++;
-      }
-
-      if (e) {
-        std::cout << mHeader.mNSamples << "\n";
-        std::cout << 2 * sizeof(FLOAT_32) / sizeof(INT_16) << "\n";
-        std::cout << "from" << from_frame << "to" << to_frame << "i" << i << "\n";
-
-        std::ostringstream s;
-        s << i << "/" << to_frame - from_frame + 1, s.str();
-        throw std::runtime_error(std::string("Cannot read feature file: '")
-              + file_name + "' frame " + s.str());
-      }
-    }
-  
-    // From now, coefs includes also trg_0 + trg_E !
-    coefs += trg_0 + trg_E; 
-    
-    // If extension of the matrix to the left or to the right is required,
-    // perform it here
-    for (i = 0; i < ext_left; i++) 
-    {
-      memcpy(rFeatureMatrix.pRowData(i),
-             rFeatureMatrix.pRowData(ext_left),
-             (coefs * (1+lo_src_tgz_deriv_order) - trg_N) * sizeof(BaseFloat));
-    }
-    
-    for (i = tot_frames - ext_right; i < tot_frames; i++) 
-    {
-      memcpy(rFeatureMatrix.pRowData(i),
-             rFeatureMatrix.pRowData(tot_frames - ext_right - 1),
-             (coefs * (1+lo_src_tgz_deriv_order) - trg_N) * sizeof(BaseFloat));
-    }
-
-    // Sentence cepstral mean normalization
-    if( (mpCmnPath == NULL)
-    && !(PARAMKIND_Z & mHeader.mSampleKind) 
-    &&  (PARAMKIND_Z & mTargetKind)) 
-    {
-      // for each coefficient
-      for(j=0; j < coefs; j++) 
-      {          
-        BaseFloat norm = 0.0;
-        for(i=0; i < tot_frames; i++)      // for each frame
-        {
-          norm += rFeatureMatrix[i][j - trg_N];
-          //norm += fea_mx[i*trg_vec_size - trg_N + j];
-        }
-        
-        norm /= tot_frames;
-  
-        for(i=0; i < tot_frames; i++)      // for each frame
-          rFeatureMatrix[i][j - trg_N] -= norm;
-          //fea_mx[i*trg_vec_size - trg_N + j] -= norm;
-      }
-    }
-    
-    // Compute missing derivatives
-    for (; src_deriv_order < mDerivOrder; src_deriv_order++) 
-    { 
-      int winLen = mDerivWinLengths[src_deriv_order];
-      BaseFloat norm = 0.0;
-      
-      for (k = 1; k <= winLen; k++) 
-      {
-        norm += 2 * k * k;
-      }
-      
-      // for each frame
-      for (i=0; i < tot_frames; i++) 
-      {        
-        // for each coefficient
-        for (j=0; j < coefs; j++) 
-        {          
-          //BaseFloat* src = fea_mx + i*trg_vec_size + src_deriv_order*coefs - trg_N + j;
-          BaseFloat* src = &rFeatureMatrix[i][src_deriv_order*coefs - trg_N + j];
-          
-          *(src + coefs) = 0.0;
-          
-          if (i < winLen || i >= tot_frames-winLen) 
-          { // boundaries need special treatment
-            for (k = 1; k <= winLen; k++) 
-            {  
-              *(src+coefs) += k*(src[ std::min(tot_frames-1-i,k)*rFeatureMatrix.Stride()]
-                                -src[-std::min(i,             k)*rFeatureMatrix.Stride()]);
-            }
-          } 
-          else 
-          { // otherwise use more efficient code
-            for (k = 1; k <= winLen; k++) 
-            {  
-              *(src+coefs) += k*(src[ k * rFeatureMatrix.Stride()]
-                                -src[-k * rFeatureMatrix.Stride()]);
-            }
-          }
-          *(src + coefs) /= norm;
-        }
-      }
-    }
-    
-    mHeader.mNSamples    = tot_frames;
-    mHeader.mSampleSize  = trg_vec_size * sizeof(FLOAT_32);
-    mHeader.mSampleKind  = mTargetKind & ~(PARAMKIND_D | PARAMKIND_A | PARAMKIND_T);
-  
-
-   TIMER_START(mTim);
-    ////////////////////////////////////////////////////////////////////////////
-    /////////////// Cepstral mean and variance normalization ///////////////////
-    ////////////////////////////////////////////////////////////////////////////
-    //.........................................................................
-    if (mpCmnPath != NULL
-    &&  mpCmnMask != NULL) 
-    {
-      // retrieve file name
-      ProcessMask(rFileNameRecord.Logical(), mpCmnMask, cmn_file_name);
-      // add the path correctly
-
-      if(cmn_file_name == "") {
-        throw std::runtime_error("CMN Matching failed");
-      }
-
-      cmn_file_name.insert(0, "/");
-      cmn_file_name.insert(0, mpCmnPath);
-
-      // read the file
-      ReadCepsNormFile(cmn_file_name.c_str(), &mpLastCmnFile, &mpCmn,
-          mHeader.mSampleKind & ~PARAMKIND_Z, CNF_Mean, coefs);
-                      
-      // recompute feature values
-      for (i=0; i < tot_frames; i++) 
-      {
-        for (j=trg_N; j < coefs; j++) 
-        {
-          rFeatureMatrix[i][j - trg_N] -= mpCmn[j];
-        }
-      }
-    }
-  
-    mHeader.mSampleKind |= mDerivOrder==3 ? PARAMKIND_D | PARAMKIND_A | PARAMKIND_T :
-                           mDerivOrder==2 ? PARAMKIND_D | PARAMKIND_A :
-                           mDerivOrder==1 ? PARAMKIND_D : 0;
-  
-    //.........................................................................
-    if (mpCvnPath != NULL
-    &&  mpCvnMask != NULL) 
-    {
-      // retrieve file name
-      ProcessMask(rFileNameRecord.Logical(), mpCvnMask, cvn_file_name);
-      // add the path correctly
-      cvn_file_name.insert(0, "/");
-      cvn_file_name.insert(0, mpCvnPath);
-
-      // read the file
-      ReadCepsNormFile(cvn_file_name.c_str(), &mpLastCvnFile, &mpCvn,
-          mHeader.mSampleKind, CNF_Variance, trg_vec_size);
-                      
-      // recompute feature values
-      for (i=0; i < tot_frames; i++) 
-      {
-        for (j=trg_N; j < trg_vec_size; j++) 
-        {
-          rFeatureMatrix[i][j - trg_N] *= mpCvn[j];
-        }
-      }
-    }
-    
-    //.........................................................................
-    // process the global covariance file
-    if (mpCvgFile != NULL) 
-    {
-      ReadCepsNormFile(mpCvgFile, &mpLastCvgFile, &mpCvg,
-                      -1, CNF_VarScale, trg_vec_size);
-                      
-      // recompute feature values
-      for (i=0; i < tot_frames; i++) 
-      {
-        for (j=trg_N; j < trg_vec_size; j++) 
-        {
-          rFeatureMatrix[i][j - trg_N] *= mpCvg[j];
-        }
-      }
-    }
-
-  TIMER_END(mTim,mTimeNormalize);
-    
-    return true;
-  }
-
-
-  //***************************************************************************
-  //***************************************************************************
-  int 
-  FeatureRepository::
-  ReadParmKind(const char *str, bool checkBrackets)
-  {
-    unsigned int  i;
-    int           parmKind =0;
-    int           slen     = strlen(str);
-  
-    if (checkBrackets) 
-    {
-      if (str[0] != '<' || str[slen-1] != '>')  return -1;
-      str++; slen -= 2;
-    }
-    
-    for (; slen >= 0 && str[slen-2] == '_'; slen -= 2) 
-    {
-      parmKind |= str[slen-1] == 'E' ? PARAMKIND_E :
-                  str[slen-1] == 'N' ? PARAMKIND_N :
-                  str[slen-1] == 'D' ? PARAMKIND_D :
-                  str[slen-1] == 'A' ? PARAMKIND_A :
-                  str[slen-1] == 'C' ? PARAMKIND_C :
-                  str[slen-1] == 'Z' ? PARAMKIND_Z :
-                  str[slen-1] == 'K' ? PARAMKIND_K :
-                  str[slen-1] == '0' ? PARAMKIND_0 :
-                  str[slen-1] == 'V' ? PARAMKIND_V :
-                  str[slen-1] == 'T' ? PARAMKIND_T : -1;
-  
-      if (parmKind == -1) return -1;
-    }
-    
-    for (i = 0; i < sizeof(mpParmKindNames) / sizeof(char*); i++) 
-    {
-      if (!strncmp(str, mpParmKindNames[i], slen))
-        return parmKind | i;
-    }
-    return -1;
-  }
-
-
-
-
-  //***************************************************************************
-  //***************************************************************************
-  int
-  FeatureRepository:: 
-  WriteHTKHeader (FILE * pOutFp, HtkHeader header, bool swap)
-  {
-    int cc;
-  
-    if (swap) {
-      swap4(header.mNSamples);
-      swap4(header.mSamplePeriod);
-      swap2(header.mSampleSize);
-      swap2(header.mSampleKind);
-    }
-  
-    fseek (pOutFp, 0L, SEEK_SET);
-    cc = fwrite(&header, sizeof(HtkHeader), 1, pOutFp);
-  
-    if (swap) {
-      swap4(header.mNSamples);
-      swap4(header.mSamplePeriod);
-      swap2(header.mSampleSize);
-      swap2(header.mSampleKind);
-    }
-  
-    return cc == 1 ? 0 : -1;
-  }
-  
-  
-  //***************************************************************************
-  //***************************************************************************
-  int 
-  FeatureRepository::
-  WriteHTKFeature(
-    FILE * pOutFp,
-    FLOAT * pOut,
-    size_t feaLen,
-    bool swap,
-    bool compress,
-    FLOAT* pScale, 
-    FLOAT* pBias)
-  {
-    size_t    i;
-    size_t    cc = 0;
-
-
-    if (compress) 
-    {
-      INT_16 s;
-        
-      for (i = 0; i < feaLen; i++) 
-      {
-	s = pOut[i] * pScale[i] - pBias[i];
-        if (swap) 
-	  swap2(s);
-	cc += fwrite(&s, sizeof(INT_16), 1, pOutFp);
-      }
-      
-    } else {
-  #if !DOUBLEPRECISION
-      if (swap) 
-        for (i = 0; i < feaLen; i++) 
-          swap4(pOut[i]);
-    
-        cc = fwrite(pOut, sizeof(FLOAT_32), feaLen, pOutFp);
-    
-      if (swap) 
-        for (i = 0; i < feaLen; i++) 
-          swap4(pOut[i]);
-  #else
-      FLOAT_32 f;
-  
-      for (i = 0; i < feaLen; i++) 
-      {
-        f = pOut[i];
-        if (swap) 
-          swap4(f);
-        cc += fwrite(&f, sizeof(FLOAT_32), 1, pOutFp);
-      }
-  #endif
-    }
-    return cc == feaLen ? 0 : -1;
-  }
-
-  //***************************************************************************
-  //***************************************************************************
-  int 
-  FeatureRepository::
-  WriteHTKFeatures(
-    FILE *  pOutFp,
-    FLOAT * pOut,
-    int     nCoeffs,
-    int     nSamples,
-    int     samplePeriod,
-    int     targetKind,  
-    bool    swap) 
-  {
-    HtkHeader header;
-    int i, j;
-    FLOAT *pScale = NULL;
-    FLOAT *pBias = NULL;
-    
-    header.mNSamples = nSamples  + ((targetKind & PARAMKIND_C) ? 2 * sizeof(FLOAT_32) / sizeof(INT_16) : 0);
-    header.mSamplePeriod = samplePeriod;
-    header.mSampleSize = nCoeffs * ((targetKind & PARAMKIND_C) ?    sizeof(INT_16)   : sizeof(FLOAT_32));;
-    header.mSampleKind = targetKind;
-    
-    WriteHTKHeader (pOutFp, header, swap);
-
-    if(targetKind & PARAMKIND_C) {
-      pScale = (FLOAT*) malloc(nCoeffs * sizeof(FLOAT));
-      pBias = (FLOAT*)  malloc(nCoeffs * sizeof(FLOAT));
-      if (pScale == NULL || pBias == NULL) Error("Insufficient memory");
-      
-      for(i = 0; i < nCoeffs; i++) {
-        float xmin, xmax;
-	xmin = xmax = pOut[i];
-	for(j = 1; j < nSamples; j++) {
-	  if(pOut[j*nCoeffs+i] > xmax) xmax = pOut[j*nCoeffs+i];
-	  if(pOut[j*nCoeffs+i] < xmin) xmin = pOut[j*nCoeffs+i];
-	}
-	pScale[i] = (2*32767) / (xmax - xmin);
-        pBias[i]  = pScale[i] * (xmax + xmin) / 2;
-	
-	
-      }
-      if (WriteHTKFeature(pOutFp, pScale, nCoeffs, swap, false, 0, 0)
-      ||  WriteHTKFeature(pOutFp, pBias,  nCoeffs, swap, false, 0, 0)) {
-        return -1;
-      }
-    }
-    for(j = 0; j < nSamples; j++) {
-      if (WriteHTKFeature(pOutFp, &pOut[j*nCoeffs], nCoeffs, swap, targetKind & PARAMKIND_C, pScale, pBias)) {
-        return -1;
-      }
-    }
-    return 0;
-  }
-  
-
-  //***************************************************************************
-  //***************************************************************************
-  int 
-  FeatureRepository::
-  WriteHTKFeatures(
-    FILE *  pOutFp,
-    int     samplePeriod,
-    int     targetKind,  
-    bool    swap,
-    Matrix<BaseFloat>&        rFeatureMatrix)
-  {
-    HtkHeader header;
-    size_t i, j;
-    FLOAT *p_scale = NULL;
-    FLOAT *p_bias = NULL;
-    size_t n_samples = rFeatureMatrix.Rows();
-    size_t n_coeffs  = rFeatureMatrix.Cols();
-    
-    header.mNSamples = n_samples  + ((targetKind & PARAMKIND_C) ? 2 * sizeof(FLOAT_32) / sizeof(INT_16) : 0);
-    header.mSamplePeriod = samplePeriod;
-    header.mSampleSize = n_coeffs * ((targetKind & PARAMKIND_C) ?    sizeof(INT_16)   : sizeof(FLOAT_32));;
-    header.mSampleKind = targetKind;
-    
-    WriteHTKHeader (pOutFp, header, swap);
-
-    if(targetKind & PARAMKIND_C) {
-      p_scale = (FLOAT*) malloc(n_coeffs * sizeof(FLOAT));
-      p_bias = (FLOAT*)  malloc(n_coeffs * sizeof(FLOAT));
-      if (p_scale == NULL || p_bias == NULL) Error("Insufficient memory");
-      
-      for(i = 0; i < n_coeffs; i++) {
-        float xmin, xmax;
-	xmin = xmax = rFeatureMatrix[0][i];
-
-	for(j = 1; j < n_samples; j++) {
-	  if(rFeatureMatrix[j][i] > xmax) xmax = rFeatureMatrix[j][i];
-	  if(rFeatureMatrix[j][i] < xmin) xmin = rFeatureMatrix[j][i];
-	}
-
-	p_scale[i] = (2*32767) / (xmax - xmin);
-        p_bias[i]  = p_scale[i] * (xmax + xmin) / 2;
-      }
-
-      if (WriteHTKFeature(pOutFp, p_scale, n_coeffs, swap, false, 0, 0)
-      ||  WriteHTKFeature(pOutFp, p_bias,  n_coeffs, swap, false, 0, 0)) {
-        return -1;
-      }
-    }
-
-    for(j = 0; j < n_samples; j++) {
-      if (WriteHTKFeature(pOutFp, rFeatureMatrix[j].pData(), n_coeffs, swap, targetKind & PARAMKIND_C, p_scale, p_bias)) {
-        return -1;
-      }
-    }
-
-    return 0;
-  }
-  
-  //***************************************************************************
-  //***************************************************************************
-
-
-  bool 
-  FeatureRepository::
-  ReadGzipAsciiFeatures(const FileListElem& rFileNameRecord, Matrix<BaseFloat>& rFeatureMatrix)
-  {
-    //build the command
-    std::string cmd("gunzip -c "); cmd += rFileNameRecord.Physical();
-
-    //define buffer
-    const int buf_size=262144;
-    char buf[buf_size];
-    char vbuf[2*buf_size];
-
-   TIMER_START(mTim);      
-    //open the pipe
-    FILE* fp = popen(cmd.c_str(),"r");
-    if(fp == NULL) {
-      //2nd try...
-      Warning(std::string("2nd try to open pipe: ")+cmd);
-      sleep(5);
-      fp = popen(cmd.c_str(),"r");
-      if(fp == NULL) {
-        KALDI_ERR << "Cannot open pipe: " << cmd;
-      }
-    }
-    setvbuf(fp,vbuf,_IOFBF,2*buf_size);
-   TIMER_END(mTim,mTimeOpen);
-
-    //string will stay allocated across calls
-    static std::string line; line.resize(0);
-
-    //define matrix storage
-    static int cols = 131072;
-    std::list<std::vector<BaseFloat> > matrix(1);
-    matrix.front().reserve(cols);
-
-    //read all the lines to a vector
-    int line_ctr=1;
-    while(1) {
-     TIMER_START(mTim);      
-      if(NULL == fgets(buf,buf_size,fp)) break;
-     TIMER_END(mTim,mTimeRead);
-      
-      line += buf;
-      if(*(line.rbegin()) == '\n' || feof(fp)) {
-        //parse the line of numbers
-       TIMER_START(mTim);      
-        const char* ptr = line.c_str();
-        char* end;
-        while(1) {
-          //skip whitespace
-          while(isspace(*ptr)) ptr++;
-          if(*ptr == 0) break;
-          //check that a number follows
-          switch(*ptr) {
-            case '0': case '1': case '2': case '3': case '4': 
-            case '5': case '6': case '7': case '8': case '9':
-            case '.': case '+': case '-': 
-            break;
-            default : KALDI_ERR << "A number was expected:" << ptr
-                                << " reading from" << cmd; 
-                      exit(1);
-          }
-          //read a number
-          BaseFloat val = strtof(ptr,&end); ptr=end;
-          matrix.back().push_back(val);
-        }
-       TIMER_END(mTim,mTimeNormalize);
-        //we have the line of numbers, insert empty row to matrix
-        if(matrix.back().size() > 0 && !feof(fp)) {
-          matrix.push_back(std::vector<BaseFloat>());
-          matrix.back().reserve(matrix.front().size());
-        }
-        //dispose the current line
-        line.resize(0);//but stay allocated... 
-        line_ctr++;
-      }
-    }
-    if(matrix.back().size() == 0) matrix.pop_back();
-
-    //get matrix dimensions
-    int rows = matrix.size();
-    /*int*/ cols = matrix.front().size();
-
-    //define interators
-    std::list<std::vector<BaseFloat> >::iterator it_r;
-    std::vector<BaseFloat>::iterator it_c;
-
-    //check that all lines have same size
-    int i;
-    for(i=0,it_r=matrix.begin(); it_r != matrix.end(); ++i,++it_r) {
-      if(it_r->size() != cols) {
-        KALDI_ERR << "All rows must have same dimension, 1st line cols: " << cols 
-                  << ", " << i << "th line cols: " << it_r->size();
-      }
-    }
-
-    //copy data to matrix
-   TIMER_START(mTim);      
-    rFeatureMatrix.Init(rows,cols);
-    int r,c;
-    for(r=0,it_r=matrix.begin(); it_r!=matrix.end(); ++r,++it_r) {
-      for(c=0,it_c=it_r->begin(); it_c!=it_r->end(); ++c,++it_c) {
-        rFeatureMatrix(r,c) = *it_c;
-      }
-    }
-   TIMER_END(mTim,mTimeSeek);
-
-    //close the pipe
-    if(pclose(fp) == -1) {
-      KALDI_ERR << "Cannot close pipe: " << cmd;
-    }
-    
-    return true;
-  }
-
-
-  //***************************************************************************
-  //***************************************************************************
-
-} // namespace TNet
diff --git a/tnet_io/KaldiLib/Features.h b/tnet_io/KaldiLib/Features.h
deleted file mode 100644
index 0980ab6..0000000
--- a/tnet_io/KaldiLib/Features.h
+++ /dev/null
@@ -1,597 +0,0 @@
-//
-// C++ Interface: %{MODULE}
-//
-// Description: 
-//
-//
-// Author: %{AUTHOR} <%{EMAIL}>, (C) %{YEAR}
-//
-// Copyright: See COPYING file that comes with this distribution
-//
-//
-
-#ifndef TNet_Features_h
-#define TNet_Features_h
-
-//*****************************************************************************
-//*****************************************************************************
-// Standard includes
-//
-#include <list>
-#include <queue>
-#include <string>
-
-
-//*****************************************************************************
-//*****************************************************************************
-// Specific includes
-//
-#include "Common.h"
-#include "Matrix.h"
-#include "StkStream.h"
-#include "Types.h"
-#include "Timer.h"
-
-
-
-// we need these for reading and writing
-#define UINT_16  unsigned short
-#define UINT_32  unsigned
-#define INT_16   short
-#define INT_32   int
-#define FLOAT_32 float
-#define DOUBLE_64 double
-
-
-#define PARAMKIND_WAVEFORM  0
-#define PARAMKIND_LPC       1
-#define PARAMKIND_LPREFC    2
-#define PARAMKIND_LPCEPSTRA 3
-#define PARAMKIND_LPDELCEP  4
-#define PARAMKIND_IREFC     5
-#define PARAMKIND_MFCC      6
-#define PARAMKIND_FBANK     7
-#define PARAMKIND_MELSPEC   8
-#define PARAMKIND_USER      9
-#define PARAMKIND_DISCRETE 10
-#define PARAMKIND_PLP      11
-#define PARAMKIND_ANON     12
-
-#define PARAMKIND_E   0000100 /// has energy
-#define PARAMKIND_N   0000200 /// absolute energy suppressed
-#define PARAMKIND_D   0000400 /// has delta coefficients
-#define PARAMKIND_A   0001000 /// has acceleration coefficients
-#define PARAMKIND_C   0002000 /// is compressed
-#define PARAMKIND_Z   0004000 /// has zero mean static coef.
-#define PARAMKIND_K   0010000 /// has CRC checksum
-#define PARAMKIND_0   0020000 /// has 0'th cepstral coef.
-#define PARAMKIND_V   0040000 /// has VQ codebook index
-#define PARAMKIND_T   0100000 /// has triple delta coefficients
-
-
-//*****************************************************************************
-//*****************************************************************************
-// Code ...
-//
-
-namespace TNet
-{
-
-  /** **************************************************************************
-   ** **************************************************************************
-   */
-  class FileListElem
-  {
-  private:
-    std::string         mLogical;     ///< Logical file name representation
-    std::string         mPhysical;    ///< Pysical file name representation
-    float               mWeight;
-    
-  public:
-    FileListElem(const std::string & rFileName);
-    ~FileListElem() {}
-    
-    const std::string &
-    Logical() const { return mLogical; }
-
-    const std::string &
-    Physical() const { return mPhysical; }
-
-    const float&
-    Weight() const { return mWeight; }
-  };
-
-  /** *************************************************************************
-   * @brief 
-   */
-  class FeatureRepository
-  {
-  public:
-    /** 
-     * @brief HTK parameter file header (see HTK manual)
-     */
-    struct HtkHeader
-    {
-      int   mNSamples;
-      int   mSamplePeriod;
-      short mSampleSize;
-      short mSampleKind;
-
-      HtkHeader() 
-       : mNSamples(0),mSamplePeriod(100000),mSampleSize(0),mSampleKind(12)
-      { }
-    };
-
-
-    /**
-     *     @brief Extension of the HTK header
-     */
-    struct HtkHeaderExt
-    {
-      int mHeaderSize;
-      int mVersion;
-      int mSampSize;
-    };
-
-
-    /** 
-     * @brief Normalization file type
-     */
-    enum CNFileType
-    {
-      CNF_Mean,
-      CNF_Variance,
-      CNF_VarScale
-    };
-
-
-    static int     
-    ReadParmKind(const char *pStr, bool checkBrackets);
-
-    static int     
-    ParmKind2Str(unsigned parmKind, char *pOutstr);
-
-    static void 
-    ReadCepsNormFile(
-        const char*   pFileName,
-        char**        lastFile,
-        BaseFloat**   vecBuff,
-        int           sampleKind,
-        CNFileType    type,
-        int           coefs);
-
-    static const char mpParmKindNames[13][16];
-
-  
-  
-  //////////////////////////////////////////////////////////////////////////////
-  //  PUBLIC SECTION
-  //////////////////////////////////////////////////////////////////////////////
-  public:
-    /// Iterates through the list of feature file records
-    typedef   std::list<FileListElem>::iterator  ListIterator;
-
-    // some params for loading features
-    bool                        mSwapFeatures;
-    int                         mStartFrameExt;
-    int                         mEndFrameExt;
-    int                         mTargetKind;
-    int                         mDerivOrder;
-    int*                        mDerivWinLengths;
-    const char*                 mpCvgFile;
-    //:TODO: get rid of these
-    const char*                 mpCmnPath;
-    const char*                 mpCmnMask;
-    const char*                 mpCvnPath;
-    const char*                 mpCvnMask;
-
-    int                         mTrace;
-    
-    
-    // Constructors and destructors
-    /**
-     * @brief Default constructor that creates an empty repository
-     */
-    FeatureRepository() : mDerivWinLengths(NULL), mpCvgFile(NULL), 
-       mpCmnPath(NULL), mpCmnMask(NULL), mpCvnPath(NULL), mpCvnMask(NULL),
-       mTrace(0),
-       mpLastFileName(NULL), mLastFileName(""), mpLastCmnFile (NULL), 
-       mpLastCvnFile (NULL), mpLastCvgFile (NULL), mpCmn(NULL), 
-       mpCvn(NULL), mpCvg(NULL), mpA(NULL), mpB(NULL),
-       mTimeOpen(0), mTimeSeek(0), mTimeRead(0), mTimeNormalize(0) 
-    { 
-      mInputQueueIterator        = mInputQueue.end();
-    }
-
-    /**
-     * @brief Copy constructor which copies filled repository
-     */
-    FeatureRepository(const FeatureRepository& ori)
-     : mDerivWinLengths(NULL), mpCvgFile(NULL), 
-       mpCmnPath(NULL), mpCmnMask(NULL), mpCvnPath(NULL), mpCvnMask(NULL),
-       mTrace(0),
-       mpLastFileName(NULL), mLastFileName(""), mpLastCmnFile (NULL), 
-       mpLastCvnFile (NULL), mpLastCvgFile (NULL), mpCmn(NULL), 
-       mpCvn(NULL), mpCvg(NULL), mpA(NULL), mpB(NULL),
-       mTimeOpen(0), mTimeSeek(0), mTimeRead(0), mTimeNormalize(0) 
-    {
-      //copy all the data from the input queue
-      mInputQueue = ori.mInputQueue;
-
-      //initialize like the original
-      Init(
-        ori.mSwapFeatures,
-        ori.mStartFrameExt,
-        ori.mEndFrameExt,
-        ori.mTargetKind,
-        ori.mDerivOrder,
-        ori.mDerivWinLengths,
-        ori.mpCmnPath,
-        ori.mpCmnMask,
-        ori.mpCvnPath,
-        ori.mpCvnMask,
-        ori.mpCvgFile);
-     
-      //set on the end 
-      mInputQueueIterator        = mInputQueue.end(); 
-      //copy default header values
-      mHeader = ori.mHeader;
-    }
-
-
-    /**
-     * @brief Destroys the repository
-     */
-    ~FeatureRepository()
-    {
-      if (NULL != mpA) {
-        free(mpA);
-      }
-
-      if (NULL != mpB) {
-        free(mpB);
-      }
-      //remove all entries
-      mInputQueue.clear();
-
-      if(mTrace&4) {
-        std::cout << "[FeatureRepository -- open:" << mTimeOpen << "s seek:" << mTimeSeek << "s read:" << mTimeRead << "s normalize:" << mTimeNormalize << "s]\n";
-      }
-
-    }
-
-
-    /**
-     * @brief Initializes the object using the given parameters
-     *
-     * @param swap          Boolean value specifies whether to swap bytes 
-     *                      when reading file or not. 
-     * @param extLeft       Features read from file are extended with extLeft 
-     *                      initial frames. Normally, these frames are 
-     *                      repetitions of the first feature frame in file 
-     *                      (with its derivative, if derivatives are preset in
-     *                      the file). However, if segment of feature frames 
-     *                      is extracted according to range specification, the 
-     *                      true feature frames from beyond the segment boundary
-     *                      are used, wherever it is possible. Note that value 
-     *                      of extLeft can be also negative. In such case
-     *                      corresponding number of initial frames is discarded. 
-     * @param extRight      The paramerer is complementary to parameter extLeft 
-     *                      and has obvious meaning. (Controls extensions over
-     *                      the last frame, last frame from file is repeated 
-     *                      only if necessary).
-     * @param targetKind    The parameters is used to check whether 
-     *                      pHeader->mSampleKind match to requited targetKind 
-     *                      and to control suppression of 0'th cepstral or 
-     *                      energy coefficients accorging to modifiers _E, _0, 
-     *                      and _N. Modifiers _D, _A and _T are ignored; 
-     *                      Computation of derivatives is controled by parameters
-     *                      derivOrder and derivWinLen. Value PARAMKIND_ANON 
-     *                      ensures that function do not result in targetKind 
-     *                      mismatch error and cause no _E or _0 suppression.
-     * @param derivOrder    Final features will be augmented with their 
-     *                      derivatives up to 'derivOrder' order. If 'derivOrder'
-     *                      is negative value, no new derivatives are appended 
-     *                      and derivatives that already present in feature file
-     *                      are preserved.  Straight features are considered 
-     *                      to be of zero order. If some derivatives are already 
-     *                      present in feature file, these are not computed 
-     *                      again, only higher order derivatives are appended 
-     *                      if required. Note, that HTK feature file cannot 
-     *                      contain higher order derivatives (e.g. double delta)
-     *                      without containing lower ones (e.g. delta). 
-     *                      Derivative present in feature file that are of 
-     *                      higher order than is required are discarded.  
-     *                      Derivatives are computed in the final stage from 
-     *                      (extracted segment of) feature frames possibly 
-     *                      extended by repeated frames. Derivatives are 
-     *                      computed using the same formula that is employed 
-     *                      also by HTK tools. Lengths of windows used for 
-     *                      computation of derivatives are passed in parameter 
-     *                      derivWinLen. To compute derivatives for frames close 
-     *                      to boundaries, frames before the first and after the 
-     *                      last frame (of the extracted segment) are considered 
-     *                      to be (yet another) repetitions of the first and the 
-     *                      last frame, respectively. If the segment of frames 
-     *                      is extracted according to range specification and 
-     *                      parameters extLeft and extLeft are set to zero, the 
-     *                      first and the last frames of the segment are 
-     *                      considered to be repeated, eventough the true feature
-     *                      frames from beyond the segment boundary can be
-     *                      available in the file. Therefore, segment extracted 
-     *                      from features that were before augmented with 
-     *                      derivatives will differ 
-     *                      from the same segment augmented with derivatives by 
-     *                      this function. Difference will be of course only on 
-     *                      boundaries and only in derivatives. This "incorrect" 
-     *                      behavior was chosen to fully simulate behavior of 
-     *                      HTK tools. To obtain more correct computation of 
-     *                      derivatives, use parameters extLeft and extRight, 
-     *                      which correctly extend segment with the true frames 
-     *                      (if possible) and in resulting feature matrix ignore 
-     *                      first extLeft and last extRight frames. For this 
-     *                      purpose, both extLeft and extRight should be set to 
-     *                      sum of all values in the array derivWinLen.
-     * @param pDerivWinLen  Array of size derivOrder specifying lengths of 
-     *                      windows used for computation of derivatives. 
-     *                      Individual values represents one side context 
-     *                      used in the computation. The each window length is 
-     *                      therefore twice the value from array plus one. 
-     *                      Value at index zero specify window length for first 
-     *                      order derivatives (delta), higher indices 
-     *                      corresponds to higher order derivatives.
-     * @param pCmnPath      Cepstral mean normalization path
-     * @param pCmnMask      Cepstral mean normalization mask
-     * @param pCvnPath      Cepstral variance normalization path
-     * @param pCvnMask      Cepstral variance normalization mask
-     * @param pCvgFile      Global variance file to be parsed
-     *
-     * The given parameters are necessary for propper feature extraction 
-     */
-    void
-    Init(
-        bool                  swap,
-        int                   extLeft,
-        int                   extRight,
-        int                   targetKind,
-        int                   derivOrder,
-        int*                  pDerivWinLen,
-        const char*           pCmnPath,
-        const char*           pCmnMask,
-        const char*           pCvnPath,
-        const char*           pCvnMask,
-        const char*           pCvgFile);
-   
-    
-    void Trace(int trace)
-    { mTrace = trace; } 
-        
-    /** 
-     * @brief Returns a refference to the current file header
-     */
-    const HtkHeader&
-    CurrentHeader() const 
-    { return mHeader; }
-
-    /** 
-     * @brief Returns a refference to the current file header
-     */
-    const HtkHeaderExt&
-    CurrentHeaderExt() const 
-    { return mHeaderExt; }
-
-    /**
-     * @brief Returns the current file details
-     *
-     * @return Refference to a class @c FileListElem
-     *
-     * Logical and physical file names are stored in @c FileListElem class
-     */
-    const std::list<FileListElem>::iterator&
-    pCurrentRecord() const
-    { return mInputQueueIterator; }
-
-
-    /**
-     * @brief Returns the following file details
-     *
-     * @return Refference to a class @c FileListElem
-     *
-     * Logical and physical file names are stored in @c FileListElem class
-     */
-    const std::list<FileListElem>::iterator&
-    pFollowingRecord() const
-    { return mInputQueueIterator; }
-
-
-    void
-    Rewind()
-    { mInputQueueIterator = mInputQueue.begin(); }
-    
-    
-    /**
-     * @brief Adds a single feature file to the repository
-     * @param rFileName file to read features from
-     */
-    void
-    AddFile(const std::string & rFileName);
-    
-
-    /**
-     * @brief Adds a list of feature files to the repository
-     * @param rFileName feature list file to read from
-     */
-    void
-    AddFileList(const char* pFileName, const char* pFilter = "");
-  
-    
-    const FileListElem&
-    Current() const
-    { return *mInputQueueIterator; }
-
-    
-    /** 
-     * @brief Moves to the next record
-     */
-    void
-    MoveNext();
-    
-    /**
-     * @brief Reads full feature matrix from a feature file
-     * @param rMatrix matrix to be created and filled with read data
-     * @return number of successfully read feature vectors
-     */
-    bool
-    ReadFullMatrix(Matrix<BaseFloat>& rMatrix); 
-    
-    bool
-    WriteFeatureMatrix(const Matrix<BaseFloat>& rMatrix, const std::string& filename, int targetKind, int samplePeriod);
-    
-    size_t
-    QueueSize() const {return mInputQueue.size(); }
-
-    /**
-     * @brief Reads feature vectors from a feature file
-     * @param rMatrix matrix to be (only!) filled with read data. 
-     * @return number of successfully read feature vectors
-     * 
-     * The function tries to fill @c pMatrix with feature vectors comming from
-     * the current stream. If there are less vectors left in the stream, 
-     * they are used and true number of successfuly read vectors is returned.
-     */
-    int
-    ReadPartialMatrix(Matrix<BaseFloat>& rMatrix);    
-    
-    /** 
-     * @brief Filters the records of this repository based on HTK logical name
-     * masking. If pFilter equals to NULL, all source repository entries are
-     * coppied to rOut repository.
-     * 
-     * @param pFilter HTK mask that defines the filter
-     * @param pValue Filter value
-     * @param rOut Reference to the new FeatureRepository which will be filled
-     * with the matching records
-     */
-    void
-    HtkFilter(const char* pFilter, const char* pValue, FeatureRepository& rOut);
-
-
-    /** 
-     * @brief Filters the records of this repository based on HTK logical name
-     * masking and returns list of unique names. If pFilter equals to NULL, 
-     * single name "default" is returned.
-     * 
-     * @param pFilter HTK mask that defines the filter
-     * @param rOut Reference to the list of results (std::list< std::string >)
-     */
-    void
-    HtkSelection(const char* pFilter, std::list< std::string >& rOut);
-
-
-    /**
-     * @brief Returns true if there are no feature files left on input
-     */
-    bool
-    EndOfList() const 
-    { return mInputQueueIterator == mInputQueue.end(); }
-
-    const std::string&
-    CurrentIndexFileName() const
-    { return mCurrentIndexFileName; }
-    
-    friend
-    void
-    AddFileListToFeatureRepositories(
-      const char* pFileName,
-      const char* pFilter,
-      std::queue<FeatureRepository *> &featureRepositoryList);
-
-
-////////////////////////////////////////////////////////////////////////////////
-//  PRIVATE SECTION
-////////////////////////////////////////////////////////////////////////////////
-  private:
-    /// List (queue) of input feature files
-    std::list<FileListElem>             mInputQueue;
-    std::list<FileListElem>::iterator   mInputQueueIterator;
-    
-    std::string                         mCurrentIndexFileName;
-    std::string                         mCurrentIndexFileDir;
-    std::string                         mCurrentIndexFileExt;
-
-    /// current stream
-    IStkStream                  mStream;
-      
-    // stores feature file's HTK header
-    HtkHeader                   mHeader;
-    HtkHeaderExt                mHeaderExt;
-
-
-    // this group of variables serve for working withthe same physical
-    // file name more than once
-    char*                       mpLastFileName;
-    std::string                 mLastFileName;
-    char*                       mpLastCmnFile;
-    char*                       mpLastCvnFile;
-    char*                       mpLastCvgFile;
-    BaseFloat*                      mpCmn;
-    BaseFloat*                      mpCvn;
-    BaseFloat*                      mpCvg;
-    HtkHeader                   mLastHeader;
-    BaseFloat*                      mpA;
-    BaseFloat*                      mpB;
-
-
-
-    Timer mTim;
-    double mTimeOpen;
-    double mTimeSeek;
-    double mTimeRead;
-    double mTimeNormalize;
-
-
-    // Reads HTK feature file header
-    int 
-    ReadHTKHeader();
-
-    int 
-    ReadHTKFeature(BaseFloat*    pIn, 
-      size_t    feaLen, 
-      bool      decompress, 
-      BaseFloat*    pScale, 
-      BaseFloat*    pBias);
-
-    
-    bool 
-    ReadHTKFeatures(const std::string& rFileName, Matrix<BaseFloat>& rFeatureMatrix);
-    
-    bool 
-    ReadHTKFeatures(const FileListElem& rFileNameRecord, Matrix<BaseFloat>& rFeatureMatrix);
-
-
-    int 
-    WriteHTKHeader  (FILE* fp_out, HtkHeader header, bool swap);
-
-    int 
-    WriteHTKFeature (FILE* fp_out, FLOAT *out, size_t fea_len, bool swap, bool compress, FLOAT* pScale, FLOAT* pBias);
-
-    int 
-    WriteHTKFeatures(FILE* pOutFp, FLOAT * pOut, int nCoeffs, int nSamples, int samplePeriod, int targetKind, bool swap);
-
-    int 
-    WriteHTKFeatures(
-      FILE *  pOutFp,
-      int     samplePeriod,
-      int     targetKind,  
-      bool    swap,
-      Matrix<BaseFloat>& rFeatureMatrix
-    );
-
-    bool 
-    ReadGzipAsciiFeatures(const FileListElem& rFileNameRecord, Matrix<BaseFloat>& rFeatureMatrix);
-
-  }; // class FeatureStream
-
-} //namespace TNet
-
-#endif // TNet_Features_h
diff --git a/tnet_io/KaldiLib/Labels.cc b/tnet_io/KaldiLib/Labels.cc
deleted file mode 100644
index 8b04cde..0000000
--- a/tnet_io/KaldiLib/Labels.cc
+++ /dev/null
@@ -1,612 +0,0 @@
-#include "Labels.h"
-#include "Timer.h"
-#include "Error.h"
-#include <cstdio>
-#include <sstream>
-
-
-namespace TNet {
-
-
-    ////////////////////////////////////////////////////////////////////////
-    // Class LabelRepository::
-    void
-        LabelRepository::
-        Init(const char* pLabelMlfFile, const char* pOutputLabelMapFile, const char* pLabelDir, const char* pLabelExt) {
-            InitMap(pLabelMlfFile, pOutputLabelMapFile, pLabelDir, pLabelExt);
-        }
-    void
-        LabelRepository::
-        InitExt(const char* pLabelMlfFile, const char* fmt, const char *arg, const char* pLabelDir, const char* pLabelExt) {
-            if (strcmp(fmt, "map") == 0)
-            {
-                InitMap(pLabelMlfFile, arg, pLabelDir, pLabelExt);
-                mlf_fmt = MAP;
-            }
-            else if (strcmp(fmt, "raw") == 0)
-            {
-                InitRaw(pLabelMlfFile, arg, pLabelDir, pLabelExt);
-                mlf_fmt = RAW;
-            }
-        }
-
-    void
-        LabelRepository::
-        InitMap(const char* pLabelMlfFile, const char* pOutputLabelMapFile, const char* pLabelDir, const char* pLabelExt)
-        {
-            assert(NULL != pLabelMlfFile);
-            assert(NULL != pOutputLabelMapFile);
-
-            // initialize the label streams
-            delete mpLabelStream; //if NULL, does nothing
-            delete _mpLabelStream;
-            _mpLabelStream = new std::ifstream(pLabelMlfFile);
-            mpLabelStream  = new IMlfStream(*_mpLabelStream);
-
-            // Label stream is initialized, just test it
-            if(!mpLabelStream->good()) 
-                Error(std::string("Cannot open Label MLF file: ")+pLabelMlfFile);
-
-            // Index the labels (good for randomized file lists)
-            Timer tim; tim.Start();
-            mpLabelStream->Index();
-            tim.End(); mIndexTime += tim.Val(); 
-
-            // Read the state-label to state-id map
-            ReadOutputLabelMap(pOutputLabelMapFile);
-
-            // Store the label dir/ext
-            mpLabelDir = pLabelDir;
-            mpLabelExt = pLabelExt;
-        }
-
-    void
-        LabelRepository::
-        InitRaw(const char* pLabelMlfFile, const char *arg, const char* pLabelDir, const char* pLabelExt)
-        {
-            assert(NULL != pLabelMlfFile);
-            std::istringstream iss(arg); 
-            size_t dim;
-            iss >> dim;
-            if (iss.fail() || dim <= 0)
-                PError("[lab] malformed dimension specification");
-            raw_dim = dim;
-            // initialize the label streams
-            delete mpLabelStream; //if NULL, does nothing
-            delete _mpLabelStream;
-            _mpLabelStream = new std::ifstream(pLabelMlfFile);
-            mpLabelStream  = new IMlfStream(*_mpLabelStream);
-
-            // Label stream is initialized, just test it
-            if(!mpLabelStream->good()) 
-                Error(std::string("Cannot open Label MLF file: ")+pLabelMlfFile);
-
-            // Index the labels (good for randomized file lists)
-            Timer tim; tim.Start();
-            mpLabelStream->Index();
-            tim.End(); mIndexTime += tim.Val(); 
-
-            // Read the state-label to state-id map
-            //ReadOutputLabelMap(pOutputLabelMapFile);
-
-            // Store the label dir/ext
-            mpLabelDir = pLabelDir;
-            mpLabelExt = pLabelExt;
-        }
-
-
-    void 
-        LabelRepository::
-        GenDesiredMatrix(BfMatrix& rDesired, size_t nFrames, size_t sourceRate, const char* pFeatureLogical, bool has_vad)
-        {
-            //timer
-            Timer tim; tim.Start();
-
-            //Get the MLF stream reference...
-            IMlfStream& mLabelStream = *mpLabelStream;
-            //Build the file name of the label
-            MakeHtkFileName(mpLabelFile, pFeatureLogical, mpLabelDir, mpLabelExt);
-
-            //Find block in MLF file
-            mLabelStream.Open(mpLabelFile);
-            if(!mLabelStream.good()) {
-                Error(std::string("Cannot open label MLF record: ") + mpLabelFile);
-            }
-
-
-            //resize the matrix
-            if(nFrames < 1) {
-                KALDI_ERR << "Number of frames:" << nFrames << " is lower than 1!!!\n"
-                    << pFeatureLogical;
-            }
-            int label_map_size = mLabelMap.size();
-            rDesired.Init(nFrames, label_map_size + (has_vad ? 2 : 0), true); //true: Zero()
-
-            //aux variables
-            std::string line, state;
-            unsigned long long beg, end;
-            size_t state_index;
-            size_t trunc_frames = 0;
-            TagToIdMap::iterator it;
-            int vad_state;
-
-            //parse the label file
-            while(!mLabelStream.eof()) {
-                std::getline(mLabelStream, line);
-                if(line == "") continue; //skip newlines/comments from MLF
-                if(line[0] == '#') continue;
-
-                std::istringstream& iss = mGenDesiredMatrixStream;
-                iss.clear();
-                iss.str(line);
-
-                //parse the line
-                //begin
-                iss >> std::ws >> beg;
-                if(iss.fail()) { 
-                    KALDI_ERR << "Cannot parse column 1 (begin)\n"
-                        << "line: " << line << "\n"
-                        << "file: " << mpLabelFile << "\n";
-                }
-                //end
-                iss >> std::ws >> end;
-                if(iss.fail()) { 
-                    KALDI_ERR << "Cannot parse column 2 (end)\n"
-                        << "line: " << line << "\n"
-                        << "file: " << mpLabelFile << "\n";
-                }
-                //state tag
-                iss >> std::ws >> state;
-                if(iss.fail()) { 
-                    KALDI_ERR << "Cannot parse column 3 (state_tag)\n"
-                        << "line: " << line << "\n"
-                        << "file: " << mpLabelFile << "\n";
-                }
-
-                if (has_vad) /* an additional column for vad */
-                {
-                    iss >> std::ws >> vad_state;
-                    if(iss.fail()) { 
-                        KALDI_ERR << "Cannot parse column 4 (vad_state)\n"
-                            << "line: " << line << "\n"
-                            << "file: " << mpLabelFile << "\n";
-                    }
-                }
-
-                //fprintf(stderr, "Parsed: %lld %lld %s\n", beg, end, state.c_str());
-
-                //divide beg/end by sourceRate and round up to get interval of frames
-                beg = (beg+sourceRate/2)/sourceRate;
-                end = (end+sourceRate/2)/sourceRate; 
-                //beg = (int)round(beg / (double)sourceRate);
-                //end = (int)round(end / (double)sourceRate); 
-
-                //find the state id
-                it = mLabelMap.find(state);
-                if(mLabelMap.end() == it) {
-                    Error(std::string("Unknown state tag: '") + state + "' file:'" + mpLabelFile);
-                }
-                state_index = it->second;
-
-                // Fill the desired matrix
-                for(unsigned long long frame=beg; frame<end; frame++) { 
-                    //don't write after matrix... (possible longer transcript than feature file)
-                    if(frame >= (int)rDesired.Rows()) { trunc_frames++; continue; }
-
-                    //check the next frame is empty:
-                    if(0.0 != rDesired[frame].Sum()) {
-                        //ERROR!!!
-                        //find out what was previously filled!!!
-                        BaseFloat max = rDesired[frame].Max();
-                        int idx = -1;
-                        for(int i=0; i<(int)rDesired[frame].Dim(); i++) { 
-                            if(rDesired[frame][i] == max) idx = i; 
-                        }
-                        for(it=mLabelMap.begin(); it!=mLabelMap.end(); ++it) {
-                            if((int)it->second == idx) break;
-                        }
-                        std::string state_prev = "error";
-                        if(it != mLabelMap.end()) {
-                            state_prev = it->first;
-                        }
-                        //print the error message
-                        std::ostringstream os; 
-                        os << "Frame already assigned to other state, "
-                            << " file: " << mpLabelFile 
-                            << " frame: " << frame
-                            << " nframes: " << nFrames 
-                            << " sum: " << rDesired[frame].Sum()  
-                            << " previously assigned to: " << state_prev << "(" << idx << ")" 
-                            << " now should be assigned to: " << state << "(" << state_index << ")"
-                            << "\n";
-                        Error(os.str());
-                    }
-
-                    //fill the row
-                    rDesired[(size_t)frame][state_index] = 1.0f;
-                    if (has_vad)
-                        rDesired[(size_t)frame][label_map_size + !!vad_state] = 1.0f;
-                }
-            }
-
-            mLabelStream.Close();
-
-            //check the desired matrix (rows sum up to 1.0)
-            for(size_t i=0; i<rDesired.Rows(); ++i) {
-                float desired_row_sum = rDesired[i].Sum();
-                if(!desired_row_sum == 1.0) {
-                    std::ostringstream os;
-                    os << "Desired vector sum isn't 1.0, "
-                        << " file: " << mpLabelFile 
-                        << " row: " << i 
-                        << " nframes: " << nFrames 
-                        << " content: " << rDesired[i] 
-                        << " sum: " << desired_row_sum  << "\n";
-                    Error(os.str());
-                }
-            }
-
-            //warning when truncating many frames
-            if(trunc_frames > 10) {
-                std::ostringstream os;
-                os << "Truncated frames: " << trunc_frames 
-                    << " Check sourcerate in features and validity of labels\n";
-                Warning(os.str());
-            }
-
-            //timer
-            tim.End(); mGenDesiredMatrixTime += tim.Val();
-        }
-
-
-
-    void
-        LabelRepository::
-        ReadOutputLabelMap(const char* file)
-        {
-            assert(mLabelMap.size() == 0);
-            int i = 0;
-            std::string state_tag;
-            std::ifstream in(file);
-            if(!in.good())
-                Error(std::string("Cannot open OutputLabelMapFile: ")+file);
-
-            in >> std::ws;
-            while(!in.eof()) {
-                in >> state_tag;
-                in >> std::ws;
-                assert(mLabelMap.find(state_tag) == mLabelMap.end());
-                mLabelMap[state_tag] = i++;
-            }
-
-            in.close();
-            assert(mLabelMap.size() > 0);
-        }
-
-
-    void 
-        LabelRepository::
-        GenDesiredMatrixExt(std::vector<BfMatrix>& rDesired, size_t nFrames, size_t sourceRate, const char* pFeatureLogical) {
-            switch (mlf_fmt)
-            {
-                case MAP: GenDesiredMatrixExtMap(rDesired, nFrames, sourceRate, pFeatureLogical);
-                            break;
-                case RAW: GenDesiredMatrixExtRaw(rDesired, nFrames, sourceRate, pFeatureLogical);
-                          break;
-                default: assert(0);
-            }
-        }
-
-    void 
-        LabelRepository::
-        GenDesiredMatrixExtMap(std::vector<BfMatrix>& rDesired, size_t nFrames, size_t sourceRate, const char* pFeatureLogical)
-        {
-            //timer
-            Timer tim; tim.Start();
-
-            //Get the MLF stream reference...
-            IMlfStream& mLabelStream = *mpLabelStream;
-            //Build the file name of the label
-            MakeHtkFileName(mpLabelFile, pFeatureLogical, mpLabelDir, mpLabelExt);
-
-            //Find block in MLF file
-            mLabelStream.Open(mpLabelFile);
-            if(!mLabelStream.good()) {
-                Error(std::string("Cannot open label MLF record: ") + mpLabelFile);
-            }
-
-
-            //resize the matrix
-            if(nFrames < 1) {
-                KALDI_ERR << "Number of frames:" << nFrames << " is lower than 1!!!\n"
-                    << pFeatureLogical;
-            }
-
-            size_t prev = rDesired.size();
-            rDesired.resize(prev + 1, BfMatrix()); /* state + vad */
-            int label_map_size = mLabelMap.size();
-            rDesired[prev].Init(nFrames, 1, true); //true: Zero()
-
-            //aux variables
-            std::string line, state;
-            unsigned long long beg, end;
-            size_t state_index;
-            size_t trunc_frames = 0;
-            TagToIdMap::iterator it;
-
-            //parse the label file
-            while(!mLabelStream.eof()) {
-                std::getline(mLabelStream, line);
-                if(line == "") continue; //skip newlines/comments from MLF
-                if(line[0] == '#') continue;
-
-                std::istringstream& iss = mGenDesiredMatrixStream;
-                iss.clear();
-                iss.str(line);
-
-                //parse the line
-                //begin
-                iss >> std::ws >> beg;
-                if(iss.fail()) { 
-                    KALDI_ERR << "Cannot parse column 1 (begin)\n"
-                        << "line: " << line << "\n"
-                        << "file: " << mpLabelFile << "\n";
-                }
-                //end
-                iss >> std::ws >> end;
-                if(iss.fail()) { 
-                    KALDI_ERR << "Cannot parse column 2 (end)\n"
-                        << "line: " << line << "\n"
-                        << "file: " << mpLabelFile << "\n";
-                }
-                //state tag
-                iss >> std::ws >> state;
-                if(iss.fail()) { 
-                    KALDI_ERR << "Cannot parse column 3 (state_tag)\n"
-                        << "line: " << line << "\n"
-                        << "file: " << mpLabelFile << "\n";
-                }
-
-
-                //fprintf(stderr, "Parsed: %lld %lld %s\n", beg, end, state.c_str());
-
-                //divide beg/end by sourceRate and round up to get interval of frames
-                beg = (beg+sourceRate/2)/sourceRate;
-                if (end == (unsigned long long)-1)
-                    end = rDesired[prev].Rows();
-                else
-                    end = (end+sourceRate/2)/sourceRate; 
-                //beg = (int)round(beg / (double)sourceRate);
-                //end = (int)round(end / (double)sourceRate); 
-
-                //find the state id
-                it = mLabelMap.find(state);
-                if(mLabelMap.end() == it) {
-                    Error(std::string("Unknown state tag: '") + state + "' file:'" + mpLabelFile);
-                }
-                state_index = it->second;
-
-                // Fill the desired matrix
-                for(unsigned long long frame=beg; frame<end; frame++) { 
-                    //don't write after matrix... (possible longer transcript than feature file)
-                    if(frame >= (int)rDesired[prev].Rows()) { trunc_frames++; continue; }
-
-                    //check the next frame is empty:
-                    if(0.0 != rDesired[prev][frame][0]) {
-                        //ERROR!!!
-                        //find out what was previously filled!!!
-                        /*
-                        BaseFloat max = rDesired[prev][frame].Max();
-                        int idx = -1;
-                        for(int i=0; i<(int)rDesired[prev][frame].Dim(); i++) { 
-                            if(rDesired[prev][frame][i] == max) idx = i; 
-                        }
-                        */
-                        BaseFloat max = rDesired[prev][frame][0];
-                        int idx = round(max);
-                        for(it=mLabelMap.begin(); it!=mLabelMap.end(); ++it) {
-                            if((int)it->second == idx) break;
-                        }
-                        std::string state_prev = "error";
-                        if(it != mLabelMap.end()) {
-                            state_prev = it->first;
-                        }
-                        //print the error message
-                        std::ostringstream os; 
-                        os << "Frame already assigned to other state, "
-                            << " file: " << mpLabelFile 
-                            << " frame: " << frame
-                            << " nframes: " << nFrames 
-                            << " sum: " << max
-                            << " previously assigned to: " << state_prev << "(" << idx << ")" 
-                            << " now should be assigned to: " << state << "(" << state_index << ")"
-                            << "\n";
-                        Error(os.str());
-                    }
-
-                    //fill the row
-                    //rDesired[prev][(size_t)frame][state_index] = 1.0f;
-                    rDesired[prev][(size_t)frame][0] = state_index;
-                }
-            }
-
-            mLabelStream.Close();
-            /*
-            //check the desired matrix (rows sum up to 1.0)
-            for(size_t i=0; i<rDesired[prev].Rows(); ++i) {
-                float desired_row_sum = rDesired[prev][i].Sum();
-                if(!desired_row_sum == 1.0) {
-                    std::ostringstream os;
-                    os << "Desired vector sum isn't 1.0, "
-                        << " file: " << mpLabelFile 
-                        << " row: " << i 
-                        << " nframes: " << nFrames 
-                        << " content: " << rDesired[prev][i] 
-                        << " sum: " << desired_row_sum  << "\n";
-                    Error(os.str());
-                }
-            }
-            */
-
-            //warning when truncating many frames
-            if(trunc_frames > 10) {
-                std::ostringstream os;
-                os << "Truncated frames: " << trunc_frames 
-                    << " Check sourcerate in features and validity of labels\n";
-                Warning(os.str());
-            }
-
-            //timer
-            tim.End(); mGenDesiredMatrixTime += tim.Val();
-        }
-
-    void 
-        LabelRepository::
-        GenDesiredMatrixExtRaw(std::vector<BfMatrix>& rDesired, size_t nFrames, size_t sourceRate, const char* pFeatureLogical)
-        {
-            //timer
-            Timer tim; tim.Start();
-
-            //Get the MLF stream reference...
-            IMlfStream& mLabelStream = *mpLabelStream;
-            //Build the file name of the label
-            MakeHtkFileName(mpLabelFile, pFeatureLogical, mpLabelDir, mpLabelExt);
-
-            //Find block in MLF file
-            mLabelStream.Open(mpLabelFile);
-            if(!mLabelStream.good()) {
-                Error(std::string("Cannot open label MLF record: ") + mpLabelFile);
-            }
-
-
-            //resize the matrix
-            if(nFrames < 1) {
-                KALDI_ERR << "Number of frames:" << nFrames << " is lower than 1!!!\n"
-                    << pFeatureLogical;
-            }
-
-            size_t prev = rDesired.size();
-            rDesired.resize(prev + 1, BfMatrix()); /* state + vad */
-            rDesired[prev].Init(nFrames, raw_dim, true); //true: Zero()
-
-            //aux variables
-            std::string line, state;
-            unsigned long long beg, end;
-            size_t trunc_frames = 0;
-            Vector<BaseFloat> raw;
-            raw.Init(raw_dim);
-
-            //parse the label file
-            while(!mLabelStream.eof()) {
-                std::getline(mLabelStream, line);
-                if(line == "") continue; //skip newlines/comments from MLF
-                if(line[0] == '#') continue;
-
-                std::istringstream& iss = mGenDesiredMatrixStream;
-                iss.clear();
-                iss.str(line);
-
-                //parse the line
-                //begin
-                iss >> std::ws >> beg;
-                if(iss.fail()) { 
-                    KALDI_ERR << "Cannot parse column 1 (begin)\n"
-                        << "line: " << line << "\n"
-                        << "file: " << mpLabelFile << "\n";
-                }
-                //end
-                iss >> std::ws >> end;
-                if(iss.fail()) { 
-                    KALDI_ERR << "Cannot parse column 2 (end)\n"
-                        << "line: " << line << "\n"
-                        << "file: " << mpLabelFile << "\n";
-                }
-
-                for (size_t i = 0; i < raw_dim; i++)
-                {
-                    if (iss.eof())
-                        PError("[label] insufficient columns for the label: %s", mpLabelFile);
-                    iss >> raw[i];
-                    if (iss.fail())
-                        PError("[label] cannot parse raw value for the label: %s", mpLabelFile);
-                }
-                /*
-                   for (size_t i = 0; i < raw_dim; i++)
-                   fprintf(stderr, "%.3f", raw[i]);
-                   fprintf(stderr, "\n");
-                   */
-                //divide beg/end by sourceRate and round up to get interval of frames
-                beg = (beg+sourceRate/2)/sourceRate;
-                if (end == (unsigned long long)-1)
-                    end = rDesired[prev].Rows();
-                else
-                    end = (end+sourceRate/2)/sourceRate; 
-                //printf("end:%lld\n", end);
-                //beg = (int)round(beg / (double)sourceRate);
-                //end = (int)round(end / (double)sourceRate); 
-
-                // Fill the desired matrix
-                for(unsigned long long frame=beg; frame<end; frame++) { 
-                    //don't write after matrix... (possible longer transcript than feature file)
-                    if(frame >= (int)rDesired[prev].Rows()) { trunc_frames++; continue; }
-
-                    //check the next frame is empty:
-                    if(0.0 != rDesired[prev][frame][0]) {
-                        //ERROR!!!
-                        //find out what was previously filled!!!
-                        /*
-                           BaseFloat max = rDesired[prev][frame].Max();
-                           int idx = -1;
-                           for(int i=0; i<(int)rDesired[prev][frame].Dim(); i++) { 
-                           if(rDesired[prev][frame][i] == max) idx = i; 
-                           }
-                           */
-                        BaseFloat max = rDesired[prev][frame][0];
-                        //print the error message
-                        std::ostringstream os; 
-                        os << "Frame already assigned to other state, "
-                            << " file: " << mpLabelFile 
-                            << " frame: " << frame
-                            << " nframes: " << nFrames 
-                            << " sum: " << max
-                            << "\n";
-                        Error(os.str());
-                    }
-
-                    //fill the row
-                    //rDesired[prev][(size_t)frame][state_index] = 1.0f;
-                    rDesired[prev][(size_t)frame].Copy(raw);
-                }
-            }
-
-            mLabelStream.Close();
-            /*
-            //check the desired matrix (rows sum up to 1.0)
-            for(size_t i=0; i<rDesired[prev].Rows(); ++i) {
-            float desired_row_sum = rDesired[prev][i].Sum();
-            if(!desired_row_sum == 1.0) {
-            std::ostringstream os;
-            os << "Desired vector sum isn't 1.0, "
-            << " file: " << mpLabelFile 
-            << " row: " << i 
-            << " nframes: " << nFrames 
-            << " content: " << rDesired[prev][i] 
-            << " sum: " << desired_row_sum  << "\n";
-            Error(os.str());
-            }
-            }
-            */
-
-            //warning when truncating many frames
-            if(trunc_frames > 10) {
-                std::ostringstream os;
-                os << "Truncated frames: " << trunc_frames 
-                    << " Check sourcerate in features and validity of labels\n";
-                Warning(os.str());
-            }
-
-            //timer
-            tim.End(); mGenDesiredMatrixTime += tim.Val();
-        }
-
-}//namespace
diff --git a/tnet_io/KaldiLib/Labels.h b/tnet_io/KaldiLib/Labels.h
deleted file mode 100644
index 409a080..0000000
--- a/tnet_io/KaldiLib/Labels.h
+++ /dev/null
@@ -1,90 +0,0 @@
-#ifndef _LABELS_H_
-#define _LABELS_H_
-
-
-#include "Matrix.h"
-#include "MlfStream.h"
-#include "Features.h"
-
-#include <map>
-#include <iostream>
-
-namespace TNet {
-
-
-  class FeaCatPool;
-
-  /**
-   * Desired matrix generation object,
-   * supports background-reading and caching, however can be 
-   * used in foreground as well by GenDesiredMatrix()
-   */
-  class LabelRepository 
-  {
-    typedef std::map<std::string,size_t> TagToIdMap;
-
-    public:
-       enum MFormat {
-           MAP,
-           RAW
-       };
-
-      LabelRepository()
-        : _mpLabelStream(NULL), mpLabelStream(NULL), mpLabelDir(NULL), mpLabelExt(NULL), mGenDesiredMatrixTime(0), mIndexTime(0), mTrace(0) 
-      { }
-
-      ~LabelRepository()
-      { 
-        if(mTrace&4) {
-          std::cout << "[LabelRepository -- indexing:" << mIndexTime << "s"
-                       " genDesiredMatrix:" << mGenDesiredMatrixTime << "s]" << std::endl;
-        }
-        delete mpLabelStream;
-        delete _mpLabelStream;
-      }
-
-      /// Initialize the LabelRepository      
-      void Init(const char* pLabelMlfFile, const char* pOutputLabelMapFile, const char* pLabelDir, const char* pLabelExt);
-      void InitExt(const char* pLabelMlfFile, const char* fmt, const char* arg, const char* pLabelDir, const char* pLabelExt);
-      void InitMap(const char* pLabelMlfFile, const char* pOutputLabelMapFile, const char* pLabelDir, const char* pLabelExt);
-      void InitRaw(const char* pLabelMlfFile,const char* arg, const char* pLabelDir, const char* pLabelExt);
-
-      /// Set trace level
-      void Trace(int trace)
-      { mTrace = trace; }
-
-      /// Get desired matrix from labels
-      void GenDesiredMatrix(BfMatrix& rDesired, size_t nFrames, size_t sourceRate, const char* pFeatureLogical, bool has_vad = false);
-
-      void GenDesiredMatrixExt(std::vector<BfMatrix>& rDesired, size_t nFrames, size_t sourceRate, const char* pFeatureLogical);
-      void GenDesiredMatrixExtMap(std::vector<BfMatrix>& rDesired, size_t nFrames, size_t sourceRate, const char* pFeatureLogical);
-      void GenDesiredMatrixExtRaw(std::vector<BfMatrix>& rDesired, size_t nFrames, size_t sourceRate, const char* pFeatureLogical);
-      size_t getWidth() { return mLabelMap.size(); }
-      MFormat getFormat() { return mlf_fmt; }
-    private:
-      /// Prepare the state-label to state-id map
-      void ReadOutputLabelMap(const char* file);
-      
-    private:
-      // Streams and state-map
-      std::ifstream* _mpLabelStream; ///< Helper stream for Label stream
-      IMlfStream* mpLabelStream;     ///< Label stream
-      std::istringstream mGenDesiredMatrixStream; ///< Label file parsing stream
-     
-      const char* mpLabelDir;  ///< Label dir in MLF 
-      const char* mpLabelExt;  ///< Label ext in MLF
-      char mpLabelFile[4096];  ///< Buffer for filenames in MLF
-      
-      TagToIdMap mLabelMap; ///< Map of state tags to net output indices
-
-      double mGenDesiredMatrixTime;
-      float  mIndexTime;
-
-      int mTrace;
-      MFormat mlf_fmt;
-      size_t raw_dim;
-  };
-
-}//namespace
-
-#endif
diff --git a/tnet_io/KaldiLib/Makefile b/tnet_io/KaldiLib/Makefile
deleted file mode 100644
index 61e0a59..0000000
--- a/tnet_io/KaldiLib/Makefile
+++ /dev/null
@@ -1,28 +0,0 @@
-
-include ../tnet.mk
-
-INCLUDE = -I. 
-
-all: $(OBJ_DIR)/libKaldiLib.a
-
-$(OBJ_DIR)/libKaldiLib.a: $(OBJ)
-	$(AR) ruv $@ $(OBJ)
-	$(RANLIB) $@ 
-
-$(OBJ_DIR)/%.o : %.cc
-	$(CXX)  -o $@  -c $< $(CFLAGS) $(CXXFLAGS) $(INCLUDE)
-
-
-
-.PHONY: clean doc depend
-clean:
-	rm -f $(OBJ_DIR)/*.o $(OBJ_DIR)/*.a
-
-doc:
-	doxygen ../../doc/doxyfile_TNetLib
-
-depend:
-	$(CXX) -M $(CXXFLAGS) *.cc $(INCLUDE) > .depend.mk
-
--include .depend.mk
-
diff --git a/tnet_io/KaldiLib/MathAux.h b/tnet_io/KaldiLib/MathAux.h
deleted file mode 100644
index c08e836..0000000
--- a/tnet_io/KaldiLib/MathAux.h
+++ /dev/null
@@ -1,117 +0,0 @@
-#ifndef TNet_MathAux_h
-#define TNet_MathAux_h
-
-#include <cmath>
-
-
-#if !defined(SQR)
-# define SQR(x) ((x) * (x))
-#endif
-
-
-#if !defined(LOG_0)
-# define LOG_0 (-1.0e10)
-#endif
-
-#if !defined(LOG_MIN)
-# define LOG_MIN   (0.5 * LOG_0)
-#endif
-
-
-#ifndef DBL_EPSILON
-#define DBL_EPSILON 2.2204460492503131e-16
-#endif
-
-
-#ifndef M_PI
-#  define M_PI 3.1415926535897932384626433832795
-#endif
-
-#define M_LOG_2PI 1.8378770664093454835606594728112
-
-
-#if DOUBLEPRECISION
-#  define FLOAT double
-#  define EPSILON DBL_EPSILON
-#  define FLOAT_FMT "%lg"
-#  define swapFLOAT swap8
-#  define _ABS  fabs
-#  define _COS  cos
-#  define _EXP  exp
-#  define _LOG  log
-#  define _SQRT sqrt
-#else
-#  define FLOAT float
-#  define EPSILON FLT_EPSILON
-#  define FLOAT_FMT "%g"
-#  define swapFLOAT swap4
-#  define _ABS  fabsf
-#  define _COS  cosf
-#  define _EXP  expf
-#  define _LOG  logf
-#  define _SQRT sqrtf
-#endif
-
-namespace TNet
-{
-  inline float frand(){ // random between 0 and 1.
-	return (float(rand()) + 1.0f) / (float(RAND_MAX)+2.0f);
-  }
-  inline float gauss_rand(){
-	return _SQRT( -2.0f * _LOG(frand()) ) * _COS(2.0f*float(M_PI)*frand());
-  }
-  
-  static const double gMinLogDiff = log(DBL_EPSILON);
-  
-  //***************************************************************************
-  //***************************************************************************
-  inline double
-  LogAdd(double x, double y)
-  {
-    double diff;
-  
-    if (x < y) {
-      diff = x - y;
-      x = y;
-    } else {
-      diff = y - x;
-    }
-  
-    double res;
-    if (x >= LOG_MIN) {
-      if (diff >= gMinLogDiff) {
-        res = x + log(1.0 + exp(diff));
-      } else {
-        res = x;
-      }
-    } else {
-      res = LOG_0;
-    }
-    return res;
-  } 
-
-
-  //***************************************************************************
-  //***************************************************************************
-  inline double
-  LogSub(double x, double y) // returns exp(x) - exp(y).  Throws exception if y>=x.
-  {
-
-    if(y >= x){
-      if(y==x)  return LOG_0;
-      else throw std::runtime_error("LogSub: cannot subtract a larger from a smaller number.");
-    }
-
-    double diff = y - x;  // Will be negative.
-    
-    double res = x + log(1.0 - exp(diff));
-
-    if(res != res) // test for res==NaN.. could happen if diff ~0.0, so 1.0-exp(diff) == 0.0 to machine precision.
-      res = LOG_0;
-    return res;
-  } 
-
-} // namespace TNet
-
-
-#endif
diff --git a/tnet_io/KaldiLib/Matrix.cc b/tnet_io/KaldiLib/Matrix.cc
deleted file mode 100644
index f9d5909..0000000
--- a/tnet_io/KaldiLib/Matrix.cc
+++ /dev/null
@@ -1,295 +0,0 @@
-/** 
- * @file Matrix.cc 
- * 
- * Implementation of specialized Matrix template methods 
- */
-
-
-#include "Matrix.h"
-
-#if defined(HAVE_CLAPACK)
-#include "CLAPACK-3.1.1.1/INCLUDE/f2c.h"
-extern "C" {
-#include "CLAPACK-3.1.1.1/INCLUDE/clapack.h"
-}
-// These are some stupid clapack things that we want to get rid of
-#ifdef min
-#undef min
-#endif
-
-#ifdef max
-#undef max
-#endif
-
-#endif
-
-
-
-
-namespace TNet
-{
-  //***************************************************************************
-  //***************************************************************************
-#ifdef HAVE_ATLAS
-  //***************************************************************************
-  //***************************************************************************
-  template<>
-    Matrix<float> &
-    Matrix<float>::
-     Invert(float *LogDet, float *DetSign, bool inverse_needed)
-  { 
-      assert(Rows() == Cols());
-      
-#if defined(HAVE_CLAPACK)
-      integer* pivot = new integer[mMRows];
-      integer  M = Rows();
-      integer  N = Cols();
-      integer  LDA = mStride;
-      integer  result;
-      integer  l_work = std::max<integer>(1, N);
-      float*   p_work = new float[l_work];
-
-      sgetrf_(&M, &N, mpData, &LDA, pivot, &result);
-	  const int pivot_offset=1;
-#else
-      int* pivot = new int[mMRows];
-      int result = clapack_sgetrf(CblasColMajor, Rows(), Cols(), mpData, mStride, pivot);
-	  const int pivot_offset=0;
-#endif
-      assert(result >= 0 && "Call to CLAPACK sgetrf_ or ATLAS clapack_sgetrf called with wrong arguments");
-      if(result != 0) {
-        Error("Matrix is singular");
-      }
-	  if(DetSign!=NULL){ *DetSign=1.0; for(size_t i=0;i<mMRows;i++) if(pivot[i]!=(int)i+pivot_offset) *DetSign *= -1.0; }
-	  if(LogDet!=NULL||DetSign!=NULL){ // Compute log determinant...
-		assert(mMRows==mMCols); // Can't take determinant of non-square matrix.
-		*LogDet = 0.0;  float prod = 1.0;
-		for(size_t i=0;i<mMRows;i++){ 
-		  prod *= (*this)(i,i); 
-		  if(i==mMRows-1 || fabs(prod)<1.0e-10 || fabs(prod)>1.0e+10){ 
-			if(LogDet!=NULL) *LogDet += log(fabs(prod)); 
-			if(DetSign!=NULL) *DetSign *= (prod>0?1.0:-1.0);
-			prod=1.0;
-		  }
-		}
-	  }
-#if defined(HAVE_CLAPACK)
-      if(inverse_needed) sgetri_(&M, mpData, &LDA, pivot, p_work, &l_work, &result);
-      delete [] pivot;
-#else
-      if(inverse_needed) result = clapack_sgetri(CblasColMajor, Rows(), mpData, mStride, pivot);
-      delete [] pivot;
-#endif
-      assert(result == 0 && "Call to CLAPACK sgetri_ or ATLAS clapack_sgetri called with wrong arguments");
-      return *this;
-    }
-
-  
-  //***************************************************************************
-  //***************************************************************************
-  template<>
-    Matrix<double> &
-    Matrix<double>::
-     Invert(double *LogDet, double *DetSign, bool inverse_needed)
-    { 
-      assert(Rows() == Cols());
-      
-#if defined(HAVE_CLAPACK)
-      integer* pivot = new integer[mMRows];
-      integer  M = Rows();
-      integer  N = Cols();
-      integer  LDA = mStride;
-      integer  result;
-      integer  l_work = std::max<integer>(1, N);
-      double*   p_work = new double[l_work];
-
-      dgetrf_(&M, &N, mpData, &LDA, pivot, &result);
-	  const int pivot_offset=1;
-#else
-      int* pivot = new int[mMRows];
-      int result = clapack_dgetrf(CblasColMajor, Rows(), Cols(), mpData, mStride, pivot);
-	  const int pivot_offset=0;
-#endif
-      assert(result >= 0 && "Call to CLAPACK dgetrf_ or ATLAS clapack_dgetrf called with wrong arguments");
-      if(result != 0) {
-        Error("Matrix is singular");
-      }
-	  if(DetSign!=NULL){ *DetSign=1.0; for(size_t i=0;i<mMRows;i++) if(pivot[i]!=(int)i+pivot_offset) *DetSign *= -1.0; }
-	  if(LogDet!=NULL||DetSign!=NULL){ // Compute log determinant...
-		assert(mMRows==mMCols); // Can't take determinant of non-square matrix.
-		*LogDet = 0.0;  double prod = 1.0;
-		for(size_t i=0;i<mMRows;i++){ 
-		  prod *= (*this)(i,i); 
-		  if(i==mMRows-1 || fabs(prod)<1.0e-10 || fabs(prod)>1.0e+10){ 
-			if(LogDet!=NULL) *LogDet += log(fabs(prod)); 
-			if(DetSign!=NULL) *DetSign *= (prod>0?1.0:-1.0);
-			prod=1.0;
-		  }
-		}
-	  }
-#if defined(HAVE_CLAPACK)
-      if(inverse_needed) dgetri_(&M, mpData, &LDA, pivot, p_work, &l_work, &result);
-      delete [] pivot;
-#else
-      if(inverse_needed) result = clapack_dgetri(CblasColMajor, Rows(), mpData, mStride, pivot);
-      delete [] pivot;
-#endif
-      assert(result == 0 && "Call to CLAPACK dgetri_ or ATLAS clapack_dgetri called with wrong arguments");
-      return *this;
-    }
-
-  template<>
-    Matrix<float> &
-    Matrix<float>::
-    BlasGer(const float alpha, const Vector<float>& rA, const Vector<float>& rB)
-    {
-      assert(rA.Dim() == mMRows && rB.Dim() == mMCols);
-      cblas_sger(CblasRowMajor, rA.Dim(), rB.Dim(), alpha, rA.pData(), 1, rB.pData(), 1, mpData, mStride);
-      return *this;
-    }
-
-  template<>
-    Matrix<double> &
-    Matrix<double>::
-  BlasGer(const double alpha, const Vector<double>& rA, const Vector<double>& rB)
-    {
-      assert(rA.Dim() == mMRows && rB.Dim() == mMCols);
-      cblas_dger(CblasRowMajor, rA.Dim(), rB.Dim(), alpha, rA.pData(), 1, rB.pData(), 1, mpData, mStride);
-      return *this;
-    }
-  
-  template<>
-    Matrix<float>&
-    Matrix<float>::
-    BlasGemm(const float alpha,
-              const Matrix<float>& rA, MatrixTrasposeType transA,
-              const Matrix<float>& rB, MatrixTrasposeType transB,
-              const float beta)
-    {
-      assert((transA == NO_TRANS && transB == NO_TRANS && rA.Cols() == rB.Rows() && rA.Rows() == Rows() && rB.Cols() == Cols())
-	     || (transA ==    TRANS && transB == NO_TRANS && rA.Rows() == rB.Rows() && rA.Cols() == Rows() && rB.Cols() == Cols())
-	     || (transA == NO_TRANS && transB ==    TRANS && rA.Cols() == rB.Cols() && rA.Rows() == Rows() && rB.Rows() == Cols())
-	     || (transA ==    TRANS && transB ==    TRANS && rA.Rows() == rB.Cols() && rA.Cols() == Rows() && rB.Rows() == Cols()));
-
-      cblas_sgemm(CblasRowMajor, static_cast<CBLAS_TRANSPOSE>(transA), static_cast<CBLAS_TRANSPOSE>(transB),
-                  Rows(), Cols(), transA == NO_TRANS ? rA.Cols() : rA.Rows(),
-                  alpha, rA.mpData, rA.mStride, rB.mpData, rB.mStride,
-                  beta, mpData, mStride);
-      return *this;
-    }
-
-  template<>
-   Matrix<double>&
-    Matrix<double>::
-    BlasGemm(const double alpha,
-              const Matrix<double>& rA, MatrixTrasposeType transA,
-              const Matrix<double>& rB, MatrixTrasposeType transB,
-              const double beta)
-    {
-      assert((transA == NO_TRANS && transB == NO_TRANS && rA.Cols() == rB.Rows() && rA.Rows() == Rows() && rB.Cols() == Cols())
-	     || (transA ==    TRANS && transB == NO_TRANS && rA.Rows() == rB.Rows() && rA.Cols() == Rows() && rB.Cols() == Cols())
-	     || (transA == NO_TRANS && transB ==    TRANS && rA.Cols() == rB.Cols() && rA.Rows() == Rows() && rB.Rows() == Cols())
-	     || (transA ==    TRANS && transB ==    TRANS && rA.Rows() == rB.Cols() && rA.Cols() == Rows() && rB.Rows() == Cols()));
-
-      cblas_dgemm(CblasRowMajor, static_cast<CBLAS_TRANSPOSE>(transA), static_cast<CBLAS_TRANSPOSE>(transB),
-                  Rows(), Cols(), transA == NO_TRANS ? rA.Cols() : rA.Rows(),
-                  alpha, rA.mpData, rA.mStride, rB.mpData, rB.mStride,
-                  beta, mpData, mStride);
-      return *this;
-    }
-
-  template<>
-    Matrix<float>&
-    Matrix<float>::
-         Axpy(const float alpha,
-              const Matrix<float>& rA, MatrixTrasposeType transA){
-	int aStride = (int)rA.mStride, stride = mStride;
-	float *adata=rA.mpData, *data=mpData;
-	if(transA == NO_TRANS){
-	  assert(rA.Rows()==Rows() && rA.Cols()==Cols());
-	  for(size_t row=0;row<mMRows;row++,adata+=aStride,data+=stride)
-		cblas_saxpy(mMCols, alpha, adata, 1, data, 1);
-	} else {
-	  assert(rA.Cols()==Rows() && rA.Rows()==Cols());
-	  for(size_t row=0;row<mMRows;row++,adata++,data+=stride)
-		cblas_saxpy(mMCols, alpha, adata, aStride, data, 1);
-	}
-	return *this;
-  } 
-
-  template<>
-    Matrix<double>&
-    Matrix<double>::
-         Axpy(const double alpha,
-              const Matrix<double>& rA, MatrixTrasposeType transA){
-	int aStride = (int)rA.mStride, stride = mStride;
-	double *adata=rA.mpData, *data=mpData;
-	if(transA == NO_TRANS){
-	  assert(rA.Rows()==Rows() && rA.Cols()==Cols());
-	  for(size_t row=0;row<mMRows;row++,adata+=aStride,data+=stride)
-		cblas_daxpy(mMCols, alpha, adata, 1, data, 1);
-	} else {
-	  assert(rA.Cols()==Rows() && rA.Rows()==Cols());
-	  for(size_t row=0;row<mMRows;row++,adata++,data+=stride)
-		cblas_daxpy(mMCols, alpha, adata, aStride, data, 1);
-	}
-	return *this;
-  } 
-
-  template <>  //non-member but friend!
-  double TraceOfProduct(const Matrix<double> &A, const Matrix<double> &B){ // tr(A B), equivalent to sum of each element of A times same element in B'
-	size_t aStride = A.mStride, bStride = B.mStride;
-	assert(A.Rows()==B.Cols() && A.Cols()==B.Rows());
-	double ans = 0.0;
-	double *adata=A.mpData, *bdata=B.mpData;
-	size_t arows=A.Rows(), acols=A.Cols();
-	for(size_t row=0;row<arows;row++,adata+=aStride,bdata++)
-	  ans += cblas_ddot(acols, adata, 1, bdata, bStride);
-	return ans;
-  }
-
-  template <>  //non-member but friend!
-  double TraceOfProductT(const Matrix<double> &A, const Matrix<double> &B){ // tr(A B), equivalent to sum of each element of A times same element in B'
-	size_t aStride = A.mStride, bStride = B.mStride;
-	assert(A.Rows()==B.Rows() && A.Cols()==B.Cols());
-	double ans = 0.0;
-	double *adata=A.mpData, *bdata=B.mpData;
-	size_t arows=A.Rows(), acols=A.Cols();
-	for(size_t row=0;row<arows;row++,adata+=aStride,bdata+=bStride)
-	  ans += cblas_ddot(acols, adata, 1, bdata, 1);
-	return ans;
-  }
-
-
-  template <>  //non-member but friend!
-  float TraceOfProduct(const Matrix<float> &A, const Matrix<float> &B){ // tr(A B), equivalent to sum of each element of A times same element in B'
-	size_t aStride = A.mStride, bStride = B.mStride;
-	assert(A.Rows()==B.Cols() && A.Cols()==B.Rows());
-	float ans = 0.0;
-	float *adata=A.mpData, *bdata=B.mpData;
-	size_t arows=A.Rows(), acols=A.Cols();
-	for(size_t row=0;row<arows;row++,adata+=aStride,bdata++)
-	  ans += cblas_sdot(acols, adata, 1, bdata, bStride);
-	return ans;
-  }
-
-  template <>  //non-member but friend!
-  float TraceOfProductT(const Matrix<float> &A, const Matrix<float> &B){ // tr(A B), equivalent to sum of each element of A times same element in B'
-	size_t aStride = A.mStride, bStride = B.mStride;
-	assert(A.Rows()==B.Rows() && A.Cols()==B.Cols());
-	float ans = 0.0;
-	float *adata=A.mpData, *bdata=B.mpData;
-	size_t arows=A.Rows(), acols=A.Cols();
-	for(size_t row=0;row<arows;row++,adata+=aStride,bdata+=bStride)
-	  ans += cblas_sdot(acols, adata, 1, bdata, 1);
-	return ans;
-  }
-
-
-
-
-#endif //HAVE_ATLAS
-
-
-
-} //namespace STK
diff --git a/tnet_io/KaldiLib/Matrix.h b/tnet_io/KaldiLib/Matrix.h
deleted file mode 100644
index d33cb0c..0000000
--- a/tnet_io/KaldiLib/Matrix.h
+++ /dev/null
@@ -1,677 +0,0 @@
-#ifndef TNet_Matrix_h
-#define TNet_Matrix_h
-
-#include <stddef.h>
-#include <stdlib.h>
-#include <stdexcept>
-#include <iostream>
-
-#ifdef HAVE_ATLAS
-extern "C"{
-  #include <cblas.h>
-  #include <clapack.h>
-}
-#endif
-
-#include "Common.h"
-#include "MathAux.h"
-#include "Types.h"
-#include "Error.h"
-
-//#define TRACE_MATRIX_OPERATIONS
-#define CHECKSIZE
-
-namespace TNet
-{
-
-
-  //  class matrix_error : public std::logic_error {};
-  //  class matrix_sizes_error : public matrix_error {};
-
-  // declare the class so the header knows about it
-  template<typename _ElemT> class Vector;
-  template<typename _ElemT> class SubVector;
-  template<typename _ElemT> class Matrix;
-  template<typename _ElemT> class SubMatrix;
-
-  // we need to declare the friend << operator here
-  template<typename _ElemT>
-    std::ostream & operator << (std::ostream & rOut, const Matrix<_ElemT> & rM);
-
-  // we need to declare the friend << operator here
-  template<typename _ElemT>
-    std::istream & operator >> (std::istream & rIn, Matrix<_ElemT> & rM);
-
-  // we need to declare this friend function here
-  template<typename _ElemT>
-   _ElemT TraceOfProduct(const Matrix<_ElemT> &A, const Matrix<_ElemT> &B); // tr(A B)
-
-  // we need to declare this friend function here
-  template<typename _ElemT> 
-	 _ElemT TraceOfProductT(const Matrix<_ElemT> &A, const Matrix<_ElemT> &B); // tr(A B^T)==tr(A^T B)
-
-
-  /** **************************************************************************
-   ** **************************************************************************
-   *  @brief Provides a matrix class
-   *
-   *  This class provides a way to work with matrices in TNet.
-   *  It encapsulates basic operations and memory optimizations.
-   *
-   */
-  template<typename _ElemT>
-    class Matrix
-    {
-    public:
-      /// defines a transpose type
-
-      struct HtkHeader
-      {
-        INT_32    mNSamples;              
-        INT_32    mSamplePeriod;
-        INT_16    mSampleSize;
-        UINT_16   mSampleKind;
-      };
-
-
-      /** 
-       * @brief Extension of the HTK header
-       */
-      struct HtkHeaderExt
-      {
-        INT_32 mHeaderSize;
-        INT_32 mVersion;
-        INT_32 mSampSize;
-      };  
-
-
-
-
-      /// defines a type of this
-      typedef Matrix<_ElemT>    ThisType;
-
-      // Constructors
-
-      /// Empty constructor
-      Matrix<_ElemT> ():
-        mpData(NULL), mMCols(0), mMRows(0), mStride(0)
-#ifdef STK_MEMALIGN_MANUAL
-        , mpFreeData(NULL)
-#endif
-      {}
-
-      /// Copy constructor
-      Matrix<_ElemT> (const Matrix<_ElemT> & rM, MatrixTrasposeType trans=NO_TRANS):
-        mpData(NULL) 
-      { if(trans==NO_TRANS){ Init(rM.mMRows, rM.mMCols); Copy(rM); } else { Init(rM.mMCols,rM.mMRows); Copy(rM,TRANS); } }
-
-      /// Copy constructor from another type.
-      template<typename _ElemU>
-      explicit Matrix<_ElemT> (const Matrix<_ElemU> & rM, MatrixTrasposeType trans=NO_TRANS):
-        mpData(NULL) 
-      { if(trans==NO_TRANS){ Init(rM.Rows(), rM.Cols()); Copy(rM); } else { Init(rM.Cols(),rM.Rows()); Copy(rM,TRANS); } }
-
-      /// Basic constructor
-      Matrix(const size_t r, const size_t c, bool clear=true)
-      { mpData=NULL; Init(r, c, clear);  }
-
-
-	  Matrix<_ElemT> &operator = (const Matrix <_ElemT> &other) { Init(other.Rows(), other.Cols()); Copy(other); return *this; } // Needed for inclusion in std::vector
-
-      /// Destructor
-      ~Matrix()
-      { Destroy(); }
-
-
-      /// Initializes matrix (if not done by constructor)
-      ThisType &
-      Init(const size_t r,
-           const size_t c, bool clear=true);
-
-      /**
-       * @brief Dealocates the matrix from memory and resets the dimensions to (0, 0)
-       */
-      void
-      Destroy();
-
-
-      ThisType &
-      Zero();
-
-      ThisType &
-      Unit(); // set to unit.
-
-      /** 
-       * @brief Copies the contents of a matrix
-       * @param rM Source data matrix
-       * @return Returns reference to this
-       */
-      template<typename _ElemU> ThisType &
-        Copy(const Matrix<_ElemU> & rM, MatrixTrasposeType Trans=NO_TRANS);
-
-
-
-      /**
-       * @brief Copies the elements of a vector row-by-row into a matrix
-       * @param rV Source vector
-       * @param nRows Number of rows of returned matrix
-       * @param nCols Number of columns of returned matrix
-       *
-       * Note that rV.Dim() must equal nRows*nCols
-       */
-      ThisType &
-      CopyVectorSplicedRows(const Vector<_ElemT> &rV, const size_t nRows, const size_t nCols);
-
-      /**
-       * @brief Returns @c true if matrix is initialized
-       */
-      bool
-		IsInitialized() const
-      { return mpData != NULL; }
-
-      /// Returns number of rows in the matrix
-      inline size_t
-		Rows() const
-      {
-        return mMRows;
-      }
-
-      /// Returns number of columns in the matrix
-      inline size_t
-      Cols() const
-      {
-        return mMCols;
-      }
-
-      /// Returns number of columns in the matrix memory
-      inline size_t
-		Stride() const
-      {
-        return mStride;
-      }
-
-
-      /**
-       *  @brief Gives access to a specified matrix row without range check
-       *  @return Pointer to the const array
-       */
-      inline const _ElemT*  __attribute__((aligned(16)))
-       pData () const
-      {
-        return mpData;
-      }
-
-
-      /**
-       *  @brief Gives access to a specified matrix row without range check
-       *  @return Pointer to the non-const data array
-       */
-      inline _ElemT* __attribute__((aligned(16)))
-       pData () 
-      {
-        return mpData;
-      }
-
-
-      /**
-       *  @brief pData_workaround is a workaround that allows SubMatrix to get a 
-       *  @return pointer to non-const data even though the Matrix is const... 
-       */
-    protected:
-      inline _ElemT*  __attribute__((aligned(16)))
-       pData_workaround () const
-      {
-        return mpData;
-      }
-    public:
-
-
-      /// Returns size of matrix in memory
-      size_t
-      MSize() const
-      {
-        return mMRows * mStride * sizeof(_ElemT);
-      }
-
-      /// Checks the content of the matrix for nan and inf values
-      void
-      CheckData(const std::string file = "") const
-      {
-        for(size_t row=0; row<Rows(); row++) {
-          for(size_t col=0; col<Cols(); col++) {
-            if(isnan((*this)(row,col)) || isinf((*this)(row,col))) {
-              std::ostringstream os;
-              os << "Invalid value: " << (*this)(row,col)
-                 << " in matrix row: " << row
-                 << " col: " << col
-                 << " file: " << file;
-              Error(os.str());
-            }
-          }
-        }
-      }
-
-      /**
-       *  **********************************************************************
-       *  **********************************************************************
-       *  @defgroup RESHAPE Matrix reshaping rutines
-       *  **********************************************************************
-       *  **********************************************************************
-       * @{
-       */
-
-      /**
-       *  @brief Removes one row from the matrix. The memory is not reallocated.
-       */
-      ThisType &
-      RemoveRow(size_t i);      
-
-      /** @} */
-
-      /**
-       *  **********************************************************************
-       *  **********************************************************************
-       *  @defgroup ACCESS Access functions and operators
-       *  **********************************************************************
-       *  **********************************************************************
-       * @{
-       */
-
-      /**
-       *  @brief Gives access to a specified matrix row without range check
-       *  @return Subvector object representing the row
-       */
-      inline const SubVector<_ElemT>
-      operator []  (size_t i) const
-      {
-        assert(i < mMRows);
-        return SubVector<_ElemT>(mpData + (i * mStride), Cols());
-      }
-
-      inline SubVector<_ElemT>
-      operator []  (size_t i)
-      {
-        assert(i < mMRows);
-        return SubVector<_ElemT>(mpData + (i * mStride), Cols());
-      }
-
-      /**
-       *  @brief Gives access to a specified matrix row without range check
-       *  @return pointer to the first field of the row
-       */
-      inline  _ElemT*
-      pRowData(size_t i) 
-      {
-        assert(i < mMRows);
-        return mpData + i * mStride;
-      }
-
-      /**
-       *  @brief Gives access to a specified matrix row without range check
-       *  @return pointer to the first field of the row (const version)
-       */
-      inline const _ElemT*
-      pRowData(size_t i) const
-      {
-        assert(i < mMRows);
-        return mpData + i * mStride;
-      }
-
-      /**
-       *  @brief Gives access to matrix elements (row, col)
-       *  @return reference to the desired field
-       */
-      inline _ElemT&
-		operator () (size_t r, size_t c)
-      { 
-#ifdef PARANOID
-        assert(r < mMRows && c < mMCols);
-#endif
-		return *(mpData + r * mStride + c); 
-	  }
-
-      /**
-       *  @brief Gives access to matrix elements (row, col)
-       *  @return pointer to the desired field (const version)
-       */
-      inline const _ElemT
-		operator () (size_t r, size_t c) const
-      { 
-#ifdef PARANOID
-        assert(r < mMRows && c < mMCols);
-#endif
-		return *(mpData + r * mStride + c); 
-	  }
-
-      /**
-       * @brief Returns a matrix sub-range
-       * @param ro Row offset
-       * @param r  Rows in range
-       * @param co Column offset
-       * @param c  Coluns in range
-       * See @c SubMatrix class for details
-       */
-      SubMatrix<_ElemT>
-      Range(const size_t    ro, const size_t    r,
-            const size_t    co, const size_t    c)
-      { return SubMatrix<_ElemT>(*this, ro, r, co, c); }
-
-      const SubMatrix<_ElemT>
-      Range(const size_t    ro, const size_t    r,
-            const size_t    co, const size_t    c) const
-      { return SubMatrix<_ElemT>(*this, ro, r, co, c); }
-      /** @} */
-
-
-      /**
-       *  **********************************************************************
-       *  **********************************************************************
-       *  @defgroup MATH ROUTINES
-       *  **********************************************************************
-       *  **********************************************************************
-       *  @{
-       **/
-
-      /**
-       *  @brief Returns sum of all elements
-       */
-      _ElemT&
-      Sum() const;
-
-      ThisType &
-      DotMul(const ThisType& a);
-
-      ThisType &
-      Scale(_ElemT alpha);
-
-      ThisType &
-      ScaleCols(const Vector<_ElemT> &scale); // Equivalent to (*this) = (*this) * diag(scale).
-
-      ThisType &
-      ScaleRows(const Vector<_ElemT> &scale); // Equivalent to (*this) = diag(scale) * (*this);
-
-      /// Sum another matrix rMatrix with this matrix
-      ThisType&
-      Add(const Matrix<_ElemT>& rMatrix);
-
-   
-      /// Sum scaled matrix rMatrix with this matrix
-      ThisType&
-      AddScaled(_ElemT alpha, const Matrix<_ElemT>& rMatrix);
-
-      /// Apply log to all items of the matrix
-      ThisType&
-      ApplyLog();
-
-      /**
-       * @brief Computes the determinant of this matrix
-       * @return Returns the determinant of a matrix
-       * @ingroup MATH
-       *
-       */
-      _ElemT LogAbsDeterminant(_ElemT *DetSign=NULL);
-
-
-      /**
-       *  @brief Performs matrix inplace inversion
-       */
-      ThisType &
-      Invert(_ElemT *LogDet=NULL, _ElemT *DetSign=NULL, bool inverse_needed=true);
-
-      /**
-       *  @brief Performs matrix inplace inversion in double precision, even if this object is not double precision.
-       */
-      ThisType &
-      InvertDouble(_ElemT *LogDet=NULL, _ElemT *DetSign=NULL, bool inverse_needed=true){
-        double LogDet_tmp, DetSign_tmp;
-        Matrix<double> dmat(*this); dmat.Invert(&LogDet_tmp, &DetSign_tmp, inverse_needed); if(inverse_needed) (*this).Copy(dmat); 
-        if(LogDet) *LogDet = LogDet_tmp; if(DetSign) *DetSign = DetSign_tmp;
-        return *this;
-      }
-
-
-      /**
-       *  @brief Inplace matrix transposition. Applicable only to square matrices
-       */
-      ThisType &
-      Transpose()
-      {
-        assert(Rows()==Cols());
-        size_t M=Rows();
-        for(size_t i=0;i<M;i++)
-          for(size_t j=0;j<i;j++){
-           _ElemT &a = (*this)(i,j), &b = (*this)(j,i);
-		   std::swap(a,b);
-        }
-		return *this;
-      }
-
-
-      
-
-
-      bool IsSymmetric(_ElemT cutoff = 1.0e-05) const;
-
-      bool IsDiagonal(_ElemT cutoff = 1.0e-05) const;
-
-      bool IsUnit(_ElemT cutoff = 1.0e-05) const;
-
-      bool IsZero(_ElemT cutoff = 1.0e-05) const;
-
-      _ElemT FrobeniusNorm() const; // sqrt of sum of square elements.
-
-      _ElemT LargestAbsElem() const; // largest absolute value.
-
-	
-      friend _ElemT TNet::TraceOfProduct<_ElemT>(const Matrix<_ElemT> &A, const Matrix<_ElemT> &B); // tr(A B)
-      friend _ElemT TNet::TraceOfProductT<_ElemT>(const Matrix<_ElemT> &A, const Matrix<_ElemT> &B); // tr(A B^T)==tr(A^T B)
-      friend class SubMatrix<_ElemT>; // so it can get around const restrictions on the pointer to mpData.
-
-      /** **********************************************************************
-       *  **********************************************************************
-       *  @defgroup BLAS_ROUTINES BLAS ROUTINES
-       *  @ingroup MATH
-       *  **********************************************************************
-       *  **********************************************************************
-       **/
-
-      ThisType &
-      BlasGer(const _ElemT alpha, const Vector<_ElemT>& rA, const Vector<_ElemT>& rB);
-
-      ThisType &
-	    Axpy(const _ElemT alpha, const Matrix<_ElemT> &rM, MatrixTrasposeType transA=NO_TRANS);
-
-      ThisType &
-      BlasGemm(const _ElemT alpha,
-               const ThisType& rA, MatrixTrasposeType transA,
-               const ThisType& rB, MatrixTrasposeType transB,
-               const _ElemT beta = 0.0);
-
-
-      /** @} */
-
-
-      /** **********************************************************************
-       *  **********************************************************************
-       *  @defgroup IO Input/Output ROUTINES
-       *  **********************************************************************
-       *  **********************************************************************
-       *  @{
-       **/
-
-      friend std::ostream &
-      operator << <> (std::ostream & out, const ThisType & m);
-	  	
-      void PrintOut(char *file);
-      void ReadIn(char *file);
-
-
-      bool
-      LoadHTK(const char* pFileName);
-
-      /** @} */
-
-
-    protected:
-//      inline void swap4b(void *a);
-//      inline void swap2b(void *a);
-
-
-    protected:
-      /// data memory area
-      _ElemT*   mpData;
-
-      /// these atributes store the real matrix size as it is stored in memory
-      /// including memalignment
-      size_t    mMCols;       ///< Number of columns
-      size_t    mMRows;       ///< Number of rows
-      size_t    mStride;      ///< true number of columns for the internal matrix.
-                              ///< This number may differ from M_cols as memory
-                              ///< alignment might be used
-
-#ifdef STK_MEMALIGN_MANUAL
-      /// data to be freed (in case of manual memalignment use, see Common.h)
-      _ElemT*   mpFreeData;
-#endif
-    }; // class Matrix
-
-    template<>  Matrix<float> &  Matrix<float>::Invert(float *LogDet, float *DetSign, bool inverse_needed); // state that we will implement separately for float and double.
-    template<>  Matrix<double> &  Matrix<double>::Invert(double *LogDet, double *DetSign, bool inverse_needed);
-
-
-
-  /** **************************************************************************
-   ** **************************************************************************
-   *  @brief Sub-matrix representation
-   *
-   *  This class provides a way to work with matrix cutouts in STK.
-   *
-   *
-   */
-  template<typename _ElemT>
-    class SubMatrix : public Matrix<_ElemT>
-    {
-    typedef SubMatrix<_ElemT>    ThisType;
-
-    public:
-      /// Constructor
-      SubMatrix(const Matrix<_ElemT>& rT, // Input matrix cannot be const because SubMatrix can change its contents.
-                const size_t    ro,
-                const size_t    r,
-                const size_t    co,
-                const size_t    c);
-
-
-      /// The destructor
-      ~SubMatrix<_ElemT>()
-      {
-#ifndef STK_MEMALIGN_MANUAL
-        Matrix<_ElemT>::mpData = NULL;
-#else
-        Matrix<_ElemT>::mpFreeData = NULL;
-#endif
-      }
-
-      /// Assign operator
-      ThisType& operator=(const ThisType& rSrc)
-      {
-        //std::cout << "[PERFORMing operator= SubMatrix&^2]" << std::flush;
-        this->mpData = rSrc.mpData;
-        this->mMCols = rSrc.mMCols;
-        this->mMRows = rSrc.mMRows;
-        this->mStride = rSrc.mStride;
-        this->mpFreeData = rSrc.mpFreeData;
-        return *this;
-      }
-
-   
-
-      /// Initializes matrix (if not done by constructor)
-      ThisType &
-      Init(const size_t r,
-           const size_t c, bool clear=true)
-      { Error("Submatrix cannot do Init"); return *this; }
-
-      /**
-       * @brief Dealocates the matrix from memory and resets the dimensions to (0, 0)
-       */
-      void
-      Destroy()
-      { Error("Submatrix cannot do Destroy"); }
-
-
-
-    };
-
-
-
-  //Create useful shortcuts
-  typedef Matrix<BaseFloat> BfMatrix;
-  typedef SubMatrix<BaseFloat> BfSubMatrix;
-
-  /**
-   * Function for summing matrices of different types
-   */
-  template<typename _ElemT, typename _ElemU>
-  void Add(Matrix<_ElemT>& rDst,  const Matrix<_ElemU>& rSrc) {
-    assert(rDst.Cols() == rSrc.Cols());
-    assert(rDst.Rows() == rSrc.Rows());
-
-    for(size_t i=0; i<rDst.Rows(); i++) {
-      const _ElemU* p_src = rSrc.pRowData(i);
-      _ElemT* p_dst = rDst.pRowData(i);
-      for(size_t j=0; j<rDst.Cols(); j++) {
-        *p_dst++ += (_ElemT)*p_src++;
-      }
-    }
-  }
-
-  /**
-   * Function for summing matrices of different types
-   */
-  template<typename _ElemT, typename _ElemU>
-  void AddScaled(Matrix<_ElemT>& rDst, const Matrix<_ElemU>& rSrc, _ElemT scale) {
-    assert(rDst.Cols() == rSrc.Cols());
-    assert(rDst.Rows() == rSrc.Rows());
-
-    Vector<_ElemT> tmp(rDst[0]);
-
-    for(size_t i=0; i<rDst.Rows(); i++) {
-      tmp.Copy(rSrc[i]);
-      rDst[i].BlasAxpy(scale, tmp);
-
-      /*
-      const _ElemU* p_src = rSrc.pRowData(i);
-      _ElemT* p_dst = rDst.pRowData(i);
-      for(size_t j=0; j<rDst.Cols(); j++) {
-        *p_dst++ += (_ElemT)(*p_src++) * scale;
-      }
-      */
-    }
-  }
-
-
-
-
-
-} // namespace STK
-
-
-
-//*****************************************************************************
-//*****************************************************************************
-// we need to include the implementation
-#include "Matrix.tcc"
-//*****************************************************************************
-//*****************************************************************************
-
-
-/******************************************************************************
- ******************************************************************************
- * The following section contains specialized template definitions
- * whose implementation is in Matrix.cc
- */
-
-
-//#ifndef TNet_Matrix_h
-#endif
diff --git a/tnet_io/KaldiLib/Matrix.tcc b/tnet_io/KaldiLib/Matrix.tcc
deleted file mode 100644
index f6ffb8f..0000000
--- a/tnet_io/KaldiLib/Matrix.tcc
+++ /dev/null
@@ -1,796 +0,0 @@
-
-/** @file Matrix.tcc
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-
-#ifndef TNet_Matrix_tcc
-#define TNet_Matrix_tcc
-
-//#pragma GCC system_header
-
-#include <cstdlib>
-#include <cmath>
-#include <cfloat>
-#include <fstream>
-#include <iomanip>
-#include <typeinfo>
-#include <algorithm>
-#include <limits>
-#include <vector>
-#include "Common.h"
-
-#ifndef _XOPEN_SOURCE
-  #define _XOPEN_SOURCE 600
-#endif
-
-
-#ifdef HAVE_ATLAS
-extern "C"{
-  #include <cblas.h>
-}
-#endif
-
-
-#include "Common.h"
-#include "Vector.h"
-namespace TNet
-{
-
-//******************************************************************************
-  template<typename _ElemT>
-  Matrix<_ElemT> &
-  Matrix<_ElemT>::
-  Init(const size_t rows,
-       const size_t cols, 
-       bool clear)
-  {
-    if(mpData != NULL) Destroy();
-    if(rows*cols == 0){
-      assert(rows==0 && cols==0);
-      mMRows=rows; 
-      mMCols=cols;
-#ifdef STK_MEMALIGN_MANUAL
-      mpFreeData=NULL;
-#endif
-      mpData=NULL;
-      return *this;
-    }
-    // initialize some helping vars
-    size_t  skip;
-    size_t  real_cols;
-    size_t  size;
-    void*   data;       // aligned memory block
-    void*   free_data;  // memory block to be really freed
-
-    // compute the size of skip and real cols
-    skip      = ((16 / sizeof(_ElemT)) - cols % (16 / sizeof(_ElemT))) % (16 / sizeof(_ElemT));
-    real_cols = cols + skip;
-    size      = rows * real_cols * sizeof(_ElemT);
-
-    // allocate the memory and set the right dimensions and parameters
-
-    if (NULL != (data = stk_memalign(16, size, &free_data)))
-    {
-      mpData        = static_cast<_ElemT *> (data);
-#ifdef STK_MEMALIGN_MANUAL
-      mpFreeData    = static_cast<_ElemT *> (free_data);
-#endif
-      mMRows      = rows;
-      mMCols      = cols;
-      mStride  = real_cols;
-    }
-    else
-    {
-      throw std::bad_alloc();
-    }
-    if(clear) Zero();
-    return *this;
-  } //
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    template<typename _ElemU>
-    Matrix<_ElemT> &
-    Matrix<_ElemT>::
-  Copy(const Matrix<_ElemU> & rM, MatrixTrasposeType Trans)
-    {
-      if(Trans==NO_TRANS){
-        assert(mMRows == rM.Rows() && mMCols == rM.Cols());
-        for(size_t i = 0; i < mMRows; i++) 
-          (*this)[i].Copy(rM[i]);
-        return *this;
-      } else {
-        assert(mMCols == rM.Rows() && mMRows == rM.Cols());        
-        for(size_t i = 0; i < mMRows; i++) 
-          for(size_t j = 0; j < mMCols; j++)
-            (*this)(i,j) = rM(j,i);
-        return *this;
-      }
-    }
-
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-  Matrix<_ElemT> &
-  Matrix<_ElemT>::
-  CopyVectorSplicedRows(const Vector<_ElemT> &rV, const size_t nRows, const size_t nCols) {
-    assert(rV.Dim() == nRows*nCols);
-    mMRows = nRows;
-    mMCols = nCols;
-    Init(nRows,nCols,true);
-    for(size_t r=0; r<mMRows; r++)
-      for(size_t c=0; c<mMCols; c++)
-        (*this)(r,c) = rV(r*mMCols + c);
-
-      return *this;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Matrix<_ElemT> &
-    Matrix<_ElemT>::
-  RemoveRow(size_t i)
-  {
-    assert(i < mMRows && "Access out of matrix");
-    for(size_t j = i + 1; j < mMRows; j++)
-      (*this)[j - 1].Copy((*this)[j]);
-    mMRows--;
-    return *this;
-  }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  // The destructor
-  template<typename _ElemT>
-    void
-    Matrix<_ElemT>::
-    Destroy()
-    {
-      // we need to free the data block if it was defined
-#ifndef STK_MEMALIGN_MANUAL
-      if (NULL != mpData) free(mpData);
-#else
-      if (NULL != mpData) free(mpFreeData);
-      mpFreeData = NULL;
-#endif
-
-      mpData = NULL;
-      mMRows = mMCols = 0;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-//  template<typename _ElemT>
-//  void
-//  Matrix<_ElemT>::
-//  VectorizeRows(Vector<_ElemT> &rV) {
-//#ifdef PARANIOD
-//    assert(rV.Dim() == mMRows*mMCols);
-//#endif
-//    for(size_t r=0; r<mMRows; r++) {
-//      rV.Range((r-1)*mMCols, mMCols).Copy((*this)[r]);
-//    }
-//  }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    bool
-    Matrix<_ElemT>::
-    LoadHTK(const char* pFileName)
-    {
-      HtkHeader htk_hdr;
-
-      FILE *fp = fopen(pFileName, "rb");
-      if(!fp)
-      {
-        return false;
-      }
-
-      read(fileno(fp), &htk_hdr, sizeof(htk_hdr));
-
-      swap4(htk_hdr.mNSamples);
-      swap4(htk_hdr.mSamplePeriod);
-      swap2(htk_hdr.mSampleSize);
-      swap2(htk_hdr.mSampleKind);
-
-      Init(htk_hdr.mNSamples, htk_hdr.mSampleSize / sizeof(float));
-
-      size_t i;
-      size_t j;
-      if (typeid(_ElemT) == typeid(float))
-      {
-        for (i=0; i< Rows(); ++i) {
-          read(fileno(fp), (*this).pRowData(i), Cols() * sizeof(float));
-
-          for(j = 0; j < Cols(); j++) {
-            swap4(((*this)(i,j)));
-          }
-        }
-      }
-      else
-      {
-        float *pmem = new (std::nothrow) float[Cols()];
-        if (!pmem)
-        {
-          fclose(fp);
-          return false;
-        }
-
-        for(i = 0; i < Rows(); i++) {
-          read(fileno(fp), pmem, Cols() * sizeof(float));
-
-          for (j = 0; j < Cols(); ++j) {
-            swap4(pmem[j]);
-            (*this)(i,j) = static_cast<_ElemT>(pmem[j]);
-          }
-        }
-        delete [] pmem;
-      }
-
-      fclose(fp);
-
-      return true;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Matrix<_ElemT> &
-    Matrix<_ElemT>::
-    DotMul(const ThisType& a)
-    {
-      size_t i;
-      size_t j;
-
-      for (i = 0; i < mMRows; ++i) {
-        for (j = 0; j < mMCols; ++j) {
-          (*this)(i,j) *= a(i,j);
-        }
-      }
-      return *this;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    _ElemT &
-    Matrix<_ElemT>::
-    Sum() const
-    {
-      double sum = 0.0;
-
-      for (size_t i = 0; i < Rows(); ++i) {
-        for (size_t j = 0; j < Cols(); ++j) {
-          sum += (*this)(i,j);
-        }
-      }
-
-      return sum;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Matrix<_ElemT>&
-    Matrix<_ElemT>::
-    Scale(_ElemT alpha)
-    {
-#if 0
-      for (size_t i = 0; i < Rows(); ++i) 
-        for (size_t j = 0; j < Cols(); ++j) 
-          (*this)(i,j) *= alpha;
-#else
-      for (size_t i = 0; i < Rows(); ++i) {
-        _ElemT* p_data = pRowData(i);
-        for (size_t j = 0; j < Cols(); ++j) {
-          *p_data++ *= alpha; 
-        }
-      }
-#endif
-      return *this;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Matrix<_ElemT>&
-    Matrix<_ElemT>::
-    ScaleRows(const Vector<_ElemT>& scale) // scales each row by scale[i].
-    {
-      assert(scale.Dim() == Rows());
-      size_t M = Rows(), N = Cols();
-
-      for (size_t i = 0; i < M; i++) {
-        _ElemT this_scale = scale(i);
-        for (size_t j = 0; j < N; j++) {
-          (*this)(i,j) *= this_scale;
-        }
-      }
-      return *this;
-     }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Matrix<_ElemT>&
-    Matrix<_ElemT>::
-    ScaleCols(const Vector<_ElemT>& scale) // scales each column by scale[i].
-    {
-      assert(scale.Dim() == Cols());
-      for (size_t i = 0; i < Rows(); i++) {
-        for (size_t j = 0; j < Cols(); j++) {
-          _ElemT this_scale = scale(j);
-          (*this)(i,j) *= this_scale;
-        }
-      }
-      return *this;
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-  Matrix<_ElemT>&
-  Matrix<_ElemT>::
-  Add(const Matrix<_ElemT>& rMatrix) 
-  {
-    assert(rMatrix.Cols() == Cols());
-    assert(rMatrix.Rows() == Rows());
-      
-#if 0
-    //this can be slow
-    for (size_t i = 0; i < Rows(); i++) {
-      for (size_t j = 0; j < Cols(); j++) {
-        (*this)(i,j) += rMatrix(i,j);
-      }
-    }
-#else
-    //this will be faster (but less secure)
-    for(size_t i=0; i<Rows(); i++) {
-      const _ElemT* p_src = rMatrix.pRowData(i);
-      _ElemT* p_dst = pRowData(i);
-      for(size_t j=0; j<Cols(); j++) {
-        *p_dst++ += *p_src++;
-      }
-    }
-#endif
-    return *this;
-  }
-
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-  Matrix<_ElemT>&
-  Matrix<_ElemT>::
-  AddScaled(_ElemT alpha, const Matrix<_ElemT>& rMatrix) 
-  {
-    assert(rMatrix.Cols() == Cols());
-    assert(rMatrix.Rows() == Rows());
-      
-#if 0
-    //this can be slow
-    for (size_t i = 0; i < Rows(); i++) {
-      for (size_t j = 0; j < Cols(); j++) {
-        (*this)(i,j) += rMatrix(i,j) * alpha;
-      }
-    }
-#else
-  /*
-    //this will be faster (but less secure)
-    for(size_t i=0; i<Rows(); i++) {
-      const _ElemT* p_src = rMatrix.pRowData(i);
-      _ElemT* p_dst = pRowData(i);
-      for(size_t j=0; j<Cols(); j++) {
-        *p_dst++ += *p_src++ * alpha;
-      }
-    }
-    */
-
-  //let's use BLAS
-  for(size_t i=0; i<Rows(); i++) {
-    (*this)[i].BlasAxpy(alpha, rMatrix[i]);
-  }
-#endif
-    return *this;
-  }
-
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-  Matrix<_ElemT>&
-  Matrix<_ElemT>::
-  ApplyLog()
-  {
-      
-#if 0
-    //this can be slow
-    for (size_t i = 0; i < Rows(); i++) {
-      for (size_t j = 0; j < Cols(); j++) {
-        (*this)(i,j) = += _LOG((*this)(i,j));
-      }
-    }
-#else
-    //this will be faster (but less secure)
-    for(size_t i=0; i<Rows(); i++) {
-      _ElemT* p_data = pRowData(i);
-      for(size_t j=0; j<Cols(); j++) {
-        *p_data = _LOG(*p_data);
-        p_data++;
-      }
-    }
-#endif
-    return *this;
-  }
-
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Matrix<_ElemT> &
-    Matrix<_ElemT>::
-    Zero()
-    {
-    for(size_t row=0;row<mMRows;row++)
-    memset(mpData + row*mStride, 0, sizeof(_ElemT)*mMCols);
-      return *this;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Matrix<_ElemT> &
-    Matrix<_ElemT>::
-    Unit()
-    {
-    for(size_t row=0;row<std::min(mMRows,mMCols);row++){
-    memset(mpData + row*mStride, 0, sizeof(_ElemT)*mMCols);
-    (*this)(row,row) = 1.0;
-    }
-      return *this;
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    void
-    Matrix<_ElemT>::
-    PrintOut(char* file)
-    {
-      FILE* f = fopen(file, "w");
-      unsigned i,j;
-      fprintf(f, "%dx%d\n", this->mMRows, this->mMCols);
-
-      for(i=0; i<this->mMRows; i++)
-      {
-        _ElemT*   row = (*this)[i];
-
-        for(j=0; j<this->mStride; j++){
-          fprintf(f, "%20.17f ",row[j]);
-        }
-        fprintf(f, "\n");
-      }
-
-      fclose(f);
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    void
-    Matrix<_ElemT>::
-    ReadIn(char* file)
-    {
-      FILE* f = fopen(file, "r");
-      int  i = 0;
-      int j = 0;
-      fscanf(f, "%dx%d\n", &i,&j);
-      fprintf(stderr, "%dx%d\n", i,j);
-
-      for(i=0; i<this->mMRows; i++)
-      {
-        _ElemT*   row = (*this)[i];
-
-        for(j=0; j<this->mStride; j++){
-          fscanf(f, "%f ",&row[j]);
-        }
-        //fprintf(f, "\n");
-      }
-
-      fclose(f);
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    void Save (std::ostream &rOut, const Matrix<_ElemT> &rM)
-    {
-      for (size_t i = 0; i < rM.Rows(); i++) {
-        for (size_t j = 0; j < rM.Cols(); j++) {
-          rOut << rM(i,j) << ' ';
-        }
-        rOut << '\n';
-      }
-      if(rOut.fail()) 
-        throw std::runtime_error("Failed to write matrix to stream");
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    std::ostream &
-    operator << (std::ostream & rOut, const Matrix<_ElemT> & rM)
-    {
-      rOut << "m " << rM.Rows() << ' ' << rM.Cols() << '\n';
-      Save(rOut, rM);
-      return rOut;
-    }
-
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    void Load (std::istream & rIn, Matrix<_ElemT> & rM)
-    {
-      if(MatrixVectorIostreamControl::Flags(rIn, ACCUMULATE_INPUT)) {
-        for (size_t i = 0; i < rM.Rows(); i++) {
-          std::streamoff pos = rIn.tellg();
-          for (size_t j = 0; j < rM.Cols(); j++) {
-            _ElemT tmp;
-            rIn >> tmp;
-            rM(i,j) += tmp;
-            if(rIn.fail()){
-              throw std::runtime_error("Failed to read matrix from stream.  File position is "+to_string(pos));
-            }        
-          }
-        }
-      } else {
-        for (size_t i = 0; i < rM.Rows(); i++) {
-          std::streamoff pos = rIn.tellg();
-          for (size_t j = 0; j < rM.Cols(); j++) {
-            rIn >> rM(i,j);
-            if(rIn.fail()){
-              throw std::runtime_error("Failed to read matrix from stream.  File position is "+to_string(pos));
-            }        
-
-          }
-        }
-      }
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    std::istream &
-    operator >> (std::istream & rIn, Matrix<_ElemT> & rM)
-    {
-      while(isascii(rIn.peek()) && isspace(rIn.peek())) rIn.get(); // eat up space.
-      if(rIn.peek() == 'm'){ // "new" format: m <nrows> <ncols> \n 1.0 0.2 4.3 ...
-        rIn.get();// eat up the 'm'.
-        long long int nrows=-1; rIn>>nrows; 
-        long long int ncols=-1; rIn>>ncols; 
-        if(rIn.fail()||nrows<0||ncols<0){ throw std::runtime_error("Failed to read matrix from stream: no size\n"); }
-
-        size_t nrows2 = size_t(nrows), ncols2 = size_t(ncols);
-        assert((long long int)nrows2 == nrows && (long long int)ncols2 == ncols);
-
-        if(rM.Rows()!=nrows2 || rM.Cols()!=ncols2) rM.Init(nrows2,ncols2);
-      }
-      Load(rIn,rM);
-      return rIn;
-    }
-
-
-
-  //****************************************************************************
-  //****************************************************************************
-  // Constructor
-  template<typename _ElemT>
-    SubMatrix<_ElemT>::
-    SubMatrix(const Matrix<_ElemT>& rT, // Matrix cannot be const because SubMatrix can change its contents.  Would have to have a ConstSubMatrix or something...
-              const size_t    ro,
-              const size_t    r,
-              const size_t    co,
-              const size_t    c)
-    {
-      assert(ro >= 0 && ro <= rT.Rows());
-      assert(co >= 0 && co <= rT.Cols());
-      assert(r  >  0 && r  <= rT.Rows() - ro);
-      assert(c  >  0 && c  <= rT.Cols() - co);
-      // point to the begining of window
-      Matrix<_ElemT>::mMRows = r;
-      Matrix<_ElemT>::mMCols = c;
-      Matrix<_ElemT>::mStride = rT.Stride();
-      Matrix<_ElemT>::mpData = rT.pData_workaround() + co + ro * rT.Stride();
-    }
-
-
-
-#ifdef HAVE_ATLAS
-
-  template<>
-    Matrix<float> &
-    Matrix<float>::
-   BlasGer(const float alpha, const Vector<float>& rA, const Vector<float>& rB);
-
-
-  template<>
-    Matrix<double> &
-    Matrix<double>::
-   BlasGer(const double alpha, const Vector<double>& rA, const Vector<double>& rB);
-
-
-  template<>
-    Matrix<float>&
-    Matrix<float>::
-    BlasGemm(const float alpha,
-              const Matrix<float>& rA, MatrixTrasposeType transA,
-              const Matrix<float>& rB, MatrixTrasposeType transB,
-       const float beta);
-
-  template<>
-   Matrix<double>&
-    Matrix<double>::
-    BlasGemm(const double alpha,
-              const Matrix<double>& rA, MatrixTrasposeType transA,
-              const Matrix<double>& rB, MatrixTrasposeType transB,
-       const double beta);
-
-  template<>
-    Matrix<float>&
-    Matrix<float>::
-         Axpy(const float alpha,
-              const Matrix<float>& rA, MatrixTrasposeType transA);
-
-  template<>
-    Matrix<double>&
-    Matrix<double>::
-         Axpy(const double alpha,
-              const Matrix<double>& rA, MatrixTrasposeType transA);
-
-  template <>  // non-member so automatic namespace lookup can occur.
-  double TraceOfProduct(const Matrix<double> &A, const Matrix<double> &B);
-
-  template <>  // non-member so automatic namespace lookup can occur.
-  double TraceOfProductT(const Matrix<double> &A, const Matrix<double> &B);
-
-  template <>  // non-member so automatic namespace lookup can occur.
-  float TraceOfProduct(const Matrix<float> &A, const Matrix<float> &B);
-
-  template <>  // non-member so automatic namespace lookup can occur.
-  float TraceOfProductT(const Matrix<float> &A, const Matrix<float> &B);
-
-  
-
-#else // HAVE_ATLAS
-      #error Routines in this section are not implemented yet without BLAS
-#endif // HAVE_ATLAS
-
-  template<class _ElemT>
-  bool
-  Matrix<_ElemT>::
-  IsSymmetric(_ElemT cutoff) const {
-  size_t R=Rows(), C=Cols();
-  if(R!=C) return false;
-  _ElemT bad_sum=0.0, good_sum=0.0;
-  for(size_t i=0;i<R;i++){
-    for(size_t j=0;j<i;j++){
-    _ElemT a=(*this)(i,j),b=(*this)(j,i), avg=0.5*(a+b), diff=0.5*(a-b);    
-    good_sum += fabs(avg); bad_sum += fabs(diff);
-    }
-    good_sum += fabs((*this)(i,i));
-  }
-  if(bad_sum > cutoff*good_sum) return false;
-  return true;
-  }
-
-  template<class _ElemT>
-  bool
-  Matrix<_ElemT>::
-  IsDiagonal(_ElemT cutoff) const{
-  size_t R=Rows(), C=Cols();
-  _ElemT bad_sum=0.0, good_sum=0.0;
-  for(size_t i=0;i<R;i++){
-    for(size_t j=0;j<C;j++){
-    if(i==j) good_sum += (*this)(i,j);
-    else bad_sum += (*this)(i,j);
-    }
-  }
-  return (!(bad_sum > good_sum * cutoff));
-  }
-
-  template<class _ElemT>
-  bool
-  Matrix<_ElemT>::
-  IsUnit(_ElemT cutoff) const {
-  size_t R=Rows(), C=Cols();
-  if(R!=C) return false;
-  _ElemT bad_sum=0.0;
-  for(size_t i=0;i<R;i++)
-    for(size_t j=0;j<C;j++)
-    bad_sum += fabs( (*this)(i,j) - (i==j?1.0:0.0));
-  return (bad_sum <= cutoff);
-  }
-
-  template<class _ElemT>
-  bool
-  Matrix<_ElemT>::
-  IsZero(_ElemT cutoff)const {
-  size_t R=Rows(), C=Cols();
-  _ElemT bad_sum=0.0;
-  for(size_t i=0;i<R;i++)
-    for(size_t j=0;j<C;j++)
-    bad_sum += fabs( (*this)(i,j) );
-  return (bad_sum <= cutoff);
-  }
-
-  template<class _ElemT>
-  _ElemT
-  Matrix<_ElemT>::
-  FrobeniusNorm() const{
-  size_t R=Rows(), C=Cols();
-  _ElemT sum=0.0;
-  for(size_t i=0;i<R;i++)
-    for(size_t j=0;j<C;j++){
-        _ElemT tmp = (*this)(i,j);
-    sum +=  tmp*tmp;
-      }
-    return sqrt(sum);
-  }
-
-  template<class _ElemT>
-  _ElemT
-  Matrix<_ElemT>::
-  LargestAbsElem() const{
-  size_t R=Rows(), C=Cols();
-  _ElemT largest=0.0;
-  for(size_t i=0;i<R;i++)
-    for(size_t j=0;j<C;j++)
-        largest = std::max(largest, (_ElemT)fabs((*this)(i,j)));
-    return largest;
-  }
-
-
-
-  // Uses SVD to compute the eigenvalue decomposition of a symmetric positive semidefinite 
-  //   matrix: 
-  // (*this) = rU * diag(rS) * rU^T, with rU an orthogonal matrix so rU^{-1} = rU^T.
-  // Does this by computing svd (*this) = U diag(rS) V^T ... answer is just U diag(rS) U^T.
-  // Throws exception if this failed to within supplied precision (typically because *this was not 
-  // symmetric positive definite).  
-  
-  
-
-  template<class _ElemT>
-  _ElemT
-  Matrix<_ElemT>::
-  LogAbsDeterminant(_ElemT *DetSign){
-    _ElemT LogDet;
-  Matrix<_ElemT> tmp(*this);
-  tmp.Invert(&LogDet, DetSign, false); // false== output not needed (saves some computation).
-    return LogDet;
-  }
-
-}// namespace TNet
-
-// #define TNet_Matrix_tcc
-#endif
diff --git a/tnet_io/KaldiLib/MlfStream.cc b/tnet_io/KaldiLib/MlfStream.cc
deleted file mode 100644
index a2f6478..0000000
--- a/tnet_io/KaldiLib/MlfStream.cc
+++ /dev/null
@@ -1,268 +0,0 @@
-#include "MlfStream.h"
-#include "Common.h"
-#include "Error.h"
-
-
-namespace TNet
-{
-  //******************************************************************************
-  LabelContainer::
-  ~LabelContainer()
-  {
-    while (!this->mLabelList.empty())
-    {
-      delete this->mLabelList.back();
-      this->mLabelList.pop_back();
-    }
-  }
-
-  //******************************************************************************
-  size_t
-  LabelContainer::
-  DirDepth(const std::string & rPath)
-  {
-    size_t depth     = 0;
-    size_t length    = rPath.length();
-    const char * s   = rPath.c_str();
-
-    for (size_t i = 0; i < length; i++)
-    {
-      if (*s == '/' || *s == '\\')
-      {
-        depth++;
-      }
-      s++;
-    }
-    return depth;
-  }
-
-
-  //******************************************************************************
-  void
-  LabelContainer::
-  Insert(const std::string &  rLabel,
-         std::streampos  Pos)
-  {
-    LabelRecord     ls;
-    size_t          depth;
-    LabelRecord     tmp_ls;
-
-    // we need to compute the depth of the label path if
-    // wildcard is used
-    // do we have a wildcard???
-    if (rLabel[0] == '*')
-    {
-      depth = this->DirDepth(rLabel);
-    }
-    else
-    {
-      depth = MAX_LABEL_DEPTH;
-    }
-
-    // perhaps we want to store the depth of the path in the label for the wildcards
-    // to work
-    this->mDepths.insert(depth);
-
-    // store the values
-    ls.mStreamPos       = Pos;
-    ls.miLabelListLimit = mLabelList.end();
-
-
-    if (mLabelList.begin() != mLabelList.end()) {
-      ls.miLabelListLimit--;
-    }
-
-    // if no wildcard chars, then we try to store in hash, otherwise store in 
-    // list
-    if (rLabel.find_first_of("*?%",1) == rLabel.npos)
-    {
-      if (!Find(rLabel, tmp_ls))
-      {
-        // look in the
-        this->mLabelMap[rLabel] = ls;
-      }
-      else {
-        ;
-        //Warning("More general definition found when inserting " + rLabel + " ... label: " + MatchedPattern());
-      }
-    }
-    else
-    {
-      this->mLabelList.push_back(new std::pair<std::string,LabelRecord>(rLabel, ls));
-    }
-  }
-
-
-  //******************************************************************************
-  bool
-  LabelContainer::
-  FindInHash(const std::string & rLabel, LabelRecord & rLS)
-  {
-    bool found = false;
-
-    std::string str;
-
-    // current depth within the str
-    DepthType  current_depth    = MAX_LABEL_DEPTH;
-
-    // current search position within the str
-    size_t     prev             = rLabel.size() + 1;
-
-    // we will walk through the set depts bacwards so we begin at the end and move
-    // to the front...
-    std::set<DepthType>::reverse_iterator ri    (this->mDepths.end());
-    std::set<DepthType>::reverse_iterator rlast (this->mDepths.begin());
-    LabelHashType::iterator               lab;
-
-    // we perform the search until we run to the end of the set or we find something
-    while ((!found) && (ri != rlast))
-    {
-      // we don't need to do anything with the string if the depth is set to
-      // max label depth since it contains no *
-      if (*ri == MAX_LABEL_DEPTH)
-      {
-        found = ((lab=this->mLabelMap.find(rLabel)) != this->mLabelMap.end());
-        if (found) str = rLabel;
-      }
-      // we will crop the string and put * in the begining and try to search
-      else
-      {
-        // we know that we walk backwards in the depths, so we need to first find
-        // the last / and
-        if (current_depth == MAX_LABEL_DEPTH)
-        {
-          if (*ri > 0)
-          {
-            // we find the ri-th / from back
-            for (DepthType i=1; (i <= *ri) && (prev != rLabel.npos); i++)
-            {
-              prev = rLabel.find_last_of("/\\", prev-1);
-            }
-          }
-          else
-          {
-            prev = 0;
-          }
-
-          // check if finding succeeded (prev == str.npos => failure, see STL)
-          if (prev != rLabel.npos)
-          {
-            // construct the new string beign sought for
-            str.assign(rLabel, prev, rLabel.size());
-            str = '*' + str;
-
-            // now we try to find
-            found = ((lab=this->mLabelMap.find(str)) != this->mLabelMap.end());
-
-            // say, that current depth is *ri
-            current_depth = *ri;
-          }
-          else
-          {
-            prev = rLabel.size() + 1;
-          }
-        }     // if (current_depth == MAX_LABEL_DEPTH)
-        else
-        {
-          // now we know at which / we are from the back, so we search forward now
-          // and we need to reach the ri-th /
-          while (current_depth > *ri)
-          {
-            // we try to find next /
-            if ((prev = rLabel.find_first_of("/\\", prev+1)) != rLabel.npos)
-              current_depth--;
-            else
-              return false;
-          }
-
-          // construct the new string beign sought for
-          str.assign(rLabel, prev, rLabel.size());
-          str = '*' + str;
-
-          // now we try to find
-          found = ((lab=this->mLabelMap.find(str)) != this->mLabelMap.end());
-        }
-      }
-
-      // move one element further (jump to next observed depth)
-      ri++;
-    } // while (run)
-
-    // some debug info
-    if (found)
-    {
-      rLS                   = lab->second;
-      this->mMatchedPattern = str;
-    }
-
-    return found;
-  }
-
-
-  //******************************************************************************
-  bool
-  LabelContainer::
-  FindInList(const std::string & rLabel, LabelRecord & rLS, bool limitSearch)
-  {
-
-    bool                      found = false;
-    std::string                    str;
-    LabelListType::iterator   lab   = mLabelList.begin();
-    LabelListType::iterator   limit;
-
-    if (limitSearch && (rLS.miLabelListLimit != mLabelList.end()))
-    {
-      limit = rLS.miLabelListLimit;
-      limit++;
-    }
-    else
-    {
-      limit = this->mLabelList.end();
-    }
-
-    // we perform sequential search until we run to the end of the list or we find
-    // something
-    while ((!found) && (lab != limit))
-    {
-      if (ProcessMask(rLabel, (*lab)->first, str))
-      {
-        found = true;
-      }
-      else
-      {
-        lab++;
-      }
-    } // while (run)
-
-    // some debug info
-    if (found)
-    {
-      rLS                       = (*lab)->second;
-      this->mMatchedPattern     = (*lab)->first;
-      this->mMatchedPatternMask = str;
-    }
-    return found;
-  }
-
-
-  //******************************************************************************
-  bool
-  LabelContainer::
-  Find(const std::string & rLabel, LabelRecord & rLS)
-  {
-    // try to find the label in the Hash
-    if (FindInHash(rLabel, rLS))
-    {
-      // we look in the list, but we limit the search.
-      FindInList(rLabel, rLS, true);
-      return true;
-    } //if (this->mLabelContainer.FindInHash(rLabel, label_stream))
-    else
-    {
-      // we didn't find it in the hash so we look in the list
-      return FindInList(rLabel, rLS);
-    }
-  }
-
-} // namespace TNet
-
diff --git a/tnet_io/KaldiLib/MlfStream.h b/tnet_io/KaldiLib/MlfStream.h
deleted file mode 100644
index d643f5c..0000000
--- a/tnet_io/KaldiLib/MlfStream.h
+++ /dev/null
@@ -1,639 +0,0 @@
-/** @file MlfStream.h
- *  This is an TNet C++ Library header.
- *
- *  The naming convention in this file coppies the std::* naming as well as STK
- */
-
-
-#ifndef STK_MlfStream_h
-#define STK_MlfStream_h
-
-#include <iostream>
-#include <vector>
-#include <map>
-#include <list>
-#include <set>
-
-
-namespace TNet
-{
-  class LabelRecord;
-  class LabelContainer;
-
-
-  /// this container stores the lables in linear order as they came
-  /// i.e. they cannot be hashed
-  typedef  std::list< std::pair<std::string,LabelRecord> *> LabelListType;
-
-  /// type of the container used to store the labels
-  typedef  std::map<std::string, LabelRecord>               LabelHashType;
-
-
-
-  /**
-   *  @brief Describes type of MLF definition
-   *
-   *  See HTK book for MLF structure. Terms used in TNet are
-   *  compatible with those in HTK book.
-   */
-  enum MlfDefType
-  {
-    MLF_DEF_UNKNOWN = 0,              ///< unknown definition
-    MLF_DEF_IMMEDIATE_TRANSCRIPTION,  ///< immediate transcription
-    MLF_DEF_SUB_DIR_DEF               ///< subdirectory definition
-  };
-
-
-
-  /** **************************************************************************
-   *  @brief Holds association between label and stream
-   */
-  class LabelRecord
-  {
-
-  public:
-    LabelRecord() : miLabelListLimit(NULL)
-    { }
-
-    ~LabelRecord()
-    { }
-
-    /// definition type
-    MlfDefType                mDefType;
-
-    /// position of the label in the stream
-    std::streampos            mStreamPos;
-
-    /**
-     *  @brief points to the current end of the LabelList
-     *
-     *  The reason for storing this value is to know when we inserted
-     *  a label into the hash. It is possible, that the hash label came
-     *  after list label, in which case the list label is prefered
-     */
-    LabelListType::iterator   miLabelListLimit;
-
-  };
-
-
-
-
-  /**
-   *  @brief Provides an interface to label hierarchy and searching
-   *
-   *  This class stores label files in a map structure. When a wildcard
-   *  convence is used, the class stores the labels in separate maps according
-   *  to level of wildcard abstraction. By level we mean the directory structure
-   *  depth.
-   */
-  class LabelContainer
-  {
-  public:
-    /// The constructor
-    LabelContainer() : mUseHashedSearch(true) {}
-
-    /// The destructor
-    ~LabelContainer();
-
-    /**
-     *  @brief Inserts new label to the hash structure
-     */
-    void
-    Insert(
-      const std::string &      rLabel,
-      std::streampos           Pos);
-
-
-    /**
-     *  @brief Looks for a record in the hash
-     */
-    bool
-    FindInHash(
-      const std::string&        rLabel,
-      LabelRecord&              rLS);
-
-    /**
-     *  @brief Looks for a record in the list
-     *  @param rLabel Label to look for
-     *  @param rLS    Structure to fill with found data
-     *  @param limitSearch If true @p rLS's @c mLabelListLimit gives the limiting position in the list
-     */
-    bool
-    FindInList(
-      const std::string&        rLabel,
-      LabelRecord&              rLS,
-      bool                      limitSearch = false);
-
-    /**
-     *  @brief Looks for a record
-     */
-    bool
-    Find(
-      const std::string &       rLabel,
-      LabelRecord &             rLS);
-
-    /**
-     *  @brief Returns the matched pattern
-     */
-    const std::string &
-    MatchedPattern() const
-    {
-      return mMatchedPattern;
-    }
-
-    /**
-     *  @brief Returns the matched pattern mask (%%%)
-     */
-    const std::string &
-    MatchedPatternMask() const
-    {
-      return mMatchedPatternMask;
-    }
-
-    /** 
-     * @brief Writes contents to stream (text)
-     * @param rOStream stream to write to
-     */
-    void
-    Write(std::ostream& rOStream);
-
-  private:
-    /// type used for directory depth notation
-    typedef  size_t                 DepthType;
-
-
-    /// this set stores depths of * labels observed at insertion
-    std::set<DepthType>             mDepths;
-
-    /// stores the labels
-    LabelHashType                   mLabelMap;
-    LabelListType                   mLabelList;
-
-    /// true if labels are to be sought by hashing function (fast) or by
-    /// sequential search (slow)
-    bool                            mUseHashedSearch;
-
-    /// if Find matches the label, this var stores the pattern that matched the
-    /// query
-    std::string                     mMatchedPattern;
-
-    /// if Find matches the label, this var stores the the masked characters.
-    /// The mask is given by '%' symbols
-    std::string                     mMatchedPatternMask;
-
-    /**
-     *  @brief Returns the directory depth of path
-     */
-    size_t
-    DirDepth(const std::string & path);
-
-
-  };
-
-
-  /** 
-   * @brief MLF output buffer definition
-   */
-  template<
-    typename _CharT, 
-    typename _Traits = std::char_traits<_CharT>,
-    typename _CharTA = std::allocator<_CharT>,
-    typename ByteT = char,
-    typename ByteAT = std::allocator<ByteT> 
-  > 
-    class BasicOMlfStreamBuf 
-    : public std::basic_streambuf<_CharT, _Traits> 
-    {
-    public:
-      // necessary typedefs ....................................................
-      typedef BasicOMlfStreamBuf<_CharT,_Traits,_CharTA,ByteT,ByteAT>
-                            this_type; 
-      typedef std::basic_ostream<_CharT, _Traits>& 
-                            OStreamReference;
-      typedef std::basic_streambuf<_CharT, _Traits>
-                            StreamBufType;
-      typedef _CharTA       char_allocator_type;
-      typedef _CharT        char_type;
-      typedef typename _Traits::int_type int_type;
-      typedef typename _Traits::pos_type pos_type;
-      typedef ByteT         byte_type;
-      typedef ByteAT        byte_allocator_type; 
-      typedef byte_type*    byte_buffer_type;
-      typedef std::vector<byte_type, byte_allocator_type > byte_vector_type;
-      typedef std::vector<char_type, char_allocator_type > char_vector_type;
-
-
-      BasicOMlfStreamBuf(OStreamReference rOStream, size_t bufferSize);
-
-      ~BasicOMlfStreamBuf();
-
-      // virtual functions inherited from basic_streambuf.......................
-      int 
-      sync();
-
-      /** 
-       * @brief Write character in the case of overflow
-       * @param c Character to be written.
-       * @return A value different than EOF (or traits::eof() for other traits) 
-       *         signals success.  If the function fails, either EOF 
-       *         (or traits::eof() for other traits) is returned or an 
-       *         exception is thrown.
-       */
-      int_type
-      overflow(int_type c = _Traits::eof());
-
-
-      // MLF specific functions ................................................
-      /** 
-       * @brief Creates a new MLF block
-       * @param rFileName filename to be opened
-       */
-      this_type*
-      Open(const std::string& rFileName);
-
-      /** 
-       * @brief Closes MLF block
-       */
-      void
-      Close();
-
-      /** 
-       * @brief Returns true if the MLF is now in open state
-       */
-      bool
-      IsOpen() const
-      { return mIsOpen; }
-
-      LabelContainer&
-      rLabels()
-      { return mLabels; }
-
-    private:
-      bool             mIsOpen;
-      char_type        mLastChar;
-      OStreamReference mOStream;
-      LabelContainer   mLabels;
-    }; // class BasicOMlfStreamBuf
-
-
-
-  /** 
-   * @brief MLF input buffer definition
-   */
-  template<
-    typename _CharT, 
-    typename _Traits = std::char_traits<_CharT>,
-    typename _CharTA = std::allocator<_CharT>,
-    typename ByteT = char,
-    typename ByteAT = std::allocator<ByteT> 
-  > 
-    class BasicIMlfStreamBuf 
-    : public std::basic_streambuf<_CharT, _Traits> 
-    {
-    private:
-      // internal automaton states
-      static const int IN_HEADER_STATE   = 0;
-      static const int OUT_OF_BODY_STATE = 1;
-      static const int IN_TITLE_STATE    = 2;
-      static const int IN_BODY_STATE     = 3;
-
-
-    public: // necessary typedefs ..............................................
-      typedef BasicIMlfStreamBuf<_CharT,_Traits,_CharTA,ByteT,ByteAT>
-                            this_type; 
-      typedef std::basic_istream<_CharT, _Traits>& IStreamReference;
-      typedef std::basic_streambuf<_CharT, _Traits>
-                            StreamBufType;
-      typedef _CharTA       char_allocator_type;
-      typedef _CharT        char_type;
-      typedef typename _Traits::int_type int_type;
-      typedef typename _Traits::pos_type pos_type;
-      typedef ByteT         byte_type;
-      typedef ByteAT        byte_allocator_type; 
-      typedef byte_type*    byte_buffer_type;
-      typedef std::vector<byte_type, byte_allocator_type > byte_vector_type;
-      typedef std::vector<char_type, char_allocator_type > char_vector_type;
-
-
-    public:
-      // constructors and destructors ..........................................
-      BasicIMlfStreamBuf(IStreamReference rIStream, size_t bufferSize = 1024);
-
-      ~BasicIMlfStreamBuf();
-
-      // virtual functions inherited from basic_streambuf.......................
-      /** 
-       * @brief Get character in the case of underflow
-       * 
-       * @return The new character available at the get pointer position, if 
-       *         any. Otherwise, traits::eof() is returned.  
-       */
-      int_type
-      underflow();
-
-
-      // MLF specific functions ................................................
-      /** 
-       * @brief Creates a new MLF block
-       * @param rFileName filename to be opened
-       */
-      this_type*
-      Open(const std::string& rFileName);
-
-      /** 
-       * @brief Closes MLF block
-       */
-      this_type*
-      Close();
-
-      /** 
-       * @brief Returns true if the MLF is now in open state
-       */
-      bool
-      IsOpen() const
-      { return mIsOpen; }
-
-      /** 
-       * @brief Parses the stream (if possible) and stores positions to the 
-       *        label titles
-       */
-      void
-      Index();
-
-	bool
-      IsHashed() const
-      { return mIsHashed; }
-
-      /** 
-       * @brief Jumps to next label definition
-       * @param rName std::string to be filled with the label name
-       * @return true on success
-       *
-       * The procedure automatically tries to hash the labels.
-       */
-      bool
-      JumpToNextDefinition(std::string& rName);
-
-      /** 
-       * @brief Returns reference to the base stream
-       * @return reference to the stream
-       *
-       */
-      IStreamReference
-      GetBaseStream() 
-      {
-        return mIStream;
-      }
-
-    private: // auxillary functions ............................................
-      /** 
-       * @brief Fills the line buffer with next line and updates the internal
-       * state of the finite automaton
-       */
-      void
-      FillLineBuffer();
-
-
-    private: // atributes ......................................................
-      // some flags
-      bool              mIsOpen;
-      bool              mIsHashed;
-      bool              mIsEof;
-
-      /// internal state of the finite automaton
-      int               mState;
-
-      IStreamReference  mIStream;
-      LabelContainer    mLabels;
-
-      std::vector<char_type>  mLineBuffer;
-    }; // class BasicIMlfStreamBuf
-
-
-
-
-  /** 
-   * @brief Base class with type-independent members for the Mlf Output 
-   *        Stram class
-   *
-   * This is a derivative of the basic_ios class. We derive it as we need 
-   * to override some member functions
-   */
-  template<
-    typename Elem, 
-    typename Tr = std::char_traits<Elem>,
-    typename ElemA = std::allocator<Elem>,
-    typename ByteT = char,
-    typename ByteAT = std::allocator<ByteT>
-  >	
-    class BasicOMlfStreamBase
-    : virtual public std::basic_ios<Elem,Tr>
-    {
-    public:
-      typedef std::basic_ostream<Elem, Tr>& OStreamReference;
-      typedef BasicOMlfStreamBuf <
-        Elem,Tr,ElemA,ByteT,ByteAT> OMlfStreamBufType;
-
-      /** 
-       * @brief constructor
-       * 
-       * @param rOStream user defined output stream 
-       */
-      BasicOMlfStreamBase(OStreamReference rOStream, 
-          size_t bufferSize)
-      : mBuf(rOStream, bufferSize)
-      { this->init(&mBuf); };
-      
-      /** 
-       * @brief Returns a pointer to the buffer object for this stream
-       */
-      OMlfStreamBufType* 
-      rdbuf() 
-      { return &mBuf; };
-
-    private:
-      OMlfStreamBufType mBuf;
-    };  
-
-
-  template<
-    typename Elem, 
-    typename Tr = std::char_traits<Elem>,
-    typename ElemA = std::allocator<Elem>,
-    typename ByteT = char,
-    typename ByteAT = std::allocator<ByteT>
-  >	
-    class BasicIMlfStreamBase
-    : virtual public std::basic_ios<Elem,Tr>
-    {
-    public:
-      typedef std::basic_istream<Elem, Tr>& IStreamReference;
-      typedef BasicIMlfStreamBuf <
-        Elem,Tr,ElemA,ByteT,ByteAT> IMlfStreamBufType;
-
-      BasicIMlfStreamBase( IStreamReference rIStream,
-          size_t bufferSize)
-      : mBuf(rIStream, bufferSize)
-      { this->init(&mBuf ); };
-      
-      IMlfStreamBufType* 
-      rdbuf() 
-      { return &mBuf; };
-
-      IStreamReference
-      GetBaseStream()
-      { return mBuf.GetBaseStream(); }
-
-    private:
-      IMlfStreamBufType mBuf;
-    };
-
-
-  template<
-    typename Elem, 
-    typename Tr = std::char_traits<Elem>,
-    typename ElemA = std::allocator<Elem>,
-    typename ByteT = char,
-    typename ByteAT = std::allocator<ByteT>
-  >
-    class BasicOMlfStream 
-    : public BasicOMlfStreamBase<Elem,Tr,ElemA,ByteT,ByteAT>, 
-      public std::basic_ostream<Elem,Tr>
-    {
-    public:
-      typedef BasicOMlfStreamBase< Elem,Tr,ElemA,ByteT,ByteAT> 
-                                          BasicOMlfStreamBaseType;
-      typedef std::basic_ostream<Elem,Tr> OStreamType;
-      typedef OStreamType&                OStreamReference;
-
-      BasicOMlfStream(OStreamReference rOStream, size_t bufferSize = 32)
-      : BasicOMlfStreamBaseType(rOStream, bufferSize), 
-        OStreamType(BasicOMlfStreamBaseType::rdbuf())
-      { }
-
-      /** 
-       * @brief Destructor closes the stream
-       */
-      ~BasicOMlfStream()
-      { }
-
-
-      /** 
-       * @brief Creates a new MLF block
-       * @param rFileName filename to be opened
-       */
-      void
-      Open(const std::string& rFileName)
-      { BasicOMlfStreamBaseType::rdbuf()->Open(rFileName); }
-
-      /** 
-       * @brief Closes MLF block
-       */
-      void
-      Close()
-      { BasicOMlfStreamBaseType::rdbuf()->Close(); }
-
-      /** 
-       * @brief Returns true if the MLF is now in open state
-       */
-      bool
-      IsOpen() const
-      { return BasicOMlfStreamBaseType::rdbuf()->IsOpen(); }
-
-      /** 
-       * @brief Accessor to the label container
-       * @return Reference to the label container
-       */
-      LabelContainer&
-      rLabels()
-      { return BasicOMlfStreamBaseType::rdbuf()->rLabels(); }
-    };
-
-
-
-  template<
-    typename Elem, 
-    typename Tr = std::char_traits<Elem>,
-    typename ElemA = std::allocator<Elem>,
-    typename ByteT = char,
-    typename ByteAT = std::allocator<ByteT>
-  >	
-    class BasicIMlfStream 
-    : public BasicIMlfStreamBase<Elem,Tr,ElemA,ByteT,ByteAT>, 
-      public std::basic_istream<Elem,Tr>
-    {
-    public:
-      typedef BasicIMlfStreamBase <Elem,Tr,ElemA,ByteT,ByteAT> 
-                                          BasicIMlfStreamBaseType;
-      typedef std::basic_istream<Elem,Tr> IStreamType;
-      typedef IStreamType&                IStreamReference;
-      typedef unsigned char               byte_type;
-
-      BasicIMlfStream(IStreamReference rIStream, size_t bufferSize = 32)
-      : BasicIMlfStreamBaseType(rIStream, bufferSize), 
-        IStreamType(BasicIMlfStreamBaseType::rdbuf())
-      {};
-
-
-      /** 
-       * @brief Creates a new MLF block
-       * @param rFileName filename to be opened
-       */
-      void
-      Open(const std::string& rFileName)
-      { 
-        std::basic_streambuf<Elem, Tr>* p_buf;
-
-        p_buf = BasicIMlfStreamBaseType::rdbuf()->Open(rFileName);
-
-        if (NULL == p_buf) {
-          IStreamType::clear(IStreamType::rdstate() | std::ios::failbit);
-        }
-        else {
-          IStreamType::clear();
-        }
-      }
-
-      /** 
-       * @brief Closes MLF block.
-       * In fact, nothing is done
-       */
-      void 
-      Close()
-      { 
-        if (NULL == BasicIMlfStreamBaseType::rdbuf()->Close()) {
-          IStreamType::clear(IStreamType::rdstate() | std::ios::failbit);
-        }
-      }
-
-      void
-      Index()
-      { BasicIMlfStreamBaseType::rdbuf()->Index(); }
-
-      bool
-	  IsHashed() const
-      { return BasicIMlfStreamBaseType::rdbuf()->IsHashed(); }
-
-    };
-
-
-
-  // MAIN TYPEDEFS..............................................................
-  typedef BasicOMlfStream<char>     OMlfStream;
-  typedef BasicOMlfStream<wchar_t>  WOMlfStream;
-  typedef BasicIMlfStream<char>     IMlfStream;
-  typedef BasicIMlfStream<wchar_t>  WIMlfStream;
-
-
-#ifdef PATH_MAX
-  const size_t MAX_LABEL_DEPTH = PATH_MAX;
-#else
-  const size_t MAX_LABEL_DEPTH = 1024;
-#endif
-
-
-} // namespace TNet
-
-#include "MlfStream.tcc"
-
-#endif
diff --git a/tnet_io/KaldiLib/MlfStream.tcc b/tnet_io/KaldiLib/MlfStream.tcc
deleted file mode 100644
index 8978545..0000000
--- a/tnet_io/KaldiLib/MlfStream.tcc
+++ /dev/null
@@ -1,517 +0,0 @@
-#ifndef STK_MlfStream_tcc
-#define STK_MlfStream_tcc
-
-#include <algorithm>
-
-#include "Common.h"
-#include "StkMatch.h"
-
-namespace TNet
-{
-  //****************************************************************************
-  //****************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits,
-    typename _CharTA,
-    typename ByteT,
-    typename ByteAT
-  > 
-    BasicOMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>::
-    BasicOMlfStreamBuf(OStreamReference rOStream, size_t bufferSize)
-    : mIsOpen(false), mOStream(rOStream)
-    { }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits,
-    typename _CharTA,
-    typename ByteT,
-    typename ByteAT
-  > 
-    BasicOMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>::
-    ~BasicOMlfStreamBuf()
-    {
-      mOStream.flush();
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits,
-    typename _CharTA,
-    typename ByteT,
-    typename ByteAT
-  > 
-    int 
-    BasicOMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>::
-    sync()
-    {
-      mOStream.flush();
-      return 0;
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits,
-    typename _CharTA,
-    typename ByteT,
-    typename ByteAT
-  > 
-    typename _Traits::int_type 
-    BasicOMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>::
-    overflow(typename _Traits::int_type c)
-    {
-      // we don't use buffer here... 
-      if (mIsOpen) {
-        if (_Traits::eof() == c) {
-          return _Traits::not_eof(c);
-        }
-        // only pass the character to the stream
-        mOStream.rdbuf()->sputc(c);
-
-        // remember last char (in case we want to close)
-        mLastChar = c;
-
-        return c;
-      }
-      else {
-        return _Traits::eof();
-      }
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits,
-    typename _CharTA,
-    typename ByteT,
-    typename ByteAT
-  > 
-    void 
-    BasicOMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>::
-    Close()
-    {
-      // if last character was not EOL, we need to insert it
-      if (mLastChar != '\n') {
-        mOStream.put('\n');
-      }
-      mOStream << ".\n";
-
-      // flush the stream and declare the stream closed
-      mOStream.flush();
-      mIsOpen = false;
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits,
-    typename _CharTA,
-    typename ByteT,
-    typename ByteAT
-  > 
-    BasicOMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT> *
-    BasicOMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>::
-    Open(const std::string& rFileName)
-    {
-      // retreive position
-      std::streampos pos = mOStream.tellp();
-
-      // write the initial "filename" in parantheses
-      mOStream << '"' << rFileName << '"' << std::endl;
-      mLastChar = '\n';
-
-      // return NULL if we canot open
-      if (!mOStream.good()) {
-        return NULL;
-      }
-
-      // if ok, store the name position
-      if (-1 != pos) {
-        pos = mOStream.tellp();
-        mLabels.Insert(rFileName, pos);
-      }
-
-      // set open flag and return this
-      mIsOpen = true;
-      return this;
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  // BasicIMlfStreamBuf section
-  //
-  //****************************************************************************
-  //****************************************************************************
-
-  //****************************************************************************
-  //****************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits,
-    typename _CharTA,
-    typename ByteT,
-    typename ByteAT
-  > 
-    BasicIMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>::
-    BasicIMlfStreamBuf(IStreamReference rIStream, size_t bufferSize)
-    : mIsOpen(false), mIsHashed(false), mIsEof(true), mState(IN_HEADER_STATE), 
-      mIStream(rIStream), mLineBuffer()
-    {
-      // we reserve some place for the buffer...
-      mLineBuffer.reserve(bufferSize);
-
-      //StreamBufType::setg(mpBuffer, mpBuffer + bufferSize, mpBuffer + bufferSize);
-      StreamBufType::setg(&(mLineBuffer.front()), &(mLineBuffer.back()), &(mLineBuffer.back()));
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits,
-    typename _CharTA,
-    typename ByteT,
-    typename ByteAT
-  > 
-    BasicIMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>::
-    ~BasicIMlfStreamBuf()
-    { 
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits,
-    typename _CharTA,
-    typename ByteT,
-    typename ByteAT
-  > 
-    void
-    BasicIMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>::
-    Index()
-    {
-      // retreive position
-      std::streampos orig_pos   = mIStream.tellg();
-      int      orig_state = mState;
-
-      // for streams like stdin, pos will by definition be -1, so we can only 
-      // rely on sequential access and cannot hash it.
-      if (-1 != orig_pos) {
-        std::string aux_name;
-        // we will constantly jump to next definition. the function automatically
-        // hashes the stream if possible
-        while (JumpToNextDefinition(aux_name)) 
-        { }
-
-        // move to the original position
-        mIStream.clear();
-        mIStream.seekg(orig_pos);
-        mState = orig_state;
-
-        // set as hashed
-        mIsHashed=true;
-      }
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits,
-    typename _CharTA,
-    typename ByteT,
-    typename ByteAT
-  > 
-    bool
-    BasicIMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>::
-    JumpToNextDefinition(std::string& rName)
-    {
-      if (!mIStream.good()) {
-        return false;
-      }
-
-      // if we can, we will try to index the label
-      std::streampos pos = mIStream.tellg();
-
-      // we might be at a definition already, so first move one line further
-      FillLineBuffer();
-
-      // read lines till we get to definition again
-      while (mIStream.good() && mState != IN_TITLE_STATE) {
-        FillLineBuffer();
-      }
-
-      // decide what happened
-      if (IN_TITLE_STATE == mState) {
-        // if we can, we will try to index the label
-        pos = mIStream.tellg();
-
-        if (pos != static_cast<const std::streampos>(-1)) {
-        // if (pos !=std::string::npos) {  // This line does not work under MinGW
-          std::string line_buffer(mLineBuffer.begin(), mLineBuffer.end());
-          TNet::ParseHTKString(line_buffer, rName);
-          mLabels.Insert(rName, pos);
-        }
-
-        return true;
-      }
-      else {
-        // we have been hashing all the way through so we know that if this is 
-        // is the EOF, we are done hashing this stream
-        if (pos != static_cast<const std::streampos>(-1)) {
-          mIsHashed = true;
-        }
-
-        // we are not in body state, so we just return false
-        return false;
-      }
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits,
-    typename _CharTA,
-    typename ByteT,
-    typename ByteAT
-  > 
-    BasicIMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>*
-    BasicIMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>::
-    Close()
-    {
-      if (!mIsOpen) {
-        mIsEof = true;
-        return NULL;
-      }
-      else {
-        // if we try to close while in the body, we need to reach the end
-        if (mState == IN_BODY_STATE) {
-          while (mState == IN_BODY_STATE) {
-            FillLineBuffer();
-          }
-        }
-
-        // disable buffer mechanism
-        StreamBufType::setg(&(mLineBuffer.front()), &(mLineBuffer.front()), 
-            &(mLineBuffer.front()));
-
-        mIsEof  = true;
-        mIsOpen = false;
-
-        return this;
-      }
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits,
-    typename _CharTA,
-    typename ByteT,
-    typename ByteAT
-  > 
-    BasicIMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>*
-    BasicIMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>::
-    Open(const std::string& rFileName)
-    {
-      BasicIMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>* ret_val = NULL;
-
-      // this behavior is compatible with ifstream
-      if (mIsOpen) {
-        Close();
-        return NULL;
-      }
-
-      // retreive position
-      std::streampos pos = mIStream.tellg();
-      LabelRecord label_record;
-
-      // for streams like stdin, pos will by definition be -1, so we can only 
-      // rely on sequential access. At this place, we decide what to do
-      if ((-1 != pos) && (mLabels.Find(rFileName, label_record))) {
-        mIStream.seekg(label_record.mStreamPos);
-        mState = IN_TITLE_STATE;
-
-        // we don't want the other stream to be bad, so we transfer the 
-        // flagbits to this stream
-        if (!mIStream.good()) {
-          mIStream.clear();
-          mIsOpen = false;
-          ret_val = NULL;
-        }
-        else {
-          mIsOpen = true;
-          mIsEof = false;
-          ret_val = this;
-        }
-      }
-
-      // we don't have sequential stream and we didn't find the label, but
-      // we are hashed, so we can be sure, that we failed
-      else if ((-1 != pos) && mIsHashed) {
-        mIsOpen = false;
-        ret_val = NULL;
-      }
-
-      // we either have sequential stream or didn't find anything, but we can 
-      // still try to sequentially go and look for it
-      else {
-        bool        found = false;
-        std::string aux_name;
-        std::string aux_name2;
-
-        while ((!found) && JumpToNextDefinition(aux_name)) {
-          if (TNet::ProcessMask(rFileName, aux_name, aux_name2)) {
-            mIsOpen = true;
-            mIsEof  = false;
-            found   = true;
-            ret_val = this;
-          }
-        }
-
-        if (!found) {
-          mIsOpen = false;
-          ret_val = NULL;
-        }
-      }
-
-      return ret_val;
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits,
-    typename _CharTA,
-    typename ByteT,
-    typename ByteAT
-  > 
-    typename _Traits::int_type
-    BasicIMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>::
-    underflow()
-    {
-      // we don't do anything if EOF
-      if (mIsEof) {
-        StreamBufType::setg(&(mLineBuffer.front()), &(mLineBuffer.front()), 
-            &(mLineBuffer.front()));
-        return _Traits::eof();
-      }
-
-      // read from buffer if we can
-      if (StreamBufType::gptr() && (StreamBufType::gptr() < StreamBufType::egptr())) {
-        return _Traits::not_eof(*StreamBufType::gptr());
-      }
-
-      // might happen that stream is in !good state
-      if (!mIStream.good()) {
-        mIsEof = true;
-        StreamBufType::setg(&(mLineBuffer.front()), &(mLineBuffer.front()), 
-            &(mLineBuffer.front()));
-        return _Traits::eof();
-      }
-
-      // fill the line buffer and update my state
-      FillLineBuffer();
-
-      // if the whole line is just period or it's eof, declare EOF
-      if (mState == OUT_OF_BODY_STATE) {
-        mIsEof = true;
-        StreamBufType::setg(&(mLineBuffer.front()), &(mLineBuffer.front()), 
-            &(mLineBuffer.front()));
-        return _Traits::eof();
-      }
-
-      // restore the buffer mechanism
-      StreamBufType::setg(&(mLineBuffer.front()), &(mLineBuffer.front()),
-          &(mLineBuffer.back()) + 1);
-
-      return *StreamBufType::gptr();
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits,
-    typename _CharTA,
-    typename ByteT,
-    typename ByteAT
-  > 
-    void
-    BasicIMlfStreamBuf<_CharT, _Traits, _CharTA, ByteT, ByteAT>::
-    FillLineBuffer()
-    {
-      // reset line buffer
-      size_t capacity = mLineBuffer.capacity();
-      mLineBuffer.clear();
-      mLineBuffer.reserve(capacity);
-
-      // read one line into buffer
-      int c;
-      while ((c = mIStream.get()) != '\n' && c != _Traits::eof()) {
-        mLineBuffer.push_back(char(c));
-      }
-
-      // we want to be able to pass last eol symbol
-      if (c == '\n') {
-        mLineBuffer.push_back(char(c));
-      }
-
-      // we will decide where we are
-      switch (mState) {
-        case IN_HEADER_STATE:
-
-        case OUT_OF_BODY_STATE:
-          if (mLineBuffer[0] != '#') {
-            mState = IN_TITLE_STATE;
-          }
-          break;
-
-        case IN_TITLE_STATE:
-          if (mLineBuffer[0] == '.' && (mLineBuffer.back() == '\n' || mIStream.eof())) {
-            mState = OUT_OF_BODY_STATE;
-          }
-          else {
-            mState = IN_BODY_STATE;
-          }
-          break;
-
-        case IN_BODY_STATE:
-          // period or EOF will end the file
-          if (mLineBuffer[0] == '.' && (mLineBuffer.back() == '\n' || mIStream.eof())) {
-            mState = OUT_OF_BODY_STATE;
-          }
-          if (mLineBuffer.size() == 0) {
-            mState = OUT_OF_BODY_STATE;
-          }
-          break;
-      }
-    }
-} // namespace TNet
-
-
-#endif // STK_MlfStream_tcc
diff --git a/tnet_io/KaldiLib/StkMatch.cc b/tnet_io/KaldiLib/StkMatch.cc
deleted file mode 100644
index 4ff4b18..0000000
--- a/tnet_io/KaldiLib/StkMatch.cc
+++ /dev/null
@@ -1,582 +0,0 @@
-/*
- EPSHeader
-
-   File: filmatch.c
-   Author: J. Kercheval
-   Created: Thu, 03/14/1991  22:22:01
-*/
-
-/*
- EPSRevision History
-   O. Glembek    Thu, 03/11/2005  01:58:00  Added Mask extraction support (char % does this)
-   J. Kercheval  Wed, 02/20/1991  22:29:01  Released to Public Domain
-   J. Kercheval  Fri, 02/22/1991  15:29:01  fix '\' bugs (two :( of them)
-   J. Kercheval  Sun, 03/10/1991  19:31:29  add error return to matche()
-   J. Kercheval  Sun, 03/10/1991  20:11:11  add is_valid_pattern code
-   J. Kercheval  Sun, 03/10/1991  20:37:11  beef up main()
-   J. Kercheval  Tue, 03/12/1991  22:25:10  Released as V1.1 to Public Domain
-   J. Kercheval  Thu, 03/14/1991  22:22:25  remove '\' for DOS file parsing
-   J. Kercheval  Thu, 03/28/1991  20:58:27  include filmatch.h
-*/
-
-/*
-   Wildcard Pattern Matching
-*/
-
-
-#include "StkMatch.h"
-#include "Common.h"
-
-namespace TNet
-{
-  //#define TEST
-  static int matche_after_star (register const char *pattern, register const char *text, register char *s);
-  // following function is not defined or used.
-  // static int fast_match_after_star (register const char *pattern, register const char *text);
-
-  /*----------------------------------------------------------------------------
-  *
-  * Return true if PATTERN has any special wildcard characters
-  *
-  ----------------------------------------------------------------------------*/
-
-  bool is_pattern (const char *p)
-  {
-      while ( *p ) {
-          switch ( *p++ ) {
-              case '?':
-              case '*':
-              case '%':
-              case '[':
-                return true;
-          }
-      }
-      return false;
-  }
-
-
-  /*----------------------------------------------------------------------------
-  *
-  * Return true if PATTERN has is a well formed regular expression according
-  * to the above syntax
-  *
-  * error_type is a return code based on the type of pattern error.  Zero is
-  * returned in error_type if the pattern is a valid one.  error_type return
-  * values are as follows:
-  *
-  *   PATTERN_VALID - pattern is well formed
-  *   PATTERN_RANGE - [..] construct has a no end range in a '-' pair (ie [a-])
-  *   PATTERN_CLOSE - [..] construct has no end bracket (ie [abc-g )
-  *   PATTERN_EMPTY - [..] construct is empty (ie [])
-  *
-  ----------------------------------------------------------------------------*/
-
-  bool is_valid_pattern (const char *p, int *error_type)
-  {
-
-  /* init error_type */
-  *error_type = PATTERN_VALID;
-
-    /* loop through pattern to EOS */
-    while ( *p )
-    {
-      /* determine pattern type */
-      switch ( *p )
-      {
-        /* the [..] construct must be well formed */
-        case '[':
-        {
-          p++;
-
-          /* if the next character is ']' then bad pattern */
-          if ( *p == ']' ) {
-            *error_type = PATTERN_EMPTY;
-            return false;
-          }
-
-          /* if end of pattern here then bad pattern */
-          if ( !*p )
-          {
-            *error_type = PATTERN_CLOSE;
-            return false;
-          }
-
-          /* loop to end of [..] construct */
-          while ( *p != ']' )
-          {
-            /* check for literal escape */
-            if ( *p == '\\' )
-            {
-                p++;
-
-                /* if end of pattern here then bad pattern */
-                if ( !*p++ ) {
-                    *error_type = PATTERN_ESC;
-                    return false;
-                }
-            }
-            else
-                p++;
-
-            /* if end of pattern here then bad pattern */
-            if ( !*p )
-            {
-              *error_type = PATTERN_CLOSE;
-              return false;
-            }
-
-            /* if this a range */
-            if ( *p == '-' )
-            {
-              /* we must have an end of range */
-              if ( !*++p || *p == ']' )
-              {
-                *error_type = PATTERN_RANGE;
-                return false;
-              }
-              else
-              {
-
-                /* check for literal escape */
-                if ( *p == '\\' )
-                    p++;
-
-                /* if end of pattern here then bad pattern */
-                if ( !*p++ )
-                {
-                    *error_type = PATTERN_ESC;
-                    return false;
-                }
-              }
-            }
-          }
-          break;
-        } //case '[':
-
-
-        /* all other characters are valid pattern elements */
-        case '*':
-        case '?':
-        case '%':
-        default:
-          p++;                              /* "normal" character */
-          break;
-      } // switch ( *p )
-    } // while ( *p )
-
-    return true;
-  } //bool is_valid_pattern (const char *p, int *error_type)
-
-
-  /*----------------------------------------------------------------------------
-  *
-  *  Match the pattern PATTERN against the string TEXT;
-  *
-  *  returns MATCH_VALID if pattern matches, or an errorcode as follows
-  *  otherwise:
-  *
-  *            MATCH_PATTERN  - bad pattern
-  *            MATCH_RANGE    - match failure on [..] construct
-  *            MATCH_ABORT    - premature end of text string
-  *            MATCH_END      - premature end of pattern string
-  *            MATCH_VALID    - valid match
-  *
-  *
-  *  A match means the entire string TEXT is used up in matching.
-  *
-  *  In the pattern string:
-  *       `*' matches any sequence of characters (zero or more)
-  *       `?' matches any character
-  *       `%' matches any character and stores it in the s string
-  *       [SET] matches any character in the specified set,
-  *       [!SET] or [^SET] matches any character not in the specified set.
-  *       \ is allowed within a set to escape a character like ']' or '-'
-  *
-  *  A set is composed of characters or ranges; a range looks like
-  *  character hyphen character (as in 0-9 or A-Z).  [0-9a-zA-Z_] is the
-  *  minimal set of characters allowed in the [..] pattern construct.
-  *  Other characters are allowed (ie. 8 bit characters) if your system
-  *  will support them.
-  *
-  *  To suppress the special syntactic significance of any of `[]*?%!^-\',
-  *  within a [..] construct and match the character exactly, precede it
-  *  with a `\'.
-  *
-  ----------------------------------------------------------------------------*/
-
-  int matche ( register const char *p, register const char *t, register char *s )
-  {
-      register char range_start, range_end;  /* start and end in range */
-
-      bool invert;             /* is this [..] or [!..] */
-      bool member_match;       /* have I matched the [..] construct? */
-      bool loop;               /* should I terminate? */
-
-      for ( ; *p; p++, t++ ) {
-
-          /* if this is the end of the text then this is the end of the match */
-          if (!*t) {
-              return ( *p == '*' && *++p == '\0' ) ? MATCH_VALID : MATCH_ABORT;
-          }
-
-          /* determine and react to pattern type */
-          switch ( *p ) {
-
-              /* single any character match */
-              case '?':
-                  break;
-
-              /* single any character match, with extraction*/
-              case '%': {
-                  *s++ = *t;
-                  *s   = '\0';
-                  break;
-              }
-
-              /* multiple any character match */
-              case '*':
-                  return matche_after_star (p, t, s);
-
-              /* [..] construct, single member/exclusion character match */
-              case '[': {
-                /* move to beginning of range */
-                p++;
-
-                /* check if this is a member match or exclusion match */
-                invert = false;
-                if ( *p == '!' || *p == '^') {
-                    invert = true;
-                    p++;
-                }
-
-                /* if closing bracket here or at range start then we have a
-                   malformed pattern */
-                if ( *p == ']' ) {
-                    return MATCH_PATTERN;
-                }
-
-                member_match = false;
-                loop = true;
-
-                while ( loop ) {
-
-                    /* if end of construct then loop is done */
-                    if (*p == ']') {
-                        loop = false;
-                        continue;
-                    }
-
-                    /* matching a '!', '^', '-', '\' or a ']' */
-                    if ( *p == '\\' ) {
-                        range_start = range_end = *++p;
-                    }
-                    else {
-                        range_start = range_end = *p;
-                    }
-
-                    /* if end of pattern then bad pattern (Missing ']') */
-                    if (!*p)
-                        return MATCH_PATTERN;
-
-                    /* check for range bar */
-                    if (*++p == '-') {
-
-                        /* get the range end */
-                        range_end = *++p;
-
-                        /* if end of pattern or construct then bad pattern */
-                        if (range_end == '\0' || range_end == ']')
-                            return MATCH_PATTERN;
-
-                        /* special character range end */
-                        if (range_end == '\\') {
-                            range_end = *++p;
-
-                            /* if end of text then we have a bad pattern */
-                            if (!range_end)
-                                return MATCH_PATTERN;
-                        }
-
-                        /* move just beyond this range */
-                        p++;
-                    }
-
-                    /* if the text character is in range then match found.
-                       make sure the range letters have the proper
-                       relationship to one another before comparison */
-                    if ( range_start < range_end  ) {
-                        if (*t >= range_start && *t <= range_end) {
-                            member_match = true;
-                            loop = false;
-                        }
-                    }
-                    else {
-                        if (*t >= range_end && *t <= range_start) {
-                            member_match = true;
-                            loop = false;
-                        }
-                    }
-                }
-
-                /* if there was a match in an exclusion set then no match */
-                /* if there was no match in a member set then no match */
-                if ((invert && member_match) ||
-                   !(invert || member_match))
-                    return MATCH_RANGE;
-
-                /* if this is not an exclusion then skip the rest of the [...]
-                    construct that already matched. */
-                if (member_match) {
-                    while (*p != ']') {
-
-                        /* bad pattern (Missing ']') */
-                        if (!*p)
-                            return MATCH_PATTERN;
-
-                        /* skip exact match */
-                        if (*p == '\\') {
-                            p++;
-
-                            /* if end of text then we have a bad pattern */
-                            if (!*p)
-                                return MATCH_PATTERN;
-                        }
-
-                        /* move to next pattern char */
-                        p++;
-                    }
-                }
-
-                break;
-            } // case ']'
-
-            /* must match this character exactly */
-            default:
-                if (*p != *t)
-                    return MATCH_LITERAL;
-        }
-      }
-
-      //*s = '\0';
-      /* if end of text not reached then the pattern fails */
-      if ( *t )
-          return MATCH_END;
-      else
-          return MATCH_VALID;
-  }
-
-
-  /*----------------------------------------------------------------------------
-  *
-  * recursively call matche() with final segment of PATTERN and of TEXT.
-  *
-  ----------------------------------------------------------------------------*/
-
-  static int matche_after_star (register const char *p, register const char *t, register char *s)
-  {
-      register int match = 0;
-      register char nextp;
-
-      /* pass over existing ? and * in pattern */
-      while ( *p == '?' || *p == '%' || *p == '*' ) {
-
-          /* take one char for each ? and + */
-          if ( *p == '?') {
-
-              /* if end of text then no match */
-              if ( !*t++ ) {
-                  return MATCH_ABORT;
-              }
-          }
-
-          if ( *p == '%') {
-              *s++ = *t;
-              *s   = '\0';
-              /* if end of text then no match */
-              if ( !*t++ ) {
-                  return MATCH_ABORT;
-              }
-          }
-
-          /* move to next char in pattern */
-          p++;
-      }
-
-      /* if end of pattern we have matched regardless of text left */
-      if ( !*p ) {
-          return MATCH_VALID;
-      }
-
-      /* get the next character to match which must be a literal or '[' */
-      nextp = *p;
-
-      /* Continue until we run out of text or definite result seen */
-      do {
-
-          /* a precondition for matching is that the next character
-             in the pattern match the next character in the text or that
-             the next pattern char is the beginning of a range.  Increment
-             text pointer as we go here */
-          if ( nextp == *t || nextp == '[' ) {
-              match = matche(p, t, s);
-          }
-
-          /* if the end of text is reached then no match */
-          if ( !*t++ ) match = MATCH_ABORT;
-
-      } while ( match != MATCH_VALID && 
-                match != MATCH_ABORT &&
-                match != MATCH_PATTERN);
-
-      /* return result */
-      return match;
-  }
-
-
-  /*----------------------------------------------------------------------------
-  *
-  * match() is a shell to matche() to return only bool values.
-  *
-  ----------------------------------------------------------------------------*/
-
-  bool match(const  char *p, const char *t, char *s)
-  {
-      int error_type;
-      error_type = matche(p,t,s);
-      return (error_type != MATCH_VALID ) ? false : true;
-  }
-
-
-  //***************************************************************************
-  //***************************************************************************
-  bool
-  ProcessMask(const std::string & rString,
-              const std::string & rWildcard,
-                    std::string & rSubstr)
-  {
-    char *  substr;
-    int     percent_count        = 0;
-    int     ret ;
-    size_t  pos                  = 0;
-
-    // let's find how many % to allocate enough space for the return substring
-    while ((pos = rWildcard.find('%', pos)) != rWildcard.npos)
-    {
-      percent_count++;
-      pos++;
-    }
-
-    // allocate space for the substring
-    substr = new char[percent_count + 1];
-    substr[percent_count] = 0;
-    substr[0]             = '\0';
-
-    // optionally prepend '*/' to wildcard
-    std::string wildcard(rWildcard);
-    if(wildcard[0] != '*') {
-      wildcard = "*/" + wildcard;
-    }
-
-    //optionally prepend '/' to string
-    std::string string1(rString);
-    if(string1[0] != '/') {
-      string1 = "/" + string1;
-    }
-
-    // parse the string
-    if (0 != (ret = match(wildcard.c_str(), string1.c_str(), substr)))
-    {
-      rSubstr = substr;
-    }
-    delete[] substr;
-    return ret;
-  } // ProcessMask
-}
-
-
-#ifdef TEST
-
-/*
-* This test main expects as first arg the pattern and as second arg
-* the match string.  Output is yaeh or nay on match.  If nay on
-* match then the error code is parsed and written.
-*/
-
-#include <stdio.h>
-
-int main(int argc, char *argv[])
-{
-    int error;
-    int is_valid_error;
-
-    char * tmp = argv[0];
-    int i = 0;
-    for (; *tmp; tmp++)
-      if (*tmp=='%') i++;
-
-    char s[i+1];
-
-
-    if (argc != 3) {
-        printf("Usage:  MATCH Pattern Text\n");
-    }
-    else {
-        printf("Pattern: %s\n", argv[1]);
-        printf("Text   : %s\n", argv[2]);
-        
-        if (!is_pattern(argv[1])) {
-            printf("    First Argument Is Not A Pattern\n");
-        }
-        else {
-            match(argv[1],argv[2], s) ? printf("true") : printf("false");
-            error = matche(argv[1],argv[2], s);
-            is_valid_pattern(argv[1],&is_valid_error);
-
-            switch ( error ) {
-                case MATCH_VALID:
-                    printf("    Match Successful");
-                    if (is_valid_error != PATTERN_VALID)
-                        printf(" -- is_valid_pattern() is complaining\n");
-                    else
-                        printf("\n");
-                    printf("%s\n", s);
-
-                    break;
-                case MATCH_RANGE:
-                    printf("    Match Failed on [..]\n");
-                    break;
-                case MATCH_ABORT:
-                    printf("    Match Failed on Early Text Termination\n");
-                    break;
-                case MATCH_END:
-                    printf("    Match Failed on Early Pattern Termination\n");
-                    break;
-                case MATCH_PATTERN:
-                    switch ( is_valid_error ) {
-                        case PATTERN_VALID:
-                            printf("    Internal Disagreement On Pattern\n");
-                            break;
-                        case PATTERN_RANGE:
-                            printf("    No End of Range in [..] Construct\n");
-                            break;
-                        case PATTERN_CLOSE:
-                            printf("    [..] Construct is Open\n");
-                            break;
-                        case PATTERN_EMPTY:
-                            printf("    [..] Construct is Empty\n");
-                            break;
-                        default:
-                            printf("    Internal Error in is_valid_pattern()\n");
-                    }
-                    break;
-                default:
-                    printf("    Internal Error in matche()\n");
-                    break;
-            }
-        }
-
-    }
-    return(0);
-}
-
-#endif
diff --git a/tnet_io/KaldiLib/StkMatch.h b/tnet_io/KaldiLib/StkMatch.h
deleted file mode 100644
index 42c6b97..0000000
--- a/tnet_io/KaldiLib/StkMatch.h
+++ /dev/null
@@ -1,123 +0,0 @@
-#ifndef TNet_StkMatch_h
-#define TNet_StkMatch_h
-
-#include <string>
-namespace TNet 
-{
-  /*
-   EPSHeader
-
-     File: filmatch.h
-     Author: J. Kercheval
-     Created: Thu, 03/14/1991  22:24:34
-  */
-
-  /*
-   EPSRevision History
-     O. Glembek    Thu, 03/11/2005  01:58:00  Added Mask extraction support (char % does this)
-     J. Kercheval  Wed, 02/20/1991  22:28:37  Released to Public Domain
-     J. Kercheval  Sun, 03/10/1991  18:02:56  add is_valid_pattern
-     J. Kercheval  Sun, 03/10/1991  18:25:48  add error_type in is_valid_pattern
-     J. Kercheval  Sun, 03/10/1991  18:47:47  error return from matche()
-     J. Kercheval  Tue, 03/12/1991  22:24:49  Released as V1.1 to Public Domain
-     J. Kercheval  Thu, 03/14/1991  22:25:00  remove '\' for DOS file matching
-     J. Kercheval  Thu, 03/28/1991  21:03:59  add in PATTERN_ESC & MATCH_LITERAL
-  */
-
-  /*
-     Wildcard Pattern Matching
-  */
-
-
-  /* match defines */
-#define MATCH_PATTERN  6    /* bad pattern */
-#define MATCH_LITERAL  5    /* match failure on literal match */
-#define MATCH_RANGE    4    /* match failure on [..] construct */
-#define MATCH_ABORT    3    /* premature end of text string */
-#define MATCH_END      2    /* premature end of pattern string */
-#define MATCH_VALID    1    /* valid match */
-
-  /* pattern defines */
-#define PATTERN_VALID  0    /* valid pattern */
-#define PATTERN_ESC   -1    /* literal escape at end of pattern */
-#define PATTERN_RANGE -2    /* malformed range in [..] construct */
-#define PATTERN_CLOSE -3    /* no end bracket in [..] construct */
-#define PATTERN_EMPTY -4    /* [..] contstruct is empty */
-
-
-  /*----------------------------------------------------------------------------
-  *
-  *  Match the pattern PATTERN against the string TEXT;
-  *
-  *       match() returns TRUE if pattern matches, FALSE otherwise.
-  *       matche() returns MATCH_VALID if pattern matches, or an errorcode
-  *           as follows otherwise:
-  *
-  *            MATCH_PATTERN  - bad pattern
-  *            MATCH_RANGE    - match failure on [..] construct
-  *            MATCH_ABORT    - premature end of text string
-  *            MATCH_END      - premature end of pattern string
-  *            MATCH_VALID    - valid match
-  *
-  *
-  *  A match means the entire string TEXT is used up in matching.
-  *
-  *  In the pattern string:
-  *       `*' matches any sequence of characters (zero or more)
-  *       `?' matches any character
-  *       [SET] matches any character in the specified set,
-  *       [!SET] or [^SET] matches any character not in the specified set.
-  *
-  *  A set is composed of characters or ranges; a range looks like
-  *  character hyphen character (as in 0-9 or A-Z).  [0-9a-zA-Z_] is the
-  *  minimal set of characters allowed in the [..] pattern construct.
-  *  Other characters are allowed (ie. 8 bit characters) if your system
-  *  will support them.
-  *
-  *  To suppress the special syntactic significance of any of `[]*?!^-\',
-  *  in a [..] construct and match the character exactly, precede it
-  *  with a `\'.
-  *
-  ----------------------------------------------------------------------------*/
-  bool 
-  match (const char *pattern, const char *text, char *s);
-
-  int  
-  matche(register const char *pattern, register const char *text, register char *s);
-
-
-  /*----------------------------------------------------------------------------
-  *
-  * Return TRUE if PATTERN has any special wildcard characters
-  *
-  ----------------------------------------------------------------------------*/
-  bool 
-  is_pattern (const char *pattern);
-
-
-  /** --------------------------------------------------------------------------
-   *
-   * Return TRUE if PATTERN has is a well formed regular expression according
-   * to the above syntax
-   *
-   * error_type is a return code based on the type of pattern error.  Zero is
-   * returned in error_type if the pattern is a valid one.  error_type return
-   * values are as follows:
-   *
-   *   PATTERN_VALID - pattern is well formed
-   *   PATTERN_RANGE - [..] construct has a no end range in a '-' pair (ie [a-])
-   *   PATTERN_CLOSE - [..] construct has no end bracket (ie [abc-g )
-   *   PATTERN_EMPTY - [..] construct is empty (ie [])
-   *  --------------------------------------------------------------------------
-  **/
-  bool 
-  is_valid_pattern (const char *pattern, int *error_type);
-
-
-  //****************************************************************************
-  //****************************************************************************
-  bool
-  ProcessMask(const std::string & rString, const std::string & rWildcard,
-      std::string & rSubstr);
-}
-#endif
diff --git a/tnet_io/KaldiLib/StkStream.h b/tnet_io/KaldiLib/StkStream.h
deleted file mode 100644
index ca8de30..0000000
--- a/tnet_io/KaldiLib/StkStream.h
+++ /dev/null
@@ -1,526 +0,0 @@
-
-
-/** @file stkstream.h
- *  This is an TNet C++ Library header.
- */
-
-
-#ifndef TNet_StkStream_h
-#define TNet_StkStream_h
-
-#include <fstream>
-#include <string>
-#include <vector>
-#include <list>
-#include <stdexcept>
-
-#pragma GCC system_header
-
-
-//extern const char * gpFilterWldcrd;
-
-namespace TNet
-{
-
-  /**
-   *  @brief Expands a filter command into a runnable form
-   *
-   *  This function replaces all occurances of *filter_wldcard in *command by
-   *  *filename
-   */
-  //char * ExpandFilterCommand(const char *command, const char *filename);
-
-  /**
-   *  @brief Provides a layer of compatibility for C/POSIX.
-   *
-   *  This GNU extension provides extensions for working with standard C
-   *  FILE*'s and POSIX file descriptors.  It must be instantiated by the
-   *  user with the type of character used in the file stream, e.g.,
-   *  basic_stkbuf<char>.
-   */
-  template<
-    typename _CharT, 
-    typename _Traits = std::char_traits<_CharT>
-  > 
-    class basic_stkbuf : public std::basic_filebuf<_CharT, _Traits>
-    {
-    public:
-
-      typedef basic_stkbuf<_CharT, _Traits>     this_type;
-
-      // Types:
-      typedef _CharT                        char_type;
-      typedef _Traits                       traits_type;
-
-      typedef typename traits_type::int_type        int_type;
-      typedef typename traits_type::pos_type        pos_type;
-      typedef typename traits_type::off_type        off_type;
-      typedef std::size_t                           size_t;
-
-    public:
-
-      /// @{
-      /// Type of streambuffer
-      static const unsigned int t_undef  = 0; ///< undefined
-      static const unsigned int t_file   = 1; ///< file stream
-      static const unsigned int t_pipe   = 2; ///< pipe
-      static const unsigned int t_filter = 4; ///< filter
-      static const unsigned int t_stdio  = 8; ///< standard input/output
-      /// @}
-
-    public:
-
-      /**
-      * deferred initialization
-      */
-      basic_stkbuf() : std::basic_filebuf<_CharT, _Traits>(),
-        mFilename(""), mpFilePtr(0), mStreamType(t_undef){}
-
-      /**
-       *  @brief  Opens a stream.
-       *  @param  fName  The name of the file.
-       *  @param  m      The open mode flags.
-       *  @param  pFilter The pFilter command to use
-       *  @return  @c this on success, NULL on failure
-       *
-       *  If a file is already open, this function immediately fails.
-       *  Otherwise it tries to open the file named @a s using the flags
-       *  given in @a mode.
-       *
-       *  [Table 92 gives the relation between openmode combinations and the
-       *  equivalent fopen() flags, but the table has not been copied yet.]
-       */
-      basic_stkbuf(const char* fName, std::ios_base::openmode m, const char* pFilter="");
-
-      
-      /**
-      *  @return  The underlying FILE*.
-      *
-      *  This function can be used to access the underlying "C" file pointer.
-      *  Note that there is no way for the library to track what you do
-      *  with the file, so be careful.
-      */
-      std::__c_file*
-      file() { return this->_M_file.file(); }
-
-
-      /**
-      *  @return  The underlying FILE*.
-      *
-      *  This function can be used to access the underlying "C" file pointer.
-      *  Note that there is no way for the library to track what you do
-      *  with the file, so be careful.
-      */
-      std::__c_file*
-      fp() { return this->_M_file.file(); }
-      
-      
-      /**
-       *  @brief  Opens an external file.
-       *  @param  fName  The name of the file.
-       *  @param  m      The open mode flags.
-       *  @param  pFilter The pFilter command to use
-       *  @return  @c this on success, NULL on failure
-       *
-       *  If a file is already open, this function immediately fails.
-       *  Otherwise it tries to open the file named @a s using the flags
-       *  given in @a mode.
-       *
-       *  [Table 92 gives the relation between openmode combinations and the
-       *  equivalent fopen() flags, but the table has not been copied yet.]
-       */
-      this_type*
-      open(const char* pFName, std::ios_base::openmode m, const char* pFilter="");
-      
-      /**
-       *  @brief  Closes the currently associated file.
-       *  @return  @c this on success, NULL on failure
-       *
-       *  If no file is currently open, this function immediately fails.
-       *
-       *  If a "put buffer area" exists, @c overflow(eof) is called to flush
-       *  all the characters.  The file is then closed.
-       *
-       *  If any operations fail, this function also fails.
-       */
-      this_type*
-      close();
-
-      /**
-      *  Closes the external data stream if the file descriptor constructor
-      *  was used.
-      */
-      virtual
-      ~basic_stkbuf() 
-      {close();};
-
-      /// Returns the file name
-      const std::string 
-      name() const 
-      {return mFilename;}
-
-
-    private:
-      /// converts the ios::xxx mode to stdio style
-      static void open_mode(std::ios_base::openmode __mode, int&, int&,  char* __c_mode);
-
-      /**
-       *  @param  __f  An open @c FILE*.
-       *  @param  __mode  Same meaning as in a standard filebuf.
-       *  @param  __size  Optimal or preferred size of internal buffer, in chars.
-       *                Defaults to system's @c BUFSIZ.
-       *
-       *  This method associates a file stream buffer with an open
-       *  C @c FILE*.  The @c FILE* will not be automatically closed when the
-       *  basic_stkbuf is closed/destroyed. It is equivalent to one of the constructors
-       *  of the stdio_filebuf class defined in GNU ISO C++ ext/stdio_filebuf.h
-      */
-      void superopen(std::__c_file* __f, std::ios_base::openmode __mode,
-            size_t __size = static_cast<size_t>(BUFSIZ));
-
-
-    private:
-      /// Holds the full file name
-      std::string           mFilename;
-
-      std::ios_base::openmode  mMode;
-
-      /// Holds a pointer to the main FILE structure
-      FILE *                mpFilePtr;
-
-      /// tells what kind of stream we use (stdio, file, pipe)
-      unsigned int          mStreamType;
-
-    };
-
-
-
-  /**
-   *  @brief This extension wraps stkbuf stream buffer into the standard ios class.
-   *
-   *  This class is inherited by (i/o)stkstream classes which make explicit use of
-   *  the custom stream buffer
-   */
-  template<
-    typename _CharT, 
-    typename _Traits = std::char_traits<_CharT>
-  >	
-    class BasicStkIos 
-    : virtual public std::basic_ios<_CharT, _Traits>
-    {
-    public:
-      typedef basic_stkbuf <_CharT,_Traits>        StkBufType;
-
-      BasicStkIos() 
-      : mBuf() 
-      { this->init(&mBuf) ;};
-
-      BasicStkIos(const char* fName, std::ios::openmode m, const char* pFilter) 
-      : mBuf(fName, m, pFilter) 
-      { this->init(&mBuf) ; }
-
-      StkBufType*
-      rdbuf() 
-      { return &mBuf; }
-
-    protected:
-      StkBufType  mBuf;
-    };
-
-
-  /**
-   *  @brief  Controlling input for files.
-   *
-   *  This class supports reading from named files, using the inherited
-   *  functions from std::istream.  To control the associated
-   *  sequence, an instance of std::stkbuf is used.
-  */
-  template<
-    typename _CharT, 
-    typename _Traits = std::char_traits<_CharT>
-  >	
-    class BasicIStkStream 
-    : public BasicStkIos<_CharT, _Traits>, 
-      public std::basic_istream<_CharT, _Traits>
-    {
-    public:
-      typedef BasicStkIos<_CharT, _Traits> BasicStkIosType;
-      typedef std::basic_istream<_CharT,_Traits>  IStreamType;
-
-
-      // Constructors:
-      /**
-       *  @brief  Default constructor.
-       *
-       *  Initializes @c mBuf using its default constructor, and passes
-       *  @c &sb to the base class initializer.  Does not open any files
-       *  (you haven't given it a filename to open).
-       */
-      BasicIStkStream() 
-      : BasicStkIosType(),
-        IStreamType(BasicStkIosType::rdbuf())
-      {};
-
-     /**
-       *  @brief  Create an input file stream.
-       *  @param  fName  String specifying the filename.
-       *  @param  m      Open file in specified mode (see std::ios_base).
-       *  @param  pFilter String specifying pFilter command to use on fName
-       *
-       *  @c ios_base::in is automatically included in
-       *  @a m.
-       *
-       *  Tip:  When using std::string to hold the filename, you must use
-       *  .c_str() before passing it to this constructor.
-      */
-      BasicIStkStream(const char* pFName, std::ios::openmode m=std::ios::out, const char* pFilter="")
-      : BasicStkIosType(),
-        IStreamType(BasicStkIosType::rdbuf())
-      {this->open(pFName, std::ios::in, pFilter);}
-
-      ~BasicIStkStream() 
-      {
-        this->close();
-      }
-        
-      /**
-      *  @brief  Opens an external file.
-      *  @param  s  The name of the file.
-      *  @param  mode  The open mode flags.
-      *  @param  pFilter The pFilter command to use
-         *
-      *  Calls @c std::basic_filebuf::open(s,mode|in).  If that function
-      *  fails, @c failbit is set in the stream's error state.
-      *
-      *  Tip:  When using std::string to hold the filename, you must use
-      *  .c_str() before passing it to this constructor.
-      */
-      void open(const char* pFName, std::ios::openmode m=std::ios::in, const char* pFilter = "")
-      {
-        if (!BasicStkIosType::mBuf.open(pFName, m | std::ios_base::in, pFilter)) {
-          this->setstate(std::ios_base::failbit);
-        }
-        else {
-        // Closing an fstream should clear error state
-          BasicStkIosType::clear();
-        }
-      }
-
-      /**
-      *  @brief  Returns true if the external file is open.
-      */
-      bool is_open() const {return BasicStkIosType::mBuf.is_open();}
-
-
-      /**
-      *  @brief  Closes the stream
-      */
-      void close() {BasicStkIosType::mBuf.close();}
-
-      /**
-      *  @brief  Returns the filename
-      */
-      const std::string name() const {return BasicStkIosType::mBuf.name();}
-
-      /// Returns a pointer to the main FILE structure
-      std::__c_file*
-      file() {return BasicStkIosType::mBuf.file();}
-
-      /// Returns a pointer to the main FILE structure
-      std::__c_file*
-      fp() {return BasicStkIosType::mBuf.fp();}
-
-      // /**
-      //  *  @brief  Reads a single line
-      //  *
-      //  *  This is a specialized function as std::getline does not provide a way to
-      //  *  read multiple end-of-line symbols (we need both '\n' and EOF to delimit
-      //  *  the line)
-      //  */
-      // void
-      // GetLine(string& rLine);
-
-    }; // class BasicIStkStream
-
-
-  /**
-   *  @brief  Controlling output for files.
-   *
-   *  This class supports reading from named files, using the inherited
-   *  functions from std::ostream.  To control the associated
-   *  sequence, an instance of TNet::stkbuf is used.
-  */
-  template<
-    typename _CharT, 
-    typename _Traits = std::char_traits<_CharT>
-  >	
-    class BasicOStkStream 
-    : public BasicStkIos<_CharT, _Traits>,
-      public std::basic_ostream<_CharT, _Traits>
-    {
-    public:
-      typedef BasicStkIos<_CharT, _Traits> BasicStkIosType;
-      typedef std::basic_ostream<_CharT,_Traits>  OStreamType;
-
-      // Constructors:
-      /**
-       *  @brief  Default constructor.
-       *
-       *  Initializes @c sb using its default constructor, and passes
-       *  @c &sb to the base class initializer.  Does not open any files
-       *  (you haven't given it a filename to open).
-       */
-      BasicOStkStream() 
-      : BasicStkIosType(),
-        OStreamType(BasicStkIosType::rdbuf())
-      {};
-
-      /**
-       *  @brief  Create an output file stream.
-       *  @param  fName  String specifying the filename.
-       *  @param  m      Open file in specified mode (see std::ios_base).
-       *  @param  pFilter String specifying pFilter command to use on fName
-       *
-       *  @c ios_base::out|ios_base::trunc is automatically included in
-       *  @a mode.
-       *
-       *  Tip:  When using std::string to hold the filename, you must use
-       *  .c_str() before passing it to this constructor.
-       */
-      BasicOStkStream(const char* pFName, std::ios::openmode m=std::ios::out, const char* pFilter="")
-      : BasicStkIosType(),
-        OStreamType(BasicStkIosType::rdbuf())
-      {this->open(pFName, std::ios::out, pFilter);}
-
-      /**
-      *  @brief  Opens an external file.
-      *  @param  fName  The name of the file.
-      *  @param  m  The open mode flags.
-      *  @param  pFilter String specifying pFilter command to use on fName
-      *
-      *  Calls @c std::basic_filebuf::open(s,mode|out).  If that function
-      *  fails, @c failbit is set in the stream's error state.
-      *
-      *  Tip:  When using std::string to hold the filename, you must use
-      *  .c_str() before passing it to this constructor.
-      */
-      void open(const char* pFName, std::ios::openmode m=std::ios::out, const char* pFilter="")
-      {
-        if (!BasicStkIosType::mBuf.open(pFName, m | std::ios_base::out, pFilter))
-          this->setstate(std::ios_base::failbit);
-        else
-        // Closing an fstream should clear error state
-          this->clear();
-      }
-
-      /**
-      *  @brief  Returns true if the external file is open.
-      */
-      bool is_open() const 
-      { return BasicStkIosType::mBuf.is_open();}
-
-      /**
-      *  @brief  Closes the stream
-      */
-      void close() 
-      { BasicStkIosType::mBuf.close();}
-
-      /**
-      *  @brief  Returns the filename
-      */
-      const std::string name() const 
-      { return BasicStkIosType::mBuf.name();}
-
-      /// Returns a pointer to the main FILE structure
-      std::__c_file*
-      file() 
-      { return BasicStkIosType::mBuf.file();}
-
-      /// Returns a pointer to the main FILE structure
-      std::__c_file*
-      fp() 
-      { return BasicStkIosType::mBuf.fp();}
-
-    }; // class BasicOStkStream
-
-
-  /**
-   * We define some implicit stkbuf class
-   */
-  ///@{
-#ifndef _GLIBCPP_USE_WCHAR_T
-  typedef BasicOStkStream<char>      OStkStream;
-  typedef BasicOStkStream<wchar_t>  WOStkStream;
-  typedef BasicIStkStream<char>      IStkStream;
-  typedef BasicIStkStream<wchar_t>  WIStkStream;
-#else 
-  typedef BasicOStkStream<char>     WOStkStream;
-  typedef BasicOStkStream<wchar_t>  WOStkStream;
-  typedef BasicIStkStream<char>     WIStkStream;
-  typedef BasicIStkStream<wchar_t>  WIStkStream;
-#endif
-  /// @}
-
-  /*
-  template<class T,class char_type> inline
-   BasicOStkStream<char_type>& operator << (BasicOStkStream<char_type> &ostream, const std::vector<T> &vec){
-    ostream << vec.size() << std::endl;
-    for(size_t i=0;i<vec.size();i++) ostream << vec[i];
-    return ostream;
-  }
-
-  template<class T,class char_type> inline BasicIStkStream<char_type> &operator >> (BasicIStkStream<char_type> &istream, std::vector<T> &vec){
-    size_t sz;
-    istream >> sz; if(!istream.good()){ throw std::runtime_error(std::string("Error reading to vector of [something]: stream bad\n"));  }
-    int ch = istream.get(); if(ch!='\n' || !istream.good()){ throw std::runtime_error(std::string("Expecting newline after vector size, got " + (std::string)(char)ch));} // TODO: This code may not be right for wchar.
-    vec.resize(sz);
-    for(size_t i=0;i<vec.size();i++) istream >> vec[i];
-    return istream;
-    }*/
-
-  template<class T> inline
-  std::ostream & operator << (std::ostream &ostream, const std::vector<T> &vec){
-    ostream << vec.size() << std::endl;
-    for(size_t i=0;i<vec.size();i++) ostream << vec[i] << "\n"; // '\n' is necessary in case item is atomic e.g. a number.
-    return ostream;
-  }
-
-  template<class T> inline std::istream& operator >> (std::istream &istream, std::vector<T> &vec){
-    size_t sz;
-    istream >> sz; if(!istream.good()){ throw std::runtime_error(std::string("Error reading to vector of [something]: stream bad\n"));  }
-    // int ch = istream.get(); if(ch!='\n' || !istream.good()){ throw std::runtime_error(std::string("Expecting newline after vector size\n")); // TODO: This code may not be right for wchar.
-    vec.resize(sz);
-    for(size_t i=0;i<vec.size();i++) istream >> vec[i];
-    return istream;
-  }
-
-  template<class T> inline
-  std::ostream & operator << (std::ostream &ostream, const std::list<T> &lst){
-    ostream << lst.size() << std::endl;
-    typename std::list<T>::iterator it;
-    for(it = lst.begin(); it != lst.end(); it++)
-      ostream << *it << "\n"; // '\n' is necessary in case item is atomic e.g. a number.
-    return ostream;
-  }
-
-  template<class T> inline std::istream& operator >> (std::istream &istream, std::list<T> &lst){
-    size_t sz;
-    istream >> sz; if(!istream.good()){ throw std::runtime_error(std::string("Error reading to list of [something]: stream bad\n"));  }
-    lst.resize(sz);
-    typename std::list<T>::iterator it;
-    for(it = lst.begin(); it != lst.end(); it++)
-      istream >> *it;
-    return istream;
-  }
-
-}; // namespace TNet
-
-
-using TNet::operator >>; 
-using TNet::operator <<;
-
-
-# include "StkStream.tcc"
-
-// TNet_StkStream_h
-#endif 
diff --git a/tnet_io/KaldiLib/StkStream.tcc b/tnet_io/KaldiLib/StkStream.tcc
deleted file mode 100644
index e3de1ae..0000000
--- a/tnet_io/KaldiLib/StkStream.tcc
+++ /dev/null
@@ -1,228 +0,0 @@
-#ifndef TNet_StkStream_tcc
-#define TNet_StkStream_tcc
-
-#include <cstring>
-#include <iostream>
-
-#include "Common.h"
-
-#pragma GCC system_header
-
-namespace TNet
-{
-  
-  //******************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits
-  > 
-  basic_stkbuf<_CharT, _Traits> *
-  basic_stkbuf<_CharT, _Traits>::
-  close(void)
-  {
-    // we only want to close an opened file
-    if (this->is_open())
-    {
-      // we want to call the parent close() procedure
-      std::basic_filebuf<_CharT, _Traits>::close();
-
-      // and for different stream type we perform different closing
-      if (mStreamType == basic_stkbuf::t_file)
-      {
-        fclose(mpFilePtr);
-      }
-      else if (mStreamType == basic_stkbuf::t_pipe)
-      {
-        pclose(mpFilePtr);
-      }
-      else if (mStreamType == basic_stkbuf::t_stdio)
-      {
-
-      }
-      
-      mpFilePtr     = NULL;
-      mFilename    = "";
-      mMode        = std::ios_base::openmode(0);
-      mStreamType = basic_stkbuf::t_undef;
-      return this;
-    }
-    else
-      return 0;
-  }
-
-
-  template<
-    typename _CharT, 
-    typename _Traits
-  > 
-  void
-  basic_stkbuf<_CharT, _Traits>::
-  open_mode(std::ios_base::openmode __mode, int&, int&,  char* __c_mode)
-  {
-    bool __testb = __mode & std::ios_base::binary;
-    bool __testi = __mode & std::ios_base::in;
-    bool __testo = __mode & std::ios_base::out;
-    bool __testt = __mode & std::ios_base::trunc;
-    bool __testa = __mode & std::ios_base::app;
-
-    if (!__testi && __testo && !__testt && !__testa)
-      strcpy(__c_mode, "w");
-    if (!__testi && __testo && !__testt && __testa)
-      strcpy(__c_mode, "a");
-    if (!__testi && __testo && __testt && !__testa)
-      strcpy(__c_mode, "w");
-    if (__testi && !__testo && !__testt && !__testa)
-      strcpy(__c_mode, "r");
-    if (__testi && __testo && !__testt && !__testa)
-      strcpy(__c_mode, "r+");
-    if (__testi && __testo && __testt && !__testa)
-      strcpy(__c_mode, "w+");
-    if (__testb)
-      strcat(__c_mode, "b");
-  }
-
-
-  //******************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits
-  > 
-  basic_stkbuf<_CharT, _Traits> *
-  basic_stkbuf<_CharT, _Traits>::
-  open(const char* pFName, std::ios::openmode m, const char* pFilter)
-  {
-    basic_stkbuf<_CharT, _Traits>* p_ret = NULL;
-
-    if (NULL == pFName)
-      return NULL;
-      
-    // we need to assure, that the stream is not open
-    if (!this->is_open())
-    {
-      char mstr[4] = {'\0', '\0', '\0', '\0'};
-      int __p_mode = 0;
-      int __rw_mode = 0;
-
-      // now we decide, what kind of file we open
-      if (!strcmp(pFName,"-"))
-      {
-        if      ((m & std::ios::in) && !(m & std::ios::out))
-        {
-          mpFilePtr   = stdin;
-          mMode       = std::ios::in;
-          mFilename   = pFName;
-          mStreamType = t_stdio;
-          p_ret       = this;
-        }
-        else if ((m & std::ios::out) && !(m & std::ios::in))
-        {
-          mpFilePtr   = stdout;
-          mMode       = std::ios::out;
-          mFilename   = pFName;
-          mStreamType = t_stdio;
-          p_ret       = this;
-        }
-        else
-          p_ret = NULL;
-      }
-      else if ( pFName[0] == '|' )
-      {
-        const char* command = pFName + 1;
-
-        if      ((m & std::ios::in) && !(m & std::ios::out)) m = std::ios::in;
-        else if ((m & std::ios::out) && !(m & std::ios::in)) m = std::ios::out;
-        else return NULL;
-
-        // we need to make some conversion
-        // iostream -> stdio open mode string
-        this->open_mode(m, __p_mode, __rw_mode, mstr);
-
-        if ((mpFilePtr = popen(command, mstr)))
-        {
-          mFilename   = command;
-          mMode       = m;
-          mStreamType = t_pipe;
-          p_ret       = this;
-        }
-        else
-          p_ret = 0;
-      }
-      else
-      {
-        // maybe we have a filter specified
-        if ( pFilter 
-        && ('\0' != pFilter[0]))
-        {
-          char* command = ExpandHtkFilterCmd(pFilter, pFName, "$");
-
-          if      ((m & std::ios::in) && !(m & std::ios::out)) m = std::ios::in;
-          else if ((m & std::ios::out) && !(m & std::ios::in)) m = std::ios::out;
-          else return NULL;
-
-          // we need to make some conversion
-          // iostream -> stdio open mode string
-          this->open_mode(m, __p_mode, __rw_mode, mstr);
-
-          if ((mpFilePtr = popen(command, mstr)))
-          {
-            mFilename     = pFName;
-            mMode         = m;
-            mStreamType   = t_pipe;
-            p_ret         = this;
-          }
-          else
-            p_ret = 0;
-        }
-        else // if (!filter.empty())
-        {
-          // we need to make some conversion
-          // iostream -> stdio open mode string
-          this->open_mode(m, __p_mode, __rw_mode, mstr);
-
-          if ((mpFilePtr = fopen(pFName, mstr)))
-          {
-            mFilename   = pFName;
-            mMode       = m;
-            mStreamType = t_file;
-            p_ret       = this;
-          }
-          else {
-            p_ret = NULL;
-          }
-        }
-      }
-
-      // here we perform what the stdio_filebuf would do
-      if (p_ret) {
-        superopen(mpFilePtr, m);
-      }
-    } //if (!isopen)
-
-    return p_ret;
-  }
-
-  //******************************************************************************
-  template<
-    typename _CharT, 
-    typename _Traits
-  > 
-  void
-  basic_stkbuf<_CharT, _Traits>::
-  superopen(std::__c_file* __f, std::ios_base::openmode __mode,
-        size_t __size)
-  {
-    this->_M_file.sys_open(__f, __mode);
-    if (this->is_open())
-    {
-      this->_M_mode = __mode;
-      this->_M_buf_size = __size;
-      this->_M_allocate_internal_buffer();
-      this->_M_reading = false;
-      this->_M_writing = false;
-      this->_M_set_buffer(-1);
-    }
-  }
-}
-
-// TNet_StkStream_tcc
-#endif
diff --git a/tnet_io/KaldiLib/Timer.cc b/tnet_io/KaldiLib/Timer.cc
deleted file mode 100644
index 692969b..0000000
--- a/tnet_io/KaldiLib/Timer.cc
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "Timer.h"
-
-/*
-TNet::Timer gTimer;
-*/
diff --git a/tnet_io/KaldiLib/Timer.h b/tnet_io/KaldiLib/Timer.h
deleted file mode 100644
index b220b93..0000000
--- a/tnet_io/KaldiLib/Timer.h
+++ /dev/null
@@ -1,103 +0,0 @@
-#ifndef Timer_h
-#define Timer_h
-
-#include "Error.h"
-#include <sstream>
-
-
-
-#if defined(_WIN32) || defined(MINGW)
-
-# include <windows.h>
-
-namespace TNet
-{
-  class Timer {
-  public:
-    void 
-    Start(void)
-    {
-      static int first = 1;
-
-      if(first) {
-              QueryPerformanceFrequency(&mFreq);
-              first = 0;
-      }
-      QueryPerformanceCounter(&mTStart);
-    }
-
-    void 
-    End(void)
-    { QueryPerformanceCounter(&mTEnd); }
-
-    double 
-    Val()
-    {
-      return ((double)mTEnd.QuadPart - (double)mTStart.QuadPart) / 
-        ((double)mFreq.QuadPart);
-    }
-
-  private:
-    LARGE_INTEGER mTStart;
-    LARGE_INTEGER mTEnd;
-    LARGE_INTEGER mFreq;
-  };
-}
-
-#else
-
-# include <sys/time.h>
-# include <unistd.h>
-
-namespace TNet
-{
-  class Timer 
-  {
-  public:
-    void 
-    Start()
-    { gettimeofday(&this->mTStart, &mTz); }
-
-    void 
-    End()
-    { gettimeofday(&mTEnd,&mTz); }
-
-    double 
-    Val()
-    {
-      double t1, t2;
-
-      t1 =  (double)mTStart.tv_sec + (double)mTStart.tv_usec/(1000*1000);
-      t2 =  (double)mTEnd.tv_sec + (double)mTEnd.tv_usec/(1000*1000);
-      return t2-t1;
-    }
-
-  private:
-    struct timeval mTStart;
-    struct timeval mTEnd;
-    struct timezone mTz;
-  };
-}
-
-#endif
-
-
-
-
-
-
-
-///////////////////////////////////////////////////////////////
-// Macros for adding the time intervals to time accumulator
-#if PROFILING==1
-#  define TIMER_START(timer) timer.Start()
-#  define TIMER_END(timer,sum) timer.End(); sum += timer.Val()
-#else
-#  define TIMER_START(timer) 
-#  define TIMER_END(timer,sum) 
-#endif
-
-#endif
-
-
-
diff --git a/tnet_io/KaldiLib/Tokenizer.cc b/tnet_io/KaldiLib/Tokenizer.cc
deleted file mode 100644
index 0c49050..0000000
--- a/tnet_io/KaldiLib/Tokenizer.cc
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "Tokenizer.h"
-#include "string.h"
-
-namespace TNet
-{
-  //****************************************************************************
-  //****************************************************************************
-  void
-  Tokenizer::
-  AddString(const char* pString)
-  {
-    // copy into string struct, which is more convenient
-    std::string       aux_string(pString);
-    std::string       aux_record;
-    std::string::size_type    cur_pos = 0;
-    std::string::size_type    old_pos = 0;
-    std::string::size_type    search_start = 0;
-
-    // make sure we have enough space
-    aux_record.reserve(aux_string.length());
-
-    // find all of separators and make a list of tokens
-    while(old_pos < std::string::npos) {
-      // find the next separator
-      cur_pos = aux_string.find_first_of(mSeparator, search_start);
-
-      // if backslash is in front of separator, ignore this separator
-      if (cur_pos != 0 && cur_pos != std::string::npos && 
-          pString[cur_pos - 1] == '\\') {
-        search_start = cur_pos + 1;
-        continue;
-      }
-
-      // we don't want to have empty records
-      if (!(cur_pos == old_pos && mSkipEmpty)) {
-        // extract token
-        aux_record.insert(0, pString+old_pos, cur_pos==std::string::npos ? strlen(pString+old_pos) : cur_pos - old_pos);
-        // insert to list
-        this->push_back(aux_record);
-
-        // we don't need the contents of the token
-        aux_record.erase();
-      }
-
-      // update old position so that it points behind the separator
-      old_pos = cur_pos < std::string::npos ? cur_pos + 1 : cur_pos;
-      search_start = old_pos;
-    }
-  }
-
-
-} // namespace TNet
-
diff --git a/tnet_io/KaldiLib/Tokenizer.h b/tnet_io/KaldiLib/Tokenizer.h
deleted file mode 100644
index 1be717b..0000000
--- a/tnet_io/KaldiLib/Tokenizer.h
+++ /dev/null
@@ -1,45 +0,0 @@
-#include <list>
-#include <string>
-
-namespace TNet {
-  /** 
-   * @brief General string tokenizer
-   */
-  class Tokenizer 
-  : public std::list<std::string>
-  {
-  public:
-    // Constructors and Destructors ............................................
-    Tokenizer(const char* pSeparator, bool skipEmpty = false)
-    : std::list<std::string>(), mSeparator(pSeparator), mSkipEmpty(skipEmpty)
-    {}
-
-    Tokenizer(const char* pString, const char* pSeparator, bool skipEmpty = false)
-    : std::list<std::string>(), mSeparator(pSeparator), mSkipEmpty(skipEmpty)
-    { AddString(pString); }
-
-    ~Tokenizer()
-    {}
-
-    /** 
-     * @brief Parses a string and appends the tokens to the list
-     * @param pString string to parse
-     */
-    void
-    AddString(const char* pString);
-
-    /** 
-     * @brief Constant accessor to the separators string
-     * @return Const refference
-     */
-    const std::string&
-    Separator() const
-    {return mSeparator;}
-
-  private:
-    std::string mSeparator;   ///< holds the list of separators
-    bool        mSkipEmpty;   ///< if true, multiple separators will be regarded as one
-  }; // class Tokenizer
-} // namespace TNet
-
-
diff --git a/tnet_io/KaldiLib/Types.h b/tnet_io/KaldiLib/Types.h
deleted file mode 100644
index 6a5bfac..0000000
--- a/tnet_io/KaldiLib/Types.h
+++ /dev/null
@@ -1,78 +0,0 @@
-#ifndef TNet_Types_h
-#define TNet_Types_h
-
-#ifdef HAVE_ATLAS
-extern "C"{
-  #include <cblas.h>
-  #include <clapack.h>
-}
-#endif
-
-
-namespace TNet 
-{
-  // TYPEDEFS ..................................................................
-#if DOUBLEPRECISION
-  typedef double  BaseFloat;
-#else
-  typedef float   BaseFloat;
-#endif
-
-#ifndef UINT_16
-  typedef unsigned short  UINT_16   ;
-  typedef unsigned        UINT_32   ;
-  typedef short           INT_16    ;
-  typedef int             INT_32    ;
-  typedef float           FLOAT_32  ;
-  typedef double          DOUBLE_64 ;
-#endif
-
-
-
-  // ...........................................................................
-  // The following declaration assumes that SSE instructions are enabled
-  // and that we are using GNU C/C++ compiler, which defines the __attribute__ 
-  // notation.
-  //
-  // ENABLE_SSE is defined in <config.h>. Its value depends on options given
-  // in the configure phase of builidng the library
-#if defined(__GNUC__ )
-  // vector of four single floats
-  typedef float  v4sf __attribute__((vector_size(16))); 
-  // vector of two single doubles
-  typedef double v2sd __attribute__((vector_size(16))); 
-
-  typedef BaseFloat BaseFloat16Aligned __attribute__((aligned(16))) ;
-
-  typedef union 
-  {
-    v4sf    v;
-    float   f[4];
-  } f4vector; 
-
-  typedef union 
-  {
-    v2sd    v;
-    double  f[2];
-  } d2vector; 
-#endif // ENABLE_SSE && defined(__GNUC__ )
-
-
-
-  typedef enum
-  {
-#ifdef HAVE_ATLAS
-    TRANS    = CblasTrans,
-    NO_TRANS = CblasNoTrans
-#else
-    TRANS    = 'T',
-    NO_TRANS = 'N'
-#endif
-  } MatrixTrasposeType;
-
-
-
-} // namespace TNet
-
-#endif // #ifndef TNet_Types_h
-
diff --git a/tnet_io/KaldiLib/UserInterface.cc b/tnet_io/KaldiLib/UserInterface.cc
deleted file mode 100644
index b59a6c5..0000000
--- a/tnet_io/KaldiLib/UserInterface.cc
+++ /dev/null
@@ -1,669 +0,0 @@
-#include <stdexcept>
-#include <sstream>
-#include <stdarg.h>
-
-#include "UserInterface.h"
-#include "StkStream.h"
-#include "Features.h"
-
-namespace TNet
-{
-  //***************************************************************************
-  //***************************************************************************
-  int 
-  npercents(const char *str)
-  {
-    int ret = 0;
-    while (*str) if (*str++ == '%') ret++;
-    return ret;
-  }
-  
-
-  //***************************************************************************
-  //***************************************************************************
-  void 
-  UserInterface::
-  ReadConfig(const char *file_name)
-  {
-    std::string   line_buf;
-    std::string::iterator chptr;
-    std::string   key;
-    std::string   value;
-    std::ostringstream ss;
-    int           line_no = 0;
-    IStkStream    i_stream;
-
-
-    i_stream.open(file_name, std::ios::binary);
-    if (!i_stream.good()) {
-      throw std::runtime_error(std::string("Cannot open input config file ")
-          + file_name);
-    }
-    i_stream >> std::ws;
-
-    while (!i_stream.eof()) {
-      size_t i_pos;
-
-      // read line
-      std::getline(i_stream, line_buf);
-      i_stream >> std::ws;
-
-      if (i_stream.fail()) {
-        throw std::runtime_error(std::string("Error reading (") 
-            + file_name + ":" + (ss << line_no,ss).str() + ")");
-      }
-
-      // increase line counter
-      line_no++;
-
-      // cut comments
-      if (std::string::npos != (i_pos = line_buf.find('#'))) {
-        line_buf.erase(i_pos);
-      }
-
-      // cut leading and trailing spaces
-      Trim(line_buf);
-
-      // if empty line, then skip it
-      if (0 == line_buf.length()) {
-        continue;
-      }
-  
-      // line = line_buf.c_str();
-      // chptr = parptr;
-
-      chptr = line_buf.begin();
-
-      for (;;) {
-        // Replace speces by '_', which is removed in InsertConfigParam
-        while (isalnum(*chptr) || *chptr == '_' || *chptr == '-') {
-          chptr++;
-        }
-
-        while (std::isspace(*chptr)) {
-          *chptr = '_';
-          chptr++;
-        }
-
-        if (*chptr != ':') {
-          break;
-        }
-
-        chptr++;
-
-        while (std::isspace(*chptr)) {
-          *chptr = '_';
-          chptr++;
-        }
-      }
-      
-      if (*chptr != '=') {
-        throw std::runtime_error(std::string("Character '=' expected (") 
-            + file_name + ":" + (ss.str(""),ss<<line_no,ss).str() + ")");
-      }
-
-      key.assign(line_buf.begin(), chptr);
-
-      chptr++;
-
-      value.assign(chptr, line_buf.end());
-
-      ParseHTKString(value, value);
-      InsertConfigParam(key.c_str(), value.c_str(), 'C');
-    }
-  
-    i_stream.close();
-  }
-  
-
-  //***************************************************************************
-  //***************************************************************************
-  void 
-  UserInterface::
-  InsertConfigParam(const char *pParamName, const char *value, int optionChar) 
-  {
-    std::string key(pParamName);
-    std::string::iterator i_key = key.begin();
-
-    while (i_key != key.end()) {
-      if (*i_key == '-' || *i_key == '_') {
-        i_key = key.erase(i_key);
-      }
-      else {
-        *i_key = toupper(*i_key);
-        i_key ++;
-      }
-    }
-  
-    mMap[key].mValue  = value;
-    mMap[key].mRead   = false;
-    mMap[key].mOption = optionChar;
-  }
-  
-  //***************************************************************************
-  //***************************************************************************
-  int 
-  UserInterface::
-  ParseOptions(
-    int             argc,
-    char*           argv[],
-    const char*     pOptionMapping,
-    const char*     pToolName)
-  {
-    int          i;
-    int          opt = '?';
-    int          optind;
-    bool         option_must_follow = false;
-    char         param[1024];
-    char*        value;
-    const char*  optfmt;
-    const char*  optarg;
-    char*        chptr;
-    char*        bptr;
-    char         tstr[4] = " -?";
-    unsigned long long option_mask = 0;
-    std::ostringstream ss;
-  
-    #define MARK_OPTION(ch) {if (isalpha(ch)) option_mask |= 1ULL << ((ch) - 'A');}
-    #define OPTION_MARK(ch) (isalpha(ch) && ((1ULL << ((ch) - 'A')) & option_mask))
-    #define IS_OPTION(str) ((str)[0] == '-' && (isalpha((str)[1]) || (str)[1] == '-'))
- 
-    //search for the -A param
-    for (optind = 1; optind < argc; optind++) {
-      // we found "--", no -A
-      if (!strcmp(argv[optind], "--")) {
-        break;
-      }
-
-      //repeat till we find -A
-      if (argv[optind][0] != '-' || argv[optind][1] != 'A') {
-        continue;
-      }
-
-      // just "-A" form
-      if (argv[optind][2] != '\0') {
-        throw std::runtime_error(std::string("Unexpected argument '") 
-            + (argv[optind] + 2) + "' after option '-A'");
-      }
-
-      for (i=0; i < argc; i++) {
-        // display all params
-        if(strchr(argv[i], ' ') || strchr(argv[i], '*')) 
-          std::cout << '\'' << argv[i] << '\'' << " ";
-        else std::cout << argv[i] << " ";
-      }
-
-      std::cout << std::endl;
-
-      break;
-    }
-
-    for (optind = 1; optind < argc; optind++) {
-      // find the '-C?' parameter (possible two configs)
-      if (!strcmp(argv[optind], "--")) break;
-      if (argv[optind][0] != '-' || argv[optind][1] != 'C') continue;
-      if (argv[optind][2] != '\0') {
-        ReadConfig(argv[optind] + 2);
-      } else if (optind+1 < argc && !IS_OPTION(argv[optind+1])) {
-        ReadConfig(argv[++optind]);
-      } else {
-        throw std::runtime_error("Config file name expected after option '-C'");
-      }
-    }
-
-    for (optind = 1; optind < argc; optind++) {
-      if (!strcmp(argv[optind], "--")) break;
-      if (argv[optind][0] != '-' || argv[optind][1] != '-') continue;
-
-      bptr = new char[strlen(pToolName) + strlen(argv[optind]+2) + 2];
-      strcat(strcat(strcpy(bptr, pToolName), ":"), argv[optind]+2);
-      value = strchr(bptr, '=');
-      if (!value) {
-        throw std::runtime_error(std::string("Character '=' expected after option '")
-            + argv[optind] + "'");
-      }
-
-      *value++ = '\0';
-      
-      InsertConfigParam(bptr, value /*? value : "TRUE"*/, '-');
-      delete [] bptr;
-    }
-
-    for (optind = 1; optind < argc && IS_OPTION(argv[optind]); optind++) {
-      option_must_follow = false;
-      tstr[2] = opt = argv[optind][1];
-      optarg = argv[optind][2] != '\0' ? argv[optind] + 2 : NULL;
-  
-      if (opt == '-' && !optarg) {    // '--' terminates the option list
-        return optind+1;
-      }
-      if (opt == 'C' || opt == '-') { // C, A and long options have been already processed
-        if (!optarg) optind++;
-        continue;
-      }
-      if (opt == 'A') continue;
-  
-      chptr = strstr((char*)pOptionMapping, tstr);
-      if (chptr == NULL) {
-        throw std::runtime_error(std::string("Invalid command line option '-") 
-            + static_cast<char>(opt) + "'");
-      }
-  
-      chptr += 3;
-      while (std::isspace(*chptr)) {
-        chptr++;
-      }
-  
-      if (!chptr || chptr[0] == '-') {// Option without format string will be ignored
-        optfmt = " ";
-      } else {
-        optfmt = chptr;
-        while (*chptr && !std::isspace(*chptr)) {
-          chptr++;
-        }
-        if (!*chptr) {
-          throw std::runtime_error("Fatal: Unexpected end of optionMap string");
-        }
-      }
-      for (i = 0; !std::isspace(*optfmt); optfmt++) {
-        while (std::isspace(*chptr)) chptr++;
-        value = chptr;
-        while (*chptr && !std::isspace(*chptr)) chptr++;
-        assert(static_cast<unsigned int>(chptr-value+1) < sizeof(param));
-        strncat(strcat(strcpy(param, pToolName), ":"), value, chptr-value);
-        param[chptr-value+strlen(pToolName)+1] = '\0';
-        switch (*optfmt) {
-          case 'n': 
-            value = strchr(param, '=');
-            if (value) *value = '\0';
-            InsertConfigParam(param,
-                              value ? value + 1: "TRUE", opt);
-            break;
-
-          case 'l':
-          case 'o':
-          case 'r': 
-            i++;
-            if (!optarg && (optind+1==argc || IS_OPTION(argv[optind+1]))) {
-              if (*optfmt == 'r' || *optfmt == 'l') {
-                throw std::runtime_error(std::string("Argument ") 
-                    + (ss<<i,ss).str() + " of option '-" 
-                    + static_cast<char>(opt) + "' expected");
-              }
-              optfmt = "  "; // Stop reading option arguments
-              break;
-            }
-            if (!optarg) optarg = argv[++optind];
-            if (*optfmt == 'o') {
-              option_must_follow = (bool) 1;
-            }
-            bptr = NULL;
-
-            // For repeated use of option with 'l' (list) format, append
-            // ',' and argument string to existing config parameter value.
-            if (*optfmt == 'l' && OPTION_MARK(opt)) {
-              bptr = strdup(GetStr(param, ""));
-              if (bptr == NULL) throw std::runtime_error("Insufficient memory");
-              bptr = (char*) realloc(bptr, strlen(bptr) + strlen(optarg) + 2);
-              if (bptr == NULL) throw std::runtime_error("Insufficient memory");
-              strcat(strcat(bptr, ","), optarg);
-              optarg = bptr;
-            }
-            MARK_OPTION(opt);
-            InsertConfigParam(param, optarg, opt);
-            free(bptr);
-            optarg = NULL;
-            break;
-
-          default : 
-            throw std::runtime_error(std::string("Fatal: Invalid character '")
-                + *optfmt + "' in optionMap after " + tstr);
-        }
-      }
-      if (optarg) {
-        throw std::runtime_error(std::string("Unexpected argument '")
-            + optarg + "' after option '-" 
-            + static_cast<char>(opt) + "'");
-      }
-    }
-  
-    for (i = optind; i < argc && !IS_OPTION(argv[i]); i++)
-    {}
-   
-    if (i < argc) {
-      throw std::runtime_error(std::string("No option expected after first non-option argument '")
-          + argv[optind] + "'");
-    }
-
-    if (option_must_follow) {
-      throw std::runtime_error(std::string("Option '-")
-          + static_cast<char>(opt) 
-          + "' with optional argument must not be the last option");
-    }
-
-    return optind;
-  }
-  
-
-  //***************************************************************************
-  //***************************************************************************
-  int 
-  UserInterface::
-  GetFeatureParams(
-    int *           derivOrder,
-    int **          derivWinLens,
-    int *           startFrmExt,
-    int *           endFrmExt,
-    char **         CMNPath,
-    char **         CMNFile,
-    const char **   CMNMask,
-    char **         CVNPath,
-    char **         CVNFile,
-    const char **   CVNMask,
-    const char **   CVGFile,
-    const char *    pToolName,
-    int             pseudoModeule)
-  {
-    const char *  str;
-    int           targetKind;
-    char *        chrptr;
-    char          paramName[32];
-    const char *  CMNDir;
-    const char *  CVNDir;
-    
-    strcpy(paramName, pToolName);
-    strcat(paramName, pseudoModeule == 1 ? "SPARM1:" :
-                      pseudoModeule == 2 ? "SPARM2:" : "");
-                      
-    chrptr = paramName + strlen(paramName);
-  
-    strcpy(chrptr, "STARTFRMEXT");
-    *startFrmExt = GetInt(paramName, 0);
-    strcpy(chrptr, "ENDFRMEXT");
-    *endFrmExt   = GetInt(paramName, 0);
-  
-    *CMNPath = *CVNPath = NULL;
-    strcpy(chrptr, "CMEANDIR");
-    CMNDir       = GetStr(paramName, NULL);
-    strcpy(chrptr, "CMEANMASK");
-    *CMNMask     = GetStr(paramName, NULL);
-
-    if (*CMNMask != NULL) {
-      *CMNPath = (char*) malloc((CMNDir ? strlen(CMNDir) : 0) + npercents(*CMNMask) + 2);
-      if (*CMNPath == NULL) throw std::runtime_error("Insufficient memory");
-      if (CMNDir != NULL) strcat(strcpy(*CMNPath, CMNDir), "/");
-      *CMNFile = *CMNPath + strlen(*CMNPath);
-    }
-    strcpy(chrptr, "VARSCALEDIR");
-    CVNDir      = GetStr(paramName, NULL);
-    strcpy(chrptr, "VARSCALEMASK");
-    *CVNMask     = GetStr(paramName, NULL);
-
-
-    if (*CVNMask != NULL) {
-      *CVNPath = (char*) malloc((CVNDir ? strlen(CVNDir) : 0) + npercents(*CVNMask) + 2);
-      if (*CVNPath == NULL) throw std::runtime_error("Insufficient memory");
-      if (CVNDir != NULL) strcat(strcpy(*CVNPath, CVNDir), "/");
-      *CVNFile = *CVNPath + strlen(*CVNPath);
-    }
-    strcpy(chrptr, "VARSCALEFN");
-    *CVGFile     = GetStr(paramName, NULL);
-    strcpy(chrptr, "TARGETKIND");
-    str = GetStr(paramName, "ANON");
-
-    targetKind = FeatureRepository::ReadParmKind(str, false);
-
-    if (targetKind == -1) {
-      throw std::runtime_error(std::string("Invalid TARGETKIND = '")
-          + str + "'");
-    }
-  
-    strcpy(chrptr, "DERIVWINDOWS");
-    if ((str = GetStr(paramName, NULL)) != NULL) {
-      long lval;
-      *derivOrder      = 0;
-      *derivWinLens = NULL;
-      
-      if (NULL != str)
-      {
-        while ((str = strtok((char *) str, " \t_")) != NULL) 
-        {
-          lval = strtol(str, &chrptr, 0);
-          if (!*str || *chrptr) {
-            throw std::runtime_error("Integers separated by '_' expected for parameter DERIVWINDOWS");
-          }
-          *derivWinLens = (int *)realloc(*derivWinLens, ++*derivOrder*sizeof(int));
-          if (*derivWinLens == NULL) throw std::runtime_error("Insufficient memory");
-          (*derivWinLens)[*derivOrder-1] = lval;
-          str = NULL;
-        }
-      }
-      
-      return targetKind;
-    }
-    *derivOrder = targetKind & PARAMKIND_T ? 3 :
-                  targetKind & PARAMKIND_A ? 2 :
-                  targetKind & PARAMKIND_D ? 1 : 0;
-  
-    if (*derivOrder || targetKind != PARAMKIND_ANON) {
-    *derivWinLens = (int *) malloc(3 * sizeof(int));
-      if (*derivWinLens == NULL) throw std::runtime_error("Insufficient memory");
-  
-      strcpy(chrptr, "DELTAWINDOW");
-      (*derivWinLens)[0] = GetInt(paramName, 2);
-      strcpy(chrptr, "ACCWINDOW");
-      (*derivWinLens)[1] = GetInt(paramName, 2);
-      strcpy(chrptr, "THIRDWINDOW");
-      (*derivWinLens)[2] = GetInt(paramName, 2);
-      return targetKind;
-    }
-    *derivWinLens = NULL;
-    *derivOrder   = -1;
-    return targetKind;
-  }
-  
-
-  //***************************************************************************
-  //***************************************************************************
-  UserInterface::ValueRecord*
-  UserInterface::
-  GetParam(const char* pParamName)
-  {
-    MapType::iterator it;
-
-    // this is done only for convenience. in the loop we will increase the 
-    // pointer again
-    pParamName--;
-
-    // we iteratively try to find the param name in the map. if an attempt 
-    // fails, we strip off all characters until the first ':' and we search 
-    // again
-    do {
-      pParamName++;
-      it = mMap.find(pParamName);
-    } while ((it == mMap.end()) && (NULL != (pParamName = strchr(pParamName, ':'))));
-
-    if (it == mMap.end()) {
-      return NULL;
-    }
-    else {
-      it->second.mRead = true;
-      return &(it->second);
-    }
-  }
-  
-
-  //***************************************************************************
-  //***************************************************************************
-  const char * 
-  UserInterface::
-  GetStr(
-    const char *    pParamName,
-    const char *    default_value)
-  {
-    ValueRecord* p_val = GetParam(pParamName);
-
-    if (NULL == p_val) {
-      return default_value;
-    }
-    else {
-      return p_val->mValue.c_str();
-    }
-  }
-  
-
-  //***************************************************************************
-  //***************************************************************************
-  long 
-  UserInterface::
-  GetInt(
-    const char *pParamName,
-    long default_value)
-  {
-    char *chrptr;
-    ValueRecord* p_val = GetParam(pParamName);
-
-    if (NULL == p_val) {
-      return default_value;
-    }
-  
-    const char *val = p_val->mValue.c_str();
-    default_value = strtol(val, &chrptr, 0);
-    if (!*val || *chrptr) {
-      throw std::runtime_error(std::string("Integer number expected for ") 
-          + pParamName + " but found '" + val + "'");
-    }
-    return default_value;
-  }
-  
-  //***************************************************************************
-  //***************************************************************************
-  float 
-  UserInterface::
-  GetFlt(
-    const char *      pParamName,
-    float             default_value)
-  {
-    char *chrptr;
-    ValueRecord* p_val = GetParam(pParamName);
-
-    if (NULL == p_val) {
-      return default_value;
-    }
-  
-    const char *val = p_val->mValue.c_str();
-    default_value = strtod(val, &chrptr);
-    if (!*val || *chrptr) {
-      throw std::runtime_error(std::string("Decimal number expected for ") 
-          + pParamName + " but found '" + val + "'");
-    }
-    return default_value;
-  }
-  
-  //***************************************************************************
-  //***************************************************************************
-  bool 
-  UserInterface::
-  GetBool(
-    const char *    pParamName,
-    bool            default_value)
-  {
-    ValueRecord* p_val = GetParam(pParamName);
-
-    if (NULL == p_val) {
-      return default_value;
-    }
-  
-    const char* val = p_val->mValue.c_str();
-
-    if (!strcasecmp(val, "TRUE") || !strcmp(val, "T")) return 1;
-    if (strcasecmp(val, "FALSE") && strcmp(val, "F")) {
-      throw std::runtime_error(std::string("TRUE or FALSE expected for ")
-          + pParamName + " but found '" + val + "'");
-    }
-    return false;
-  }
-  
-  //***************************************************************************
-  //***************************************************************************
-  // '...' are pairs: string and corresponding integer value , terminated by NULL
-  int 
-  UserInterface::
-  GetEnum(
-    const char *    pParamName,
-    int             default_value, 
-    ...)  
-  {
-    ValueRecord* p_val = GetParam(pParamName);
-
-    if (NULL == p_val) {
-      return default_value;
-    }
-
-    const char* val = p_val->mValue.c_str();
-    char*       s;
-    int i = 0, cnt = 0, l = 0;
-    va_list ap;
-  
-    va_start(ap, default_value);
-    while ((s = va_arg(ap, char *)) != NULL) {
-      l += strlen(s) + 2;
-      ++cnt;
-      i = va_arg(ap, int);
-      if (!strcmp(val, s)) break;
-    }
-    va_end(ap);
-
-    if (s) {
-      return i;
-    }
-  
-    //To report error, create string listing all possible values
-    s = (char*) malloc(l + 1);
-    s[0] = '\0';
-    va_start(ap, default_value);
-    for (i = 0; i < cnt; i++) {
-      strcat(s, va_arg(ap, char *));
-      va_arg(ap, int);
-      if (i < cnt - 2) strcat(s, ", ");
-      else if (i == cnt - 2) strcat(s, " or ");
-    }
-
-    va_end(ap);
-
-    throw std::runtime_error(std::string(s) + " expected for "
-        + pParamName + " but found '" + val + "'");
-
-    return 0;
-  }
-  
-
-  //***************************************************************************
-  //***************************************************************************
-  void
-  UserInterface::
-  PrintConfig(std::ostream& rStream)
-  {
-    rStream << "Configuration Parameters[" << mMap.size() << "]\n";
-    for (MapType::iterator it = mMap.begin(); it != mMap.end(); ++it) {
-      rStream << (it->second.mRead ? "  " : "# ") 
-        << std::setw(35) << std::left << it->first << " = "
-        << std::setw(30) << std::left << it->second.mValue 
-        << " # -" << it->second.mOption << std::endl;
-    }
-  }
-  
-  //***************************************************************************
-  //***************************************************************************
-  void 
-  UserInterface::
-  CheckCommandLineParamUse()
-  {
-    for (MapType::iterator it = mMap.begin(); it != mMap.end(); ++it) {
-      if (!it->second.mRead && it->second.mOption != 'C') {
-        Error("Unexpected command line parameter " + it->first);
-      }
-    }
-  }
-
-}
diff --git a/tnet_io/KaldiLib/UserInterface.h b/tnet_io/KaldiLib/UserInterface.h
deleted file mode 100644
index fa189e7..0000000
--- a/tnet_io/KaldiLib/UserInterface.h
+++ /dev/null
@@ -1,166 +0,0 @@
-#ifndef TNet_UserInterface_h
-#define TNet_UserInterface_h
-
-#include <iostream>
-#include <cstdlib>
-#include <string>
-#include <map>
-
-namespace TNet 
-{
-  /** **************************************************************************
-   ** **************************************************************************
-   */
-  class UserInterface 
-  {
-  public:
-    struct ValueRecord {
-      std::string   mValue;
-      char          mOption;
-      bool          mRead;
-    };
-
-
-    void InsertConfigParam(
-      const char *param_name,
-      const char *value,
-      int optionChar);
-    
-
-    void 
-    ReadConfig(const char *pFileName);
-
-
-    void 
-    CheckCommandLineParamUse();
-    
-
-    /** 
-     * @brief Retreives the content of a parameter
-     * @param pParamName Name of the parameter to look for
-     * @return Returns the pointer to the ValueRecord structure if success,
-     *         otherwise return NULL
-     *
-     *  We iteratively try to find the param name in the map. If an attempt 
-     *  fails, we strip off all characters until the first occurance of ':' 
-     *  and we search again
-     */
-    ValueRecord*
-    GetParam(const char* pParamName);
-
-
-    /** 
-     * @brief Returns the parameter's value as string
-     * 
-     * @param param_name Parameter name
-     * @param default_value Value, which is returned in case the parameter 
-     * was not found
-     * 
-     * @return Pointer to the begining of the string if success, default_value
-     * otherwise
-     */
-    const char* 
-    GetStr( const char *param_name, const char *default_value);
-    
-
-    /** 
-     * @brief Returns the parameter's value as int
-     * 
-     * @param param_name Parameter name
-     * @param default_value Value, which is returned in case the parameter 
-     * was not found
-     * 
-     * @return Returns the integer value if success, default_value
-     * otherwise
-     */
-    long 
-    GetInt( const char *param_name, long default_value);
-    
-
-    /** 
-     * @brief Returns the parameter's value as float
-     * 
-     * @param param_name Parameter name
-     * @param default_value Value, which is returned in case the parameter 
-     * was not found
-     * 
-     * @return Returns the float value if success, default_value
-     * otherwise
-     */
-    float 
-    GetFlt( const char *param_name, float default_value);
-    
-
-    /** 
-     * @brief Returns the parameter's value as bool
-     * 
-     * @param param_name Parameter name
-     * @param default_value Value, which is returned in case the parameter 
-     * was not found
-     * 
-     * @return Returns the bool value if success, default_value
-     * otherwise
-     *
-     * Note that true is returned if the value is 'TRUE' or 'T', false is
-     * returned if the value is 'FALSE' or 'F'. Otherwise exception is thrown
-     */
-    bool 
-    GetBool(const char *param_name, bool default_value);
-    
-
-    /** 
-     * @brief Returns the parameter's value as enum integer
-     * 
-     * @param param_name Parameter name
-     * @param default_value Value, which is returned in case the parameter 
-     * was not found
-     * 
-     * @return Returns the index value if success, default_value
-     * otherwise
-     *
-     * Variable arguments specify the possible values of this parameter. If the
-     * value does not match any of these, exception is thrown.
-     */
-    int 
-    GetEnum( const char *param_name, int default_value, ...);
-    
-
-    int GetFeatureParams(
-        int *derivOrder,
-        int **derivWinLens,
-        int *startFrmExt,
-        int *endFrmExt,
-        char **CMNPath,
-        char **CMNFile,
-        const char **CMNMask,
-        char **CVNPath,
-        char **CVNFile,
-        const char **CVNMask,
-        const char **CVGFile,
-        const char *toolName,
-        int pseudoModeule);
-    
-
-    int ParseOptions(
-        int             argc,
-        char*           argv[],
-        const char*     optionMapping,
-        const char*     toolName);
-
-
-    /** 
-     * @brief Send the defined paramaters to a stream
-     * 
-     * @param rStream stream to use
-     */
-    void
-    PrintConfig(std::ostream& rStream);
-
-  public:
-    typedef std::map<std::string, ValueRecord> MapType;
-    MapType             mMap;
-  };
-}
-
-#endif
-  
diff --git a/tnet_io/KaldiLib/Vector.cc b/tnet_io/KaldiLib/Vector.cc
deleted file mode 100644
index 020bae2..0000000
--- a/tnet_io/KaldiLib/Vector.cc
+++ /dev/null
@@ -1,110 +0,0 @@
-#ifndef TNet_Vector_cc
-#define TNet_Vector_cc
-
-#include <cstdlib>
-#include <cmath>
-#include <cstring>
-#include <fstream>
-#include <iomanip>
-#include "Common.h"
-
-#ifdef HAVE_ATLAS
-extern "C"{
-  #include <cblas.h>
-}
-#endif
-
-#include "Common.h"
-#include "Matrix.h"
-#include "Vector.h"
-
-namespace TNet
-{
-
-#ifdef HAVE_ATLAS
-  template<>
-     float
-    BlasDot<>(const Vector<float>& rA, const Vector<float>& rB)
-    {
-      assert(rA.mDim == rB.mDim);
-      return cblas_sdot(rA.mDim, rA.pData(), 1, rB.pData(), 1);
-    }
-
-  template<>
-     double
-    BlasDot<>(const Vector<double>& rA, const Vector<double>& rB)
-    {
-      assert(rA.mDim == rB.mDim);
-      return cblas_ddot(rA.mDim, rA.pData(), 1, rB.pData(), 1);
-    }
-
-  template<>
-     Vector<float>&
-    Vector<float>::
-    BlasAxpy(const float alpha, const Vector<float>& rV)
-    {
-      assert(mDim == rV.mDim);
-      cblas_saxpy(mDim, alpha, rV.pData(), 1, mpData, 1);
-      return *this;
-    }
-
-  template<>
-     Vector<double>&
-    Vector<double>::
-    BlasAxpy(const double alpha, const Vector<double>& rV)
-    {
-      assert(mDim == rV.mDim);
-      cblas_daxpy(mDim, alpha, rV.pData(), 1, mpData, 1);
-      return *this;
-    }
-
-  template<>
-     Vector<int>&
-    Vector<int>::
-    BlasAxpy(const int alpha, const Vector<int>& rV)
-    {
-      assert(mDim == rV.mDim);
-      for(int i=0; i<Dim(); i++) {
-        (*this)[i] += rV[i];
-      }
-      return *this;
-    }
-
-
-  template<>
-     Vector<float>&
-    Vector<float>::
-    BlasGemv(const float alpha, const Matrix<float>& rM, MatrixTrasposeType trans, const Vector<float>& rV, const float beta)
-    {
-      assert((trans == NO_TRANS && rM.Cols() == rV.mDim && rM.Rows() == mDim)
-          || (trans ==    TRANS && rM.Rows() == rV.mDim && rM.Cols() == mDim));
-
-      cblas_sgemv(CblasRowMajor, static_cast<CBLAS_TRANSPOSE>(trans), rM.Rows(), rM.Cols(), alpha, rM.pData(), rM.Stride(),
-                  rV.pData(), 1, beta, mpData, 1);
-      return *this;
-    }
-
-
-
-  template<>
-     Vector<double>&
-    Vector<double>::
-    BlasGemv(const double alpha, const Matrix<double>& rM, MatrixTrasposeType trans, const Vector<double>& rV, const double beta)
-    {
-      assert((trans == NO_TRANS && rM.Cols() == rV.mDim && rM.Rows() == mDim)
-          || (trans ==    TRANS && rM.Rows() == rV.mDim && rM.Cols() == mDim));
-
-      cblas_dgemv(CblasRowMajor, static_cast<CBLAS_TRANSPOSE>(trans), rM.Rows(), rM.Cols(), alpha, rM.pData(), rM.Stride(),
-                  rV.pData(), 1, beta, mpData, 1);
-      return *this;
-    }
-
-
-#else
-      #error Routines in this section are not implemented yet without BLAS
-#endif
-
-} // namespace TNet
-
-
-#endif // TNet_Vector_tcc
diff --git a/tnet_io/KaldiLib/Vector.h b/tnet_io/KaldiLib/Vector.h
deleted file mode 100644
index 384c5d2..0000000
--- a/tnet_io/KaldiLib/Vector.h
+++ /dev/null
@@ -1,496 +0,0 @@
-//
-// C++ Interface: %{MODULE}
-//
-// Description:
-//
-//
-// Author: %{AUTHOR} <%{EMAIL}>, (C) %{YEAR}
-//
-// Copyright: See COPYING file that comes with this distribution
-//
-//
-
-#ifndef TNet_Vector_h
-#define TNet_Vector_h
-
-#include <cstddef>
-#include <cstdlib>
-#include <stdexcept>
-#include <iostream>
-
-#ifdef HAVE_ATLAS
-extern "C"{
-  #include <cblas.h>
-  #include <clapack.h>
-}
-#endif
-
-#include "Common.h"
-#include "MathAux.h"
-#include "Types.h"
-#include "Error.h"
-
-namespace TNet
-{
-  template<typename _ElemT> class Vector;
-  template<typename _ElemT> class SubVector;
-  template<typename _ElemT> class Matrix;
-  template<typename _ElemT> class SpMatrix;
-
-  // we need to declare the friend functions here
-  template<typename _ElemT>
-    std::ostream & operator << (std::ostream & rOut, const Vector<_ElemT> & rV);
-
-  template<typename _ElemT>
-    std::istream & operator >> (std::istream & rIn, Vector<_ElemT> & rV);
-
-  template<typename _ElemT>
-    _ElemT
-    BlasDot(const Vector<_ElemT>& rA, const Vector<_ElemT>& rB);
-
-  /** **************************************************************************
-   ** **************************************************************************
-   *  @brief Provides a matrix abstraction class
-   *
-   *  This class provides a way to work with matrices in TNet.
-   *  It encapsulates basic operations and memory optimizations.
-   *
-   */
-  template<typename _ElemT>
-    class Vector
-    {
-    public:
-
-    /// defines a type of this
-    typedef Vector<_ElemT> ThisType;
-
-
-    Vector(): mpData(NULL)
-#ifdef STK_MEMALIGN_MANUAL
-    ,mpFreeData(NULL)
-#endif
-    , mDim(0)
-      {}
-
-      /**
-       * @brief Copy constructor
-       * @param rV
-       */
-      Vector(const Vector<_ElemT>& rV)
-  	  { mpData=NULL; Init(rV.Dim()); Copy(rV); }
-
-
-      /* Type conversion constructor. */
-      template<typename _ElemU>
-      explicit Vector(const Vector<_ElemU>& rV)
-  	  { mpData=NULL; Init(rV.Dim()); Copy(rV); }
-
-
-      Vector(const _ElemT* ppData, const size_t s)
-      { mpData=NULL; Init(s); Copy(ppData); }
-
-      explicit Vector(const size_t s, bool clear=true)
-      { mpData=NULL; Init(s,clear); }
-
-      ~Vector()
-      { Destroy(); }
-
-       Vector<_ElemT> &operator = (const Vector <_ElemT> &other)
-       { Init(other.Dim()); Copy(other); return *this; } // Needed for inclusion in std::vector
-
-      Vector<_ElemT>&
-      Init(size_t length, bool clear=true);
-
-      /**
-       * @brief Dealocates the window from memory and resets the dimensions to (0)
-       */
-      void
-      Destroy();
-
-      /**
-       * @brief Returns @c true if vector is initialized
-       */
-      bool
-      IsInitialized() const
-      { return mpData != NULL; }
-
-      /**
-       * @brief Sets all elements to 0
-       */
-      void
-      Zero();
-
-      void
-      Set(_ElemT f);
-
-      inline size_t
-      Dim() const
-      { return mDim; }
-
-      /**
-       * @brief Returns size of matrix in memory (in bytes)
-       */
-      inline size_t
-      MSize() const
-      {
-        return (mDim + (((16 / sizeof(_ElemT)) - mDim%(16 / sizeof(_ElemT)))
-                          % (16 / sizeof(_ElemT)))) * sizeof(_ElemT);
-      }
-
-      /**
-       *  @brief Gives access to the vector memory area
-       *  @return pointer to the first field
-       */
-      inline _ElemT*
-      pData()
-      { return mpData; }
-
-      /**
-       *  @brief Gives access to the vector memory area
-       *  @return pointer to the first field (const version)
-       */
-      inline const _ElemT*
-      pData() const
-      { return mpData; }
-
-      /**
-       *  @brief Gives access to a specified vector element (const).
-       */
-      inline _ElemT
-      operator [] (size_t i) const
-      {
-#ifdef PARANOID
-		assert(i<mDim);
-#endif
-		return *(mpData + i);
-	  }
-
-      /**
-       *  @brief Gives access to a specified vector element (non-const).
-       */
-      inline _ElemT &
-      operator [] (size_t i)
-      {
-#ifdef PARANOID
-		assert(i<mDim);
-#endif
-		return *(mpData + i);
-	  }
-
-      /**
-       *  @brief Gives access to a specified vector element (const).
-       */
-      inline _ElemT
-		operator () (size_t i) const
-      {
-#ifdef PARANOID
-		assert(i<mDim);
-#endif
-		return *(mpData + i);
-	  }
-
-      /**
-       *  @brief Gives access to a specified vector element (non-const).
-       */
-      inline _ElemT &
-		operator () (size_t i)
-      {
-#ifdef PARANOID
-		assert(i<mDim);
-#endif
-		return *(mpData + i);
-	  }
-
-      /**
-       * @brief Returns a matrix sub-range
-       * @param o Origin
-       * @param l Length
-       * See @c SubVector class for details
-       */
-      SubVector<_ElemT>
-      Range(const size_t o, const size_t l)
-      { return SubVector<_ElemT>(*this, o, l); }
-
-      /**
-       * @brief Returns a matrix sub-range
-       * @param o Origin
-       * @param l Length
-       * See @c SubVector class for details
-       */
-      const SubVector<_ElemT>
-      Range(const size_t o, const size_t l) const
-      { return SubVector<_ElemT>(*this, o, l); }
-
-
-
-      //########################################################################
-      //########################################################################
-
-      /// Copy data from another vector
-      Vector<_ElemT>&
-      Copy(const Vector<_ElemT>& rV);
-
-      /// Copy data from another vector of a different type.
-      template<typename _ElemU> Vector<_ElemT>&
-      Copy(const Vector<_ElemU>& rV);
-
-
-      /// Load data into the vector
-      Vector<_ElemT>&
-      Copy(const _ElemT* ppData);
-
-      Vector<_ElemT>&
-      CopyVectorizedMatrixRows(const Matrix<_ElemT> &rM);
-
-      Vector<_ElemT>&
-      RemoveElement(size_t i);
-
-      Vector<_ElemT>&
-      ApplyLog();
-
-      Vector<_ElemT>&
-      ApplyLog(const Vector<_ElemT>& rV);//ApplyLog to rV and put the result in (*this)
-
-      Vector<_ElemT>&
-      ApplyExp();
-
-      Vector<_ElemT>&
-      ApplySoftMax();
-
-      Vector<_ElemT>&
-      Invert();
-
-      Vector<_ElemT>&
-      DotMul(const Vector<_ElemT>& rV); // Multiplies each element (*this)(i) by rV(i).
-
-      Vector<_ElemT>&
-      BlasAxpy(const _ElemT alpha, const Vector<_ElemT>& rV);
-
-      Vector<_ElemT>&
-      BlasGemv(const _ElemT alpha, const Matrix<_ElemT>& rM, const MatrixTrasposeType trans, const Vector<_ElemT>& rV, const _ElemT beta = 0.0);
-
-
-      //########################################################################
-      //########################################################################
-
-      Vector<_ElemT>&
-      Add(const Vector<_ElemT>& rV)
-      { return BlasAxpy(1.0, rV); }
-
-      Vector<_ElemT>&
-      Subtract(const Vector<_ElemT>& rV)
-      { return BlasAxpy(-1.0, rV); }
-
-      Vector<_ElemT>&
-      AddScaled(_ElemT alpha, const Vector<_ElemT>& rV)
-      { return BlasAxpy(alpha, rV); }
-
-      Vector<_ElemT>&
-      Add(_ElemT c);
-
-      Vector<_ElemT>&
-      MultiplyElements(const Vector<_ElemT>& rV);
-
-      // @brief elementwise : rV.*rR+beta*this --> this
-      Vector<_ElemT>&
-      MultiplyElements(_ElemT alpha, const Vector<_ElemT>& rV, const Vector<_ElemT>& rR,_ElemT beta);
-
-      Vector<_ElemT>&
-      DivideElements(const Vector<_ElemT>& rV);
-
-      /// @brief elementwise : rV./rR+beta*this --> this
-      Vector<_ElemT>&
-      DivideElements(_ElemT alpha, const Vector<_ElemT>& rV, const Vector<_ElemT>& rR,_ElemT beta);
-
-      Vector<_ElemT>&
-      Subtract(_ElemT c);
-
-      Vector<_ElemT>&
-      Scale(_ElemT c);
-
-
-      //########################################################################
-      //########################################################################
-
-      /// Performs a row stack of the matrix rMa
-      Vector<_ElemT>&
-      MatrixRowStack(const Matrix<_ElemT>& rMa);
-
-      // Extracts a row of the matrix rMa.  .. could also do this with vector.Copy(rMa[row]).
-      Vector<_ElemT>&
-      Row(const Matrix<_ElemT>& rMa, size_t row);
-
-      // Extracts a column of the matrix rMa.
-      Vector<_ElemT>&
-      Col(const Matrix<_ElemT>& rMa, size_t col);
-
-      // Takes all elements to a power.
-      Vector<_ElemT>&
-      Power(_ElemT power);
-
-      _ElemT 
-      Max() const;
-
-      _ElemT 
-      Min() const;
-
-      /// Returns sum of the elements
-      _ElemT
-      Sum() const;
-
-      /// Returns sum of the elements
-      Vector<_ElemT>&
-      AddRowSum(const Matrix<_ElemT>& rM);
-
-      /// Returns sum of the elements
-      Vector<_ElemT>&
-      AddColSum(const Matrix<_ElemT>& rM);
-
-      /// Returns log(sum(exp())) without exp overflow
-      _ElemT
-      LogSumExp() const;
-
-      //########################################################################
-      //########################################################################
-
-      friend std::ostream &
-      operator << <> (std::ostream& rOut, const Vector<_ElemT>& rV);
-
-      friend _ElemT
-      BlasDot<>(const Vector<_ElemT>& rA, const Vector<_ElemT>& rB);
-
-      /**
-       * Computes v1^T * M * v2.  
-       * Not as efficient as it could be where v1==v2 (but no suitable blas
-       * routines available).
-       */
-      _ElemT
-      InnerProduct(const Vector<_ElemT> &v1, const Matrix<_ElemT> &M, const Vector<_ElemT> &v2) const;
-
-
-    //##########################################################################
-    //##########################################################################
-    //protected:
-    public:
-      /// data memory area
-      _ElemT*   mpData;
-#ifdef STK_MEMALIGN_MANUAL
-      /// data to be freed (in case of manual memalignment use, see common.h)
-      _ElemT*   mpFreeData;
-#endif
-      size_t  mDim;      ///< Number of elements
-    }; // class Vector
-
-
-
-
-  /**
-   * @brief Represents a non-allocating general vector which can be defined
-   * as a sub-vector of higher-level vector
-   */
-  template<typename _ElemT>
-    class SubVector : public Vector<_ElemT>
-    {
-    protected:
-      /// Constructor
-      SubVector(const Vector<_ElemT>& rT,
-                const size_t  origin,
-                const size_t  length)
-      {
-        assert(origin+length <= rT.mDim);
-        Vector<_ElemT>::mpData = rT.mpData+origin;
-        Vector<_ElemT>::mDim   = length;
-      }
-      //only Vector class can call this protected constructor
-      friend class Vector<_ElemT>; 
-
-    public:
-      /// Constructor
-      SubVector(Vector<_ElemT>& rT,
-                const size_t  origin,
-                const size_t  length)
-      {
-        assert(origin+length <= rT.mDim);
-        Vector<_ElemT>::mpData = rT.mpData+origin;
-        Vector<_ElemT>::mDim   = length;
-      }
-
-
-      /**
-       * @brief Constructs a vector representation out of a standard array
-       *
-       * @param pData pointer to data array to associate with this vector
-       * @param length length of this vector
-       */
-      inline
-      SubVector(_ElemT *ppData,
-                size_t length)
-      {
-        Vector<_ElemT>::mpData = ppData;
-        Vector<_ElemT>::mDim   = length;
-      }
-
-
-      /**
-       * @brief Destructor
-       */
-      ~SubVector()
-      {
-        Vector<_ElemT>::mpData = NULL;
-      }
-    };
-
-
-    // Useful shortcuts
-    typedef Vector<BaseFloat> BfVector;
-    typedef SubVector<BaseFloat> BfSubVector;
-
-    //Adding two vectors of different types
-    template <typename _ElemT, typename _ElemU>
-    void Add(Vector<_ElemT>& rDst, const Vector<_ElemU>& rSrc)
-    {
-      assert(rDst.Dim() == rSrc.Dim());
-      const _ElemU* p_src = rSrc.pData();
-      _ElemT* p_dst = rDst.pData();
-
-      for(size_t i=0; i<rSrc.Dim(); i++) {
-        *p_dst++ += (_ElemT)*p_src++;
-      }
-    }
-   
-      
-    //Scales adding two vectors of different types
-    template <typename _ElemT, typename _ElemU>
-    void AddScaled(Vector<_ElemT>& rDst, const Vector<_ElemU>& rSrc, _ElemT scale)
-    {
-      assert(rDst.Dim() == rSrc.Dim());
-
-      Vector<_ElemT> tmp(rSrc);
-      rDst.BlasAxpy(scale, tmp); 
-
-/*
-      const _ElemU* p_src = rSrc.pData();
-      _ElemT* p_dst = rDst.pData();
-
-      for(size_t i=0; i<rDst.Dim(); i++) {
-        *p_dst++ += *p_src++ * scale;
-      }
-*/
-    }
-
-
-} // namespace TNet
-
-//*****************************************************************************
-//*****************************************************************************
-// we need to include the implementation
-#include "Vector.tcc"
-
-/******************************************************************************
- ******************************************************************************
- * The following section contains specialized template definitions
- * whose implementation is in Vector.cc
- */
-
-
-#endif // #ifndef TNet_Vector_h
diff --git a/tnet_io/KaldiLib/Vector.tcc b/tnet_io/KaldiLib/Vector.tcc
deleted file mode 100644
index 751ffa7..0000000
--- a/tnet_io/KaldiLib/Vector.tcc
+++ /dev/null
@@ -1,638 +0,0 @@
-/** @file Vector.tcc
- *  This is an internal header file, included by other library headers.
- *  You should not attempt to use it directly.
- */
-
-#ifndef TNet_Vector_tcc
-#define TNet_Vector_tcc
-
-#include <cstdlib>
-#include <cmath>
-#include <cstring>
-#include <fstream>
-#include <iomanip>
-#include "Common.h"
-
-#ifdef HAVE_ATLAS
-extern "C"{
-  #include <cblas.h>
-}
-#endif
-
-#include "Common.h"
-#include "MathAux.h"
-#include "Matrix.h"
-
-namespace TNet
-{
-  //******************************************************************************
-  //******************************************************************************
-  template<typename _ElemT>
-    inline Vector<_ElemT>&
-    Vector<_ElemT>::
-    Init(const size_t length, bool clear)
-    {
-	  if(mpData != NULL) Destroy();
-	  if(length==0){
-		mpData=NULL;
-#ifdef STK_MEMALIGN_MANUAL
-		mpFreeData=NULL;
-#endif
-		mDim=0;
-		return *this;
-	  }
-      size_t size;
-      void*  data;
-      void*  free_data;
-
-      size = align<16>(length * sizeof(_ElemT));
-
-      if (NULL != (data = stk_memalign(16, size, &free_data))) {
-        mpData        = static_cast<_ElemT*> (data);
-#ifdef STK_MEMALIGN_MANUAL
-        mpFreeData    = static_cast<_ElemT*> (free_data);
-#endif
-        mDim = length;
-      } else {
-        throw std::bad_alloc();
-      }
-      if(clear) Zero();
-      return *this;
-    }
-
-
-  //******************************************************************************
-  //******************************************************************************
-  /// Copy data from another vector
-  template<typename _ElemT>
-    inline Vector<_ElemT>&
-    Vector<_ElemT>::
-    Copy(const Vector<_ElemT>& rV) {
-      assert(Dim() == rV.Dim());
-      Copy(rV.mpData);
-      return *this;
-    }
-
-  /// Load data into the vector
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    Copy(const _ElemT* ppData) {
-      std::memcpy(this->mpData, ppData, Dim() * sizeof(_ElemT));
-      return *this;
-    }
-
-  template<typename _ElemT>
-  template<typename _ElemU>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    Copy(const Vector<_ElemU> &other){
-      assert(Dim()==other.Dim());
-      size_t D=Dim();
-      for(size_t d=0;d<D;d++) (*this)(d) = (_ElemT) other[d];
-      return *this;
-  }
-
-
-  //******************************************************************************
-  //******************************************************************************
-  template<typename _ElemT>
-  Vector<_ElemT>&
-  Vector<_ElemT>::
-  CopyVectorizedMatrixRows(const Matrix<_ElemT> &rM) {
-//    TraceLog("Dim = "+to_string(Dim())+", Rows = "+to_string(rM.Rows())+", Cols = "+to_string(rM.Cols()));
-    assert(Dim() == rM.Cols()*rM.Rows());
-    size_t nCols = rM.Cols();
-    for(size_t r=0; r<rM.Rows(); r++)
-      Range(r*nCols, nCols).Copy(rM[r]);
-    return *this;
-  }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  // Remove element from the vector. The vector is non reallocated
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    RemoveElement(size_t i) {
-      assert(i < mDim && "Access out of vector");
-      for(size_t j = i + 1; j < mDim; j++)
-        this->mpData[j - 1] = this->mpData[j];
-      mDim--;
-      return *this;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  // The destructor
-  template<typename _ElemT>
-    inline void
-    Vector<_ElemT>::
-    Destroy()
-    {
-      // we need to free the data block if it was defined
-#ifndef STK_MEMALIGN_MANUAL
-      if (NULL != mpData) free(mpData);
-#else
-      if (NULL != mpData) free(mpFreeData);
-      mpFreeData = NULL;
-#endif
-
-      mpData = NULL;
-      mDim = 0;
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    inline void
-    Vector<_ElemT>::
-    Zero()
-    {
-      std::memset(mpData, 0, mDim * sizeof(_ElemT));
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    inline void
-    Vector<_ElemT>::
-    Set(_ElemT f)
-    {
-      for(size_t i=0;i<mDim;i++) mpData[i] = f;
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    MatrixRowStack(const Matrix<_ElemT>& rMa)
-    {
-      assert(mDim == rMa.Cols() * rMa.Rows());
-
-      _ElemT*       inc_data = mpData;
-      const size_t  cols     = rMa.Cols();
-
-      for (size_t i = 0; i < rMa.Rows(); i++)
-      {
-        // copy the data to the propper position
-        memcpy(inc_data, rMa[i], cols * sizeof(_ElemT));
-
-        // set new copy position
-        inc_data += cols;
-      }
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-	  Row(const Matrix<_ElemT> &rMa, size_t row)
-    {
-	  assert(row < rMa.Rows());
-      const _ElemT *mRow = rMa.pRowData(row);
-      // if(mDim != rMa.Cols()) Init(rMa.Cols()); // automatically resize.
-      memcpy(mpData, mRow, sizeof(_ElemT)*mDim);
-	  return *this;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-  Power(_ElemT power) // takes elements to a power.  Throws exception if could not.
-    {
-      for(size_t i=0;i<Dim();i++){
-        _ElemT tmp = (*this)(i);
-        (*this)(i) = pow(tmp, power);
-        if((*this)(i) == HUGE_VAL)
-          throw std::runtime_error((std::string)"Error in Vector::power, could not take " +to_string(tmp)+ " to power " +to_string((*this)(i)));
-      }
-      return (*this);
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    _ElemT
-    Vector<_ElemT>::
-    Max() const 
-    {
-      if(Dim()==0) throw std::runtime_error("Error in Vector::Max(), empty vector\n");
-      _ElemT ans = (*this)(0);
-      for(size_t i=1;i<Dim();i++) ans = std::max(ans, (*this)(i));
-      return ans;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    _ElemT
-    Vector<_ElemT>::
-    Min() const 
-    {
-      if(Dim()==0) throw std::runtime_error("Error in Vector::Min(), empty vector\n");
-      _ElemT ans = (*this)(0);
-      for(size_t i=1;i<Dim();i++) ans = std::min(ans, (*this)(i));
-      return ans;
-    }
-
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-	  Col(const Matrix<_ElemT> &rMa, size_t col)
-  {
-	  assert(col < rMa.Cols());
-      // if(mDim != rMa.Cols()) Init(rMa.Cols()); // automatically resize.
-	  for(size_t i=0;i<mDim;i++)
-		mpData[i] = rMa(i,col); // can't do this efficiently so don't really bother.
-	  return *this;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    _ElemT
-    Vector<_ElemT>::
-    Sum() const
-    {
-      //note the double accumulator
-      double sum = 0.0;
-
-      for (size_t i = 0; i < mDim; ++i) {
-        sum += mpData[i];
-      }
-      return (_ElemT)sum;
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    AddColSum(const Matrix<_ElemT>& rM)
-    {
-      // note the double accumulator
-      double sum;
-
-      assert(mDim == rM.Cols());
-
-      for (size_t i = 0; i < mDim; ++i) {
-        sum = 0.0;
-        for (size_t j = 0; j < rM.Rows(); ++j) {
-          sum += rM[j][i];
-        }
-        mpData[i] += sum;
-      }
-      return *this;
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    AddRowSum(const Matrix<_ElemT>& rM)
-    {
-      // note the double accumulator
-      double sum;
-
-      assert(mDim == rM.Rows());
-
-      for (size_t i = 0; i < mDim; ++i) {
-        sum = 0.0;
-        for (size_t j = 0; j < rM.Cols(); ++j) {
-          sum += rM[i][j];
-        }
-        mpData[i] += sum;
-      }
-      return *this;
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    _ElemT
-    Vector<_ElemT>::
-    LogSumExp() const
-    {
-      double sum = LOG_0;
-
-      for (size_t i = 0; i < mDim; ++i) {
-        sum = LogAdd(sum, mpData[i]);
-      }
-      return sum;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    Invert() {
-      for (size_t i = 0; i < mDim; ++i) {
-        mpData[i] = static_cast<_ElemT>(1 / mpData[i]);
-      }
-      return *this;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    ApplyLog() {
-      for (size_t i = 0; i < mDim; ++i) {
-        mpData[i] = _LOG(mpData[i]);
-      }
-      return *this;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    ApplyLog(const Vector<_ElemT>& rV) {
-      assert(mDim==rV.Dim());
-      for (size_t i = 0; i < mDim; ++i) {
-        mpData[i] = log(rV[i]);
-      }
-      return *this;
-    }
-    
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    ApplyExp() {
-      for (size_t i = 0; i < mDim; ++i) {
-        mpData[i] = _EXP(mpData[i]);
-      }
-      return *this;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    ApplySoftMax() {
-      _ElemT lse = LogSumExp();
-
-      for (size_t i = 0; i < mDim; ++i) {
-        mpData[i] = exp(mpData[i] - lse);
-      }
-      return *this;
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    Add(_ElemT c)
-    {
-      for(size_t i = 0; i < mDim; i++) {
-        mpData[i] += c;
-      }
-      return *this;
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    Subtract(_ElemT c)
-    {
-      for(size_t i = 0; i < mDim; i++) {
-        mpData[i] -= c;
-      }
-      return *this;
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    Scale(_ElemT c)
-    {
-      for(size_t i = 0; i < mDim; i++) {
-        mpData[i] *= c;
-      }
-      return *this;
-    }
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    MultiplyElements(const Vector<_ElemT>& rV)
-    {
-      assert(mDim == rV.Dim());
-      for(size_t i = 0; i < mDim; i++) {
-        mpData[i] *= rV[i];
-      }
-      return *this;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    MultiplyElements(_ElemT alpha, const Vector<_ElemT>& rV, const Vector<_ElemT>& rR, _ElemT beta)
-    {
-      assert((mDim == rV.Dim() && mDim == rR.Dim()));
-      for(size_t i = 0; i < mDim; i++) {
-        mpData[i] = alpha * rV[i] * rR[i] + beta * mpData[i];
-      }
-      return *this;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    DivideElements(const Vector<_ElemT>& rV)
-    {
-      assert(mDim == rV.Dim());
-      for(size_t i = 0; i < mDim; i++) {
-        mpData[i] /= rV[i];
-      }
-      return *this;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-
-  template<typename _ElemT>
-    Vector<_ElemT>&
-    Vector<_ElemT>::
-    DivideElements(_ElemT alpha, const Vector<_ElemT>& rV, const Vector<_ElemT>& rR, _ElemT beta)
-    {
-      assert((mDim == rV.Dim() && mDim == rR.Dim()));
-      for(size_t i = 0; i < mDim; i++) {
-        mpData[i] = alpha * rV[i]/rR[i] + beta * mpData[i] ;
-      }
-      return *this;
-    }
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-  void Load(std::istream& rIn, Vector<_ElemT>& rV)
-    { 
-      std::streamoff pos = rIn.tellg();
-      if(MatrixVectorIostreamControl::Flags(rIn, ACCUMULATE_INPUT)) {
-        for (size_t i = 0; i < rV.Dim(); i++) {
-          _ElemT tmp;
-          rIn >> tmp;
-          rV[i] += tmp;
-        }
-      } else {
-        for (size_t i = 0; i < rV.Dim(); i++) {
-          rIn >> rV[i];
-        }
-      }
-      if(rIn.fail()) { 
-        throw std::runtime_error("Failed to read vector from stream.  File position is "+to_string(pos));
-      }
-    }
-
-  template<typename _ElemT>
-    std::istream &
-     operator >> (std::istream& rIn, Vector<_ElemT>& rV)
-    {
-      rIn >> std::ws;
-      if(rIn.peek() == 'v'){ // "new" format: v <dim> 1.0 0.2 4.3 ...
-        rIn.get();
-        long long int tmp=-1; 
-        rIn >> tmp; 
-        if(rIn.fail() || tmp<0) { 
-          throw std::runtime_error("Failed to read vector from stream: no size"); 
-        }
-        size_t tmp2 = size_t(tmp);
-        assert((long long int)tmp2 == tmp);
-
-        if(rV.Dim() != tmp2) rV.Init(tmp2);
-      }
-      Load(rIn,rV);
-      return rIn;
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    void Save (std::ostream& rOut, const Vector<_ElemT>& rV)
-    {
-
-      for (size_t i = 0; i < rV.Dim(); i++) {
-        rOut << rV[i] << ' ';
-      }
-      if(rOut.fail()) { 
-        throw std::runtime_error("Failed to write vector to stream"); 
-      }
-    }
-
-
-  //****************************************************************************
-  //****************************************************************************
-  template<typename _ElemT>
-    std::ostream &
-    operator << (std::ostream& rOut, const Vector<_ElemT>& rV)
-    {
-      rOut << "v " << rV.Dim() << "  ";
-      Save(rOut,rV);
-      return rOut;
-    }
-
-
-
-  //****************************************************************************
-  //****************************************************************************
-
-#ifdef HAVE_ATLAS
-  template<>
-    float
-   BlasDot<>(const Vector<float>& rA, const Vector<float>& rB);
-
-  template<>
-   double
-   BlasDot<>(const Vector<double>& rA, const Vector<double>& rB);
-
-  template<typename _ElemT>
-    inline Vector<_ElemT>&
-    Vector<_ElemT>::
-   DotMul(const Vector<_ElemT> &rV){
-	 assert(mDim == rV.mDim);
-	 const _ElemT *other_data = rV.pData();
-	 _ElemT *my_data = mpData, *my_data_end = my_data+mDim;
-	 for(;my_data<my_data_end;) *(my_data++) *= *(other_data++);
-	 return *this;
-  }
-
-  template<>
-    Vector<float>&
-    Vector<float>::
-    BlasAxpy(const float alpha, const Vector<float>& rV);
-
-
-  template<>
-    Vector<double>&
-    Vector<double>::
-   BlasAxpy(const double alpha, const Vector<double>& rV);
-
-
-  template<>
-    Vector<float>&
-    Vector<float>::
-    BlasGemv(const float alpha, const Matrix<float>& rM, MatrixTrasposeType trans, const Vector<float>& rV, const float beta);
-
-  template<>
-    Vector<double>&
-    Vector<double>::
-    BlasGemv(const double alpha, const Matrix<double>& rM, MatrixTrasposeType trans, const Vector<double>& rV, const double beta);
-
-#else
-      #error Routines in this section are not implemented yet without BLAS
-#endif
-
-
-  template<class _ElemT>
-  _ElemT
-  InnerProduct(const Vector<_ElemT> &v1, const Matrix<_ElemT> &M, const Vector<_ElemT> &v2){
-    assert(v1.size()==M.Rows() && v2.size()==M.Cols());
-    Vector<_ElemT> vtmp(M.Rows());
-    vtmp.BlasGemv(1.0, M, NO_TRANS, v2, 0.0);
-    return BlasDot(v1, vtmp);
-  }
-
-
-} // namespace TNet
-
-
-#endif // TNet_Vector_tcc
diff --git a/tnet_io/KaldiLib/clapack.cc b/tnet_io/KaldiLib/clapack.cc
deleted file mode 100644
index a486bef..0000000
--- a/tnet_io/KaldiLib/clapack.cc
+++ /dev/null
@@ -1,61 +0,0 @@
-
-extern "C" {
-
-  /**
-   * Wrapper to GotoBLAS lapack for STK and TNet (sgetrf sgetri dgetrf dgetri)
-   */
-  typedef float real;
-  typedef double doublereal;
-  typedef int integer;
-
-
-  /**
-   * The lapack interface (used in gotoblas)
-   */
-  /* Subroutine */ int sgetrf_(integer *m, integer *n, real *a, integer *lda,
-          integer *ipiv, integer *info);
-  /* Subroutine */ int sgetri_(integer *n, real *a, integer *lda, integer *ipiv,
-          real *work, integer *lwork, integer *info);
-  /* Subroutine */ int dgetrf_(integer *m, integer *n, doublereal *a, integer *
-          lda, integer *ipiv, integer *info);
-  /* Subroutine */ int dgetri_(integer *n, doublereal *a, integer *lda, integer
-          *ipiv, doublereal *work, integer *lwork, integer *info);
-
-
-
-
-
-  /**
-   * The clapack interface as used by ATLAS (used in STK, 
-   */
-  enum CBLAS_ORDER {CblasRowMajor=101, CblasColMajor=102 };
-
-  int clapack_sgetrf(const enum CBLAS_ORDER Order, const int M, const int N,
-                     float *A, const int lda, int *ipiv) 
-  {
-    return sgetrf_((int*)&M, (int*)&N, A, (int*)&lda, (int*)ipiv, 0);
-  }
-
-
-  int clapack_sgetri(const enum CBLAS_ORDER Order, const int N, float *A,
-                     const int lda, const int *ipiv) 
-  {
-    return sgetri_((int*)&N, A, (int*)&lda, (int*)ipiv, 0, 0, 0);
-  }
-
-
-  int clapack_dgetrf(const enum CBLAS_ORDER Order, const int M, const int N,
-                     double *A, const int lda, int *ipiv) 
-  {
-    return dgetrf_((int*)&M, (int*)&N, A, (int*)&lda, (int*)ipiv, 0);
-  }
-    
-
-  int clapack_dgetri(const enum CBLAS_ORDER Order, const int N, double *A,
-                     const int lda, const int *ipiv)
-  {
-    return dgetri_((int*)&N, A, (int*)&lda, (int*)ipiv, 0, 0, 0);
-  }
-
-
-}
diff --git a/tnet_io/KaldiLib/clapack.h b/tnet_io/KaldiLib/clapack.h
deleted file mode 100644
index 0c6855d..0000000
--- a/tnet_io/KaldiLib/clapack.h
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- *             Automatically Tuned Linear Algebra Software v3.8.2
- *                    (C) Copyright 1999 R. Clint Whaley
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *   1. Redistributions of source code must retain the above copyright
- *      notice, this list of conditions and the following disclaimer.
- *   2. Redistributions in binary form must reproduce the above copyright
- *      notice, this list of conditions, and the following disclaimer in the
- *      documentation and/or other materials provided with the distribution.
- *   3. The name of the ATLAS group or the names of its contributers may
- *      not be used to endorse or promote products derived from this
- *      software without specific written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ATLAS GROUP OR ITS CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef CLAPACK_H
-
-#define CLAPACK_H
-#include "cblas.h"
-
-#ifndef ATLAS_ORDER
-   #define ATLAS_ORDER CBLAS_ORDER
-#endif
-#ifndef ATLAS_UPLO
-   #define ATLAS_UPLO CBLAS_UPLO
-#endif
-#ifndef ATLAS_DIAG
-   #define ATLAS_DIAG CBLAS_DIAG
-#endif
-int clapack_sgesv(const enum CBLAS_ORDER Order, const int N, const int NRHS,
-                  float *A, const int lda, int *ipiv,
-                  float *B, const int ldb);
-int clapack_sgetrf(const enum CBLAS_ORDER Order, const int M, const int N,
-                   float *A, const int lda, int *ipiv);
-int clapack_sgetrs
-   (const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE Trans,
-    const int N, const int NRHS, const float *A, const int lda,
-    const int *ipiv, float *B, const int ldb);
-int clapack_sgetri(const enum CBLAS_ORDER Order, const int N, float *A,
-                   const int lda, const int *ipiv);
-int clapack_sposv(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo,
-                  const int N, const int NRHS, float *A, const int lda,
-                  float *B, const int ldb);
-int clapack_spotrf(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo,
-                   const int N, float *A, const int lda);
-int clapack_spotrs(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,
-                   const int N, const int NRHS, const float *A, const int lda,
-                   float *B, const int ldb);
-int clapack_spotri(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo,
-                   const int N, float *A, const int lda);
-int clapack_slauum(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo,
-                   const int N, float *A, const int lda);
-int clapack_strtri(const enum ATLAS_ORDER Order,const enum ATLAS_UPLO Uplo,
-                  const enum ATLAS_DIAG Diag,const int N, float *A, const int lda);
-
-int clapack_dgesv(const enum CBLAS_ORDER Order, const int N, const int NRHS,
-                  double *A, const int lda, int *ipiv,
-                  double *B, const int ldb);
-int clapack_dgetrf(const enum CBLAS_ORDER Order, const int M, const int N,
-                   double *A, const int lda, int *ipiv);
-int clapack_dgetrs
-   (const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE Trans,
-    const int N, const int NRHS, const double *A, const int lda,
-    const int *ipiv, double *B, const int ldb);
-int clapack_dgetri(const enum CBLAS_ORDER Order, const int N, double *A,
-                   const int lda, const int *ipiv);
-int clapack_dposv(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo,
-                  const int N, const int NRHS, double *A, const int lda,
-                  double *B, const int ldb);
-int clapack_dpotrf(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo,
-                   const int N, double *A, const int lda);
-int clapack_dpotrs(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,
-                   const int N, const int NRHS, const double *A, const int lda,
-                   double *B, const int ldb);
-int clapack_dpotri(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo,
-                   const int N, double *A, const int lda);
-int clapack_dlauum(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo,
-                   const int N, double *A, const int lda);
-int clapack_dtrtri(const enum ATLAS_ORDER Order,const enum ATLAS_UPLO Uplo,
-                  const enum ATLAS_DIAG Diag,const int N, double *A, const int lda);
-
-int clapack_cgesv(const enum CBLAS_ORDER Order, const int N, const int NRHS,
-                  void *A, const int lda, int *ipiv,
-                  void *B, const int ldb);
-int clapack_cgetrf(const enum CBLAS_ORDER Order, const int M, const int N,
-                   void *A, const int lda, int *ipiv);
-int clapack_cgetrs
-   (const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE Trans,
-    const int N, const int NRHS, const void *A, const int lda,
-    const int *ipiv, void *B, const int ldb);
-int clapack_cgetri(const enum CBLAS_ORDER Order, const int N, void *A,
-                   const int lda, const int *ipiv);
-int clapack_cposv(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo,
-                  const int N, const int NRHS, void *A, const int lda,
-                  void *B, const int ldb);
-int clapack_cpotrf(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo,
-                   const int N, void *A, const int lda);
-int clapack_cpotrs(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,
-                   const int N, const int NRHS, const void *A, const int lda,
-                   void *B, const int ldb);
-int clapack_cpotri(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo,
-                   const int N, void *A, const int lda);
-int clapack_clauum(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo,
-                   const int N, void *A, const int lda);
-int clapack_ctrtri(const enum ATLAS_ORDER Order,const enum ATLAS_UPLO Uplo,
-                  const enum ATLAS_DIAG Diag,const int N, void *A, const int lda);
-
-int clapack_zgesv(const enum CBLAS_ORDER Order, const int N, const int NRHS,
-                  void *A, const int lda, int *ipiv,
-                  void *B, const int ldb);
-int clapack_zgetrf(const enum CBLAS_ORDER Order, const int M, const int N,
-                   void *A, const int lda, int *ipiv);
-int clapack_zgetrs
-   (const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE Trans,
-    const int N, const int NRHS, const void *A, const int lda,
-    const int *ipiv, void *B, const int ldb);
-int clapack_zgetri(const enum CBLAS_ORDER Order, const int N, void *A,
-                   const int lda, const int *ipiv);
-int clapack_zposv(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo,
-                  const int N, const int NRHS, void *A, const int lda,
-                  void *B, const int ldb);
-int clapack_zpotrf(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo,
-                   const int N, void *A, const int lda);
-int clapack_zpotrs(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,
-                   const int N, const int NRHS, const void *A, const int lda,
-                   void *B, const int ldb);
-int clapack_zpotri(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo,
-                   const int N, void *A, const int lda);
-int clapack_zlauum(const enum ATLAS_ORDER Order, const enum ATLAS_UPLO Uplo,
-                   const int N, void *A, const int lda);
-int clapack_ztrtri(const enum ATLAS_ORDER Order,const enum ATLAS_UPLO Uplo,
-                  const enum ATLAS_DIAG Diag,const int N, void *A, const int lda);
-
-#endif
diff --git a/tnet_io/cwrapper.cpp b/tnet_io/cwrapper.cpp
deleted file mode 100644
index 98ad864..0000000
--- a/tnet_io/cwrapper.cpp
+++ /dev/null
@@ -1,148 +0,0 @@
-#include "KaldiLib/Features.h"
-#include "KaldiLib/Labels.h"
-#include "KaldiLib/Common.h"
-#include "KaldiLib/UserInterface.h"
-#include <string>
-#define SNAME "TNET"
-
-extern "C" {
-#include "cwrapper.h"
-#include "string.h"
-#include "../../nerv/common.h"
-
-    extern Matrix *nerv_matrix_host_float_create(long nrow, long ncol, Status *status);
-
-    struct TNetFeatureRepo {
-        TNet::FeatureRepository feature_repo;
-        TNet::UserInterface ui;
-        bool swap_features;
-        int target_kind;
-        int deriv_order;
-        int* p_deriv_win_lenghts;
-        int start_frm_ext;
-        int end_frm_ext;
-        char* cmn_path;
-        char* cmn_file;
-        const char* cmn_mask;
-        char* cvn_path;
-        char* cvn_file;
-        const char* cvn_mask;
-        const char* cvg_file;
-        TNet::Matrix<float> feats_host; /* KaldiLib implementation */
-    };
-
-    TNetFeatureRepo *tnet_feature_repo_new(const char *p_script, const char *config, int context) {
-        TNetFeatureRepo *repo = new TNetFeatureRepo();
-        repo->ui.ReadConfig(config);
-        repo->swap_features = !repo->ui.GetBool(SNAME":NATURALREADORDER", TNet::IsBigEndian());
-        /* load defaults */
-        repo->target_kind = repo->ui.GetFeatureParams(&repo->deriv_order,
-                &repo->p_deriv_win_lenghts,
-                &repo->start_frm_ext, &repo->end_frm_ext,
-                &repo->cmn_path, &repo->cmn_file, &repo->cmn_mask,
-                &repo->cvn_path, &repo->cvn_file, &repo->cvn_mask,
-                &repo->cvg_file, SNAME":", 0);
-        repo->start_frm_ext = repo->end_frm_ext = context;
-        repo->feature_repo.Init(repo->swap_features,
-                repo->start_frm_ext, repo->end_frm_ext, repo->target_kind,
-                repo->deriv_order, repo->p_deriv_win_lenghts,
-                repo->cmn_path, repo->cmn_mask,
-                repo->cvn_path, repo->cvn_mask, repo->cvg_file);
-        repo->feature_repo.AddFileList(p_script);
-        repo->feature_repo.Rewind();
-        return repo;
-    }
-
-    Matrix *tnet_feature_repo_read_utterance(TNetFeatureRepo *repo, lua_State *L, int debug) {
-        Matrix *mat;                    /* nerv implementation */
-        repo->feature_repo.ReadFullMatrix(repo->feats_host);
-        std::string utter_str = repo->feature_repo.Current().Logical();
-        repo->feats_host.CheckData(utter_str);
-        int n = repo->feats_host.Rows();
-        int m = repo->feats_host.Cols();
-        Status status;
-        mat = nerv_matrix_host_float_create(n, m, &status);
-        NERV_LUA_CHECK_STATUS(L, status);
-        size_t stride = mat->stride;
-        if (debug)
-            fprintf(stderr, "[tnet] feature: %s %d %d\n", utter_str.c_str(), n, m);
-        for (int i = 0; i < n; i++)
-        {
-            float *row = repo->feats_host.pRowData(i);
-            float *nerv_row = (float *)((char *)mat->data.f + i * stride);
-            /* use memmove to copy the row, since KaldiLib uses compact storage */
-            memmove(nerv_row, row, sizeof(float) * m);
-        }
-        return mat;
-    }
-
-    void tnet_feature_repo_next(TNetFeatureRepo *repo) {
-        repo->feature_repo.MoveNext();
-    }
-
-    int tnet_feature_repo_is_end(TNetFeatureRepo *repo) {
-        return repo->feature_repo.EndOfList();
-    }
-
-    size_t tnet_feature_repo_current_samplerate(TNetFeatureRepo *repo) {
-        return repo->feature_repo.CurrentHeader().mSamplePeriod;
-    }
-
-    const char *tnet_feature_repo_current_tag(TNetFeatureRepo *repo) {
-        return repo->feature_repo.Current().Logical().c_str();
-    }
-
-    void tnet_feature_repo_destroy(TNetFeatureRepo *repo) {
-        if (repo->cmn_mask)
-            free(repo->cmn_path);
-        if (repo->cvn_mask)
-            free(repo->cvn_path);
-        free(repo->p_deriv_win_lenghts);
-        delete repo;
-    }
-
-    struct TNetLabelRepo {
-        TNet::LabelRepository label_repo;
-    };
-
-    TNetLabelRepo *tnet_label_repo_new(const char *mlf, const char *fmt,
-                                        const char *fmt_arg, const char *dir,
-                                        const char *ext) {
-        TNetLabelRepo *repo = new TNetLabelRepo();
-        repo->label_repo.InitExt(mlf, fmt, fmt_arg, dir, ext);
-        /* repo->label_repo.Init(mlf, fmt_arg, dir, ext); */
-        return repo;
-    }
-
-    Matrix *tnet_label_repo_read_utterance(TNetLabelRepo *repo,
-                                            size_t frames,
-                                            size_t sample_rate,
-                                            const char *tag,
-                                            lua_State *L,
-                                            int debug) {
-        std::vector<TNet::Matrix<float> >  labs_hosts; /* KaldiLib implementation */
-        Matrix *mat;
-        repo->label_repo.GenDesiredMatrixExt(labs_hosts, frames,
-                                            sample_rate, tag);
-        int n = labs_hosts[0].Rows();
-        int m = labs_hosts[0].Cols();
-        Status status;
-        mat = nerv_matrix_host_float_create(n, m, &status);
-        NERV_LUA_CHECK_STATUS(L, status);
-        size_t stride = mat->stride;
-        if (debug)
-            fprintf(stderr, "[tnet] label: %s %d %d\n", tag, n, m);
-        for (int i = 0; i < n; i++)
-        {
-            float *row = labs_hosts[0].pRowData(i);
-            float *nerv_row = (float *)((char *)mat->data.f + i * stride);
-            /* use memmove to copy the row, since KaldiLib uses compact storage */
-            memmove(nerv_row, row, sizeof(float) * m);
-        }
-        return mat;
-    }
-
-    void tnet_label_repo_destroy(TNetLabelRepo *repo) {
-        delete repo;
-    }
-}
diff --git a/tnet_io/cwrapper.h b/tnet_io/cwrapper.h
deleted file mode 100644
index a52770b..0000000
--- a/tnet_io/cwrapper.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#ifndef NERV_TNET_IO_CWRAPPER
-#define NERV_TNET_IO_CWRAPPER
-#include "../../nerv/lib/matrix/matrix.h"
-#include "../../nerv/common.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-    typedef struct TNetFeatureRepo TNetFeatureRepo;
-
-    TNetFeatureRepo *tnet_feature_repo_new(const char *scp,
-                                            const char *config, int context);
-    Matrix *tnet_feature_repo_read_utterance(TNetFeatureRepo *repo, lua_State *L, int debug);
-    size_t tnet_feature_repo_current_samplerate(TNetFeatureRepo *repo);
-    const char *tnet_feature_repo_current_tag(TNetFeatureRepo *repo);
-    void tnet_feature_repo_next(TNetFeatureRepo *repo);
-    int tnet_feature_repo_is_end(TNetFeatureRepo *repo);
-    void tnet_feature_repo_destroy(TNetFeatureRepo *repo);
-
-    typedef struct TNetLabelRepo TNetLabelRepo;
-
-    TNetLabelRepo *tnet_label_repo_new(const char *mlf, const char *fmt,
-                                        const char *fmt_arg, const char *dir,
-                                        const char *ext);
-
-    Matrix *tnet_label_repo_read_utterance(TNetLabelRepo *repo,
-                                            size_t frames,
-                                            size_t sample_rate,
-                                            const char *tag,
-                                            lua_State *L,
-                                            int debug);
-
-    void tnet_label_repo_destroy(TNetLabelRepo *repo);
-#ifdef __cplusplus
-}
-#endif
-#endif
diff --git a/tnet_io/init.c b/tnet_io/init.c
deleted file mode 100644
index 3e3f90d..0000000
--- a/tnet_io/init.c
+++ /dev/null
@@ -1,118 +0,0 @@
-#include "../../nerv/common.h"
-#include "cwrapper.h"
-#include <stdio.h>
-
-const char *nerv_tnet_feat_repo_tname = "nerv.TNetFeatureRepo";
-const char *nerv_tnet_label_repo_tname = "nerv.TNetLabelRepo";
-const char *nerv_matrix_host_float_tname = "nerv.MMatrixFloat";
-
-static int feat_repo_new(lua_State *L) {
-    const char *scp_file = luaL_checkstring(L, 1);
-    const char *conf = luaL_checkstring(L, 2);
-    int frm_ext = luaL_checkinteger(L, 3);
-    TNetFeatureRepo *repo = tnet_feature_repo_new(scp_file, conf, frm_ext);
-    luaT_pushudata(L, repo, nerv_tnet_feat_repo_tname);
-    return 1;
-}
-
-static int feat_repo_destroy(lua_State *L) {
-    TNetFeatureRepo *repo = luaT_checkudata(L, 1, nerv_tnet_feat_repo_tname);
-    tnet_feature_repo_destroy(repo);
-    return 0;
-}
-
-static int feat_repo_current_tag(lua_State *L) {
-    TNetFeatureRepo *repo = luaT_checkudata(L, 1, nerv_tnet_feat_repo_tname);
-    lua_pushstring(L, tnet_feature_repo_current_tag(repo));
-    return 1;
-}
-
-static int feat_repo_current_utterance(lua_State *L) {
-    TNetFeatureRepo *repo = luaT_checkudata(L, 1, nerv_tnet_feat_repo_tname);
-    int debug;
-    if (!lua_isboolean(L, 2))
-        nerv_error(L, "debug flag should be a boolean");
-    debug = lua_toboolean(L, 2);
-    Matrix *utter = tnet_feature_repo_read_utterance(repo, L, debug);
-    luaT_pushudata(L, utter, nerv_matrix_host_float_tname);
-    return 1;
-}
-
-static int feat_repo_next(lua_State *L) {
-    TNetFeatureRepo *repo = luaT_checkudata(L, 1, nerv_tnet_feat_repo_tname);
-    tnet_feature_repo_next(repo);
-    return 0;
-}
-
-static int feat_repo_is_end(lua_State *L) {
-    TNetFeatureRepo *repo = luaT_checkudata(L, 1, nerv_tnet_feat_repo_tname);
-    lua_pushboolean(L, tnet_feature_repo_is_end(repo));
-    return 1;
-}
-
-static const luaL_Reg feat_repo_methods[] = {
-    {"cur_utter", feat_repo_current_utterance},
-    {"cur_tag", feat_repo_current_tag},
-    {"next", feat_repo_next},
-    {"is_end", feat_repo_is_end},
-    {NULL, NULL}
-};
-
-static int label_repo_new(lua_State *L) {
-    const char *mlf_file = luaL_checkstring(L, 1);
-    const char *fmt = luaL_checkstring(L, 2);
-    const char *arg = luaL_checkstring(L, 3);
-    const char *dir = luaL_checkstring(L, 4);
-    const char *ext = luaL_checkstring(L, 5);
-    TNetLabelRepo *repo = tnet_label_repo_new(
-                                mlf_file, fmt, arg,
-                                dir, ext);
-    luaT_pushudata(L, repo, nerv_tnet_label_repo_tname);
-    return 1;
-}
-
-static int label_repo_read_utterance(lua_State *L) {
-    TNetLabelRepo *repo = luaT_checkudata(L, 1, nerv_tnet_label_repo_tname);
-    TNetFeatureRepo *feat_repo = luaT_checkudata(L, 2, nerv_tnet_feat_repo_tname);
-    size_t frames = luaL_checkinteger(L, 3);
-    int debug;
-    if (!lua_isboolean(L, 4))
-        nerv_error(L, "debug flag should be a boolean");
-    debug = lua_toboolean(L, 4);
-    Matrix *utter = tnet_label_repo_read_utterance(repo,
-                        frames,
-                        tnet_feature_repo_current_samplerate(feat_repo),
-                        tnet_feature_repo_current_tag(feat_repo), L, debug);
-    luaT_pushudata(L, utter, nerv_matrix_host_float_tname);
-    return 1;
-}
-
-static int label_repo_destroy(lua_State *L) {
-    TNetLabelRepo *repo = luaT_checkudata(L, 1, nerv_tnet_label_repo_tname);
-    tnet_label_repo_destroy(repo);
-    return 0;
-}
-
-static const luaL_Reg label_repo_methods[] = {
-    {"get_utter", label_repo_read_utterance},
-    {NULL, NULL}
-};
-
-static void feat_repo_init(lua_State *L) {
-    luaT_newmetatable(L, nerv_tnet_feat_repo_tname, NULL,
-                        feat_repo_new, feat_repo_destroy, NULL);
-    luaL_register(L, NULL, feat_repo_methods);
-    lua_pop(L, 1);
-}
-
-static void label_repo_init(lua_State *L) {
-    luaT_newmetatable(L, nerv_tnet_label_repo_tname, NULL,
-                        label_repo_new, label_repo_destroy, NULL);
-    luaL_register(L, NULL, label_repo_methods);
-    lua_pop(L, 1);
-}
-
-void tnet_io_init(lua_State *L) {
-    feat_repo_init(L);
-    label_repo_init(L);
-}
diff --git a/tnet_io/test.c b/tnet_io/test.c
deleted file mode 100644
index 6812ef1..0000000
--- a/tnet_io/test.c
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "cwrapper.h"
-#include <stdio.h>
-
-void print_nerv_matrix(Matrix *mat) {
-    int n = mat->nrow;
-    int m = mat->ncol;
-    int i, j;
-    size_t stride = mat->stride;
-    for (i = 0; i < n; i++)
-    {
-
-        float *nerv_row = (float *)((char *)mat->data.f + i * stride);
-        for (j = 0; j < m; j++)
-            fprintf(stderr, "%.8f ", nerv_row[j]);
-        fprintf(stderr, "\n");
-    }
-}
-
-int main() {
-    fprintf(stderr, "init repo\n");
-    TNetFeatureRepo *feat_repo = tnet_feature_repo_new(
-            "/slfs1/users/mfy43/swb_ivec/train_bp.scp",
-            "/slfs1/users/mfy43/swb_ivec/plp_0_d_a.conf", 5);
-    Matrix *feat_utter;
-    feat_utter = tnet_feature_repo_read_utterance(feat_repo, NULL, 1);
-
-    TNetLabelRepo *lab_repo = tnet_label_repo_new(
-            "/slfs1/users/mfy43/swb_ivec/ref.mlf",
-            "map",
-            "/slfs1/users/mfy43/swb_ivec/dict",
-            "*/",
-            "lab");
-    Matrix *lab_utter = tnet_label_repo_read_utterance(lab_repo,
-            feat_utter->nrow - 5 * 2,
-            tnet_feature_repo_current_samplerate(feat_repo),
-            tnet_feature_repo_current_tag(feat_repo), NULL,
-            1);
-    print_nerv_matrix(lab_utter);
-    return 0;
-}
diff --git a/tnet_io/tnet.mk b/tnet_io/tnet.mk
deleted file mode 100644
index 9f933db..0000000
--- a/tnet_io/tnet.mk
+++ /dev/null
@@ -1,83 +0,0 @@
-#
-# This makefile contains some global definitions,
-# that are used during the build process.
-# It is included by all the subridrectory libraries.
-#
-
-
-##############################################################
-##### 64-BIT CROSS-COMPILATION #####
-CXXFLAGS=
-FWDPARAM=
-BITS64=true
-ifeq ($(BITS64), true)
-  ##### CHANGE WHEN DIFFERENT 64BIT g++ PREFIX ##### 
-  CROSS_COMPILE = x86_64-linux-
-  ##### CHANGE WHEN DIFFERENT 64BIT g++ PREFIX ##### 
-  CXXFLAGS += -m64
-  FWDPARAM += BITS64=true
-else
-  CXXFLAGS += -m32
-endif
-
-# disable cross-compile prefix if CXX not exists
-CXX=$(CROSS_COMPILE)g++
-CXX2=$(notdir $(shell which $(CXX) 2>/dev/null))
-ifneq ("$(CXX)", "$(CXX2)")
-  CROSS_COMPILE=
-endif
-
-# compilation tools
-CC = $(CROSS_COMPILE)g++
-CXX = $(CROSS_COMPILE)g++
-AR = $(CROSS_COMPILE)ar
-RANLIB = $(CROSS_COMPILE)ranlib
-AS = $(CROSS_COMPILE)as
-
-
-
-
-##############################################################
-##### PATH TO CUDA TOOLKIT #####
-#CUDA_TK_BASE=/usr/local/share/cuda-3.2.12
-#CUDA_TK_BASE=/usr/local/cuda
-##### PATH TO CUDA TOOLKIT #####
-
-
-
-
-# compilation args
-CXXFLAGS += -g -Wall -O2 -DHAVE_ATLAS -rdynamic -fPIC
-CXXFLAGS += -Wshadow -Wpointer-arith -Wcast-qual -Wcast-align -Wwrite-strings -Wconversion
-
-# enable double-precision
-ifeq ($(DOUBLEPRECISION), true)
-  CXXFLAGS += -DDOUBLEPRECISION
-  FWDPARAM += DOUBLEPRECISION=true
-endif
-
-
-# compile all the source .cc files 
-SRC=$(wildcard *.cc)
-OBJ=$(addprefix $(OBJ_DIR)/,$(patsubst %.cc, %.o, $(SRC)))
-
-
-
-
-#########################################################
-# CONFIGURATION CHECKS
-#
-
-#check that CUDA_TK_BASE is set correctly
-ifeq ("$(wildcard $(CUDA_TK_BASE)/bin/nvcc)", "$(CUDA_TK_BASE)/bin/nvcc")
-  HAVE_CUDA=true
-else 
-  ifeq ($(CUDA), true)
-    $(error %%% CUDA not found! Incorrect path in CUDA_TK_BASE: $(CUDA_TK_BASE) in 'trunk/src/tnet.mk')
-  endif
-endif
-
-#
-#########################################################
-
-