diff --git a/.gitignore b/.gitignore
index 2a95a24e0..c41f82d27 100644
--- a/.gitignore
+++ b/.gitignore
@@ -24,21 +24,28 @@ config.h
 include/
 lib/
 bin/
-lgdpj
-lgsrl
-otcws
-otpos
-otner
-maxent
-cws
-cws_cmdline
-multi_cws_cmdline
-pos
-par
-ner
+tools/train/lgdpj
+tools/train/lgsrl
+tools/train/otcws
+tools/train/otpos
+tools/train/otner
+tools/train/maxent
+examples/cws
+examples/cws_cmdline
+examples/multi_cws_cmdline
+examples/pos
+examples/pos_cmdline
+examples/multi_pos_cmdline
+examples/par
+examples/ner
 
 ###############
 # data file   #
 ###############
 new_ltp_data/
 ltp_data/
+
+##################
+# running folder #
+##################
+dummy/
diff --git a/ChangeLog.md b/ChangeLog.md
index e657e7628..984652995 100644
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,3 +1,11 @@
+2014-01-16
+----------
+* 在分词、词性标注和依存句法分析模块中加入模型裁剪功能，减少了模型大小。用户可以通过配置文件里的rare-feature-threshold参数配置裁剪力度，如果rare-feature-threshold为0，则只去掉为0的特征；rare-feature-threshold大于0时将一步去掉更新次数低于阈值的特征。这一优化方法主要参考[Learning Sparser Perceptron Models](http://www.cs.bgu.ac.il/~yoavg/publications/acl2011sparse.pdf)。
+* 修复了词性标注、命名实体识别、依存句法分析训练套件中的内存泄露问题
+* 修复了语义角色标注的内存泄露问题
+* 增加了`ltp_server`在异常输入情况下返回错误代码，如果输入数据编码错误或者输入xml不符合规则，将返回400
+* 修复了词性标注、命名实体识别模型文件的错误标示符，这项修改将导致3.1.0以及之后的版本不能与3.0.x的模型兼容，请务必注意
+
 2013-09-29
 ----------
 * 解决windows编译问题
diff --git a/doc/ltp-document-3.0.md b/doc/ltp-document-3.0.md
index 7f9e1c9b7..ab55e541c 100644
--- a/doc/ltp-document-3.0.md
+++ b/doc/ltp-document-3.0.md
@@ -43,7 +43,9 @@ LTP提供了一系列中文自然语言处理工具，用户可以使用这些
 
 同时，你可以从以下一些地方获得LTP的模型。
 
-* 
+* [百度云](http://pan.baidu.com/share/link?shareid=1988562907&uk=2738088569)
+* 当前模型版本3.1.0
+
 
 ## 安装CMake
 
@@ -860,7 +862,7 @@ otcws是ltp分词模型的训练套件，用户可以使用otcws训练获得ltp
 
 otcws分别支持从人工切分数据中训练分词模型和调用分词模型对句子进行切分。人工切分的句子的样例如下：
 
-	对外		，	他们		代表		国家		。
+	对外	，	他们	代表	国家	。
 
 otcws主要通过配置文件指定执行的工作，其中主要有两类配置文件：训练配置和测试配置。
 
@@ -872,15 +874,17 @@ otcws主要通过配置文件指定执行的工作，其中主要有两类配置
 	algorithm = pa 
 	model-name = model/ctb5-seg
 	max-iter = 5
+	rare-feature-threshold = 0
 
 其中，
 
 * [train] 配置组指定执行训练
-	* Ttain-file 配置项指定训练集文件
-	* Holdout-file 配置项指定开发集文件
-	* Algorithm 指定参数学习方法，现在otcws支持两种参数学习方法，分别是passive aggressive(pa)和average perceptron(ap)。
-	* Model-name 指定输出模型文件名
-	* Max-iter 指定最大迭代次数
+	* ttain-file 配置项指定训练集文件
+	* holdout-file 配置项指定开发集文件
+	* algorithm 指定参数学习方法，现在otcws支持两种参数学习方法，分别是passive aggressive(pa)和average perceptron(ap)。
+	* model-name 指定输出模型文件名
+	* max-iter 指定最大迭代次数
+	* rare-feature-threshold 配置裁剪力度，如果rare-feature-threshold为0，则只去掉为0的特征；rare-feature-threshold；如果大于0时将进一步去掉更新次数低于阈值的特征
 
 测试配置的配置文件样例如下所示。
 
@@ -891,8 +895,8 @@ otcws主要通过配置文件指定执行的工作，其中主要有两类配置
 其中，
 
 * [test] 配置组指定执行测试
-	* Test-file 指定测试文件
-	* Model-file 指定模型文件位置
+	* test-file 指定测试文件
+	* model-file 指定模型文件位置
 	
 切分结果将输入到标准io中。
 
@@ -924,11 +928,12 @@ otpos主要通过配置文件指定执行的工作，其中主要有两类配置
 其中，
 
 * [train] 配置组指定执行训练
-	* Ttain-file 配置项指定训练集文件
-	* Holdout-file 配置项指定开发集文件
-	* Algorithm 指定参数学习方法，现在otcws支持两种参数学习方法，分别是passive aggressive(pa)和average perceptron(ap)。
-	* Model-name 指定输出模型文件名
-	* Max-iter 指定最大迭代次数
+	* ttain-file 配置项指定训练集文件
+	* holdout-file 配置项指定开发集文件
+	* algorithm 指定参数学习方法，现在otcws支持两种参数学习方法，分别是passive aggressive(pa)和average perceptron(ap)。
+	* model-name 指定输出模型文件名
+	* max-iter 指定最大迭代次数
+	* rare-feature-threshold 配置裁剪力度，如果rare-feature-threshold为0，则只去掉为0的特征；rare-feature-threshold；如果大于0时将进一步去掉更新次数低于阈值的特征
 
 测试配置的配置文件样例如下所示。
 
@@ -939,8 +944,8 @@ otpos主要通过配置文件指定执行的工作，其中主要有两类配置
 其中，
 
 * [test] 配置组指定执行测试
-	* Test-file 指定测试文件
-	* Model-file 指定模型文件位置
+	* test-file 指定测试文件
+	* model-file 指定模型文件位置
 
 词性标注结果将输入到标准io中。
 
@@ -972,11 +977,11 @@ Otner主要通过配置文件指定执行的工作，其中主要有两类配置
 其中，
 
 * [train] 配置组指定执行训练
-	* Train-file 配置项指定训练集文件
-	* Holdout-file 配置项指定开发集文件
-	* Algorithm 指定参数学习方法，现在otner支持两种参数学习方法，分别是passive aggressive（pa）和average perceptron（ap）。
-	* Model-name 指定输出模型文件名
-	* Max-iter 指定最大迭代次数
+	* train-file 配置项指定训练集文件
+	* holdout-file 配置项指定开发集文件
+	* algorithm 指定参数学习方法，现在otner支持两种参数学习方法，分别是passive aggressive（pa）和average perceptron（ap）。
+	* model-name 指定输出模型文件名
+	* max-iter 指定最大迭代次数
 
 测试配置的配置文件样例如下所示。
 
@@ -987,8 +992,8 @@ Otner主要通过配置文件指定执行的工作，其中主要有两类配置
 其中，
 
 * [test] 配置组指定执行测试
-	* Test-file 指定测试文件
-	* Model-file 指定模型文件位置
+	* test-file 指定测试文件
+	* model-file 指定模型文件位置
 
 命名实体识别结果将输入到标准io中。
 
@@ -1000,7 +1005,7 @@ lgdpj是ltp依存句法分析模型的训练套件，用户可以使用lgdpj训
 
 编译之后，在tools/train下面会产生名为lgdpj的二进制程序。调用方法是
 
-	./lgdpj [config_file]。
+	./lgdpj [config_file]
 
 lgdpj分别支持从人工标注依存句法的数据中训练依存句法分析模型和调用依存句法分析模型对句子进行依存句法分析。人工标注的词性标注依存句法的句子遵从conll格式，其样例如下：
 
@@ -1039,6 +1044,7 @@ lgdpj主要通过配置文件指定执行的工作，其中主要有两类配置
 	max-iter = 5 
 	algorithm = pa
 	model-name = model/parser/ldc-o2carreras
+	rare-feature-threshold = 0
 
 其中，
 
@@ -1047,11 +1053,12 @@ lgdpj主要通过配置文件指定执行的工作，其中主要有两类配置
 	* decoder-name 表示采用的解码算法，现在lgdpj支持三种解码算法，分别是1o，2o-sib，2o-carreras
 * [feature] 配置组指定使用的特征
 * [train] 配置组指定执行训练
-	* Train-file 配置项指定训练集文件
-	* Holdout-file 配置项指定开发集文件
-	* Algorithm 指定参数学习方法，现在otcws支持两种参数学习方法，分别是passive aggressive(pa)和average perceptron(ap)。
-	* Model-name 指定输出模型文件名
-	* Max-iter 指定最大迭代次数
+	* train-file 配置项指定训练集文件
+	* holdout-file 配置项指定开发集文件
+	* algorithm 指定参数学习方法，现在otcws支持两种参数学习方法，分别是passive aggressive(pa)和average perceptron(ap)。
+	* model-name 指定输出模型文件名
+	* max-iter 指定最大迭代次数
+	* rare-feature-threshold 配置裁剪力度，如果rare-feature-threshold为0，则只去掉为0的特征；rare-feature-threshold；如果大于0时将进一步去掉更新次数低于阈值的特征
 
 测试配置的配置文件样例如下所示。
 
@@ -1062,8 +1069,8 @@ lgdpj主要通过配置文件指定执行的工作，其中主要有两类配置
 其中，
 
 * [test] 配置组指定执行测试
-	* Test-file 指定测试文件
-	* Model-file 指定模型文件位置
+	* test-file 指定测试文件
+	* model-file 指定模型文件位置
 
 依存句法分析结果将输入到标准io中。
 
diff --git a/examples/cws.cpp b/examples/cws.cpp
index 0f42063e0..6a9355c54 100644
--- a/examples/cws.cpp
+++ b/examples/cws.cpp
@@ -3,38 +3,38 @@
 #include "segment_dll.h"
 
 int main(int argc, char * argv[]) {
-    if (argc < 2) {
-        std::cerr << "cws [model path] [lexicon_file]" << std::endl;
-        return 1;
-    }
+  if (argc < 2) {
+    std::cerr << "cws [model path] [lexicon_file]" << std::endl;
+    return 1;
+  }
 
-    void * engine = 0;
-    if (argc == 2) {
-        engine = segmentor_create_segmentor(argv[1]);
-    } else if (argc == 3) {
-        engine = segmentor_create_segmentor(argv[1], argv[2]);
-    }
+  void * engine = 0;
+  if (argc == 2) {
+    engine = segmentor_create_segmentor(argv[1]);
+  } else if (argc == 3) {
+    engine = segmentor_create_segmentor(argv[1], argv[2]);
+  }
 
-    if (!engine) {
-        return -1;
-    }
-    std::vector<std::string> words;
+  if (!engine) {
+    return -1;
+  }
+  std::vector<std::string> words;
 
-    const char * suite[2] = {
-        "What's wrong with you? 别灰心! http://t.cn/zQz0Rn",
-        "台北真的是天子骄子吗？",};
+  const char * suite[2] = {
+    "What's wrong with you? 别灰心! http://t.cn/zQz0Rn",
+    "台北真的是天子骄子吗？",};
 
-    for (int i = 0; i < 2; ++ i) {
-        words.clear();
-        int len = segmentor_segment(engine, suite[i], words);
-        for (int i = 0; i < len; ++ i) {
-            std::cout << words[i];
-            if (i+1 == len) std::cout <<std::endl;
-            else std::cout<< "|";
-        }
+  for (int i = 0; i < 2; ++ i) {
+    words.clear();
+    int len = segmentor_segment(engine, suite[i], words);
+    for (int i = 0; i < len; ++ i) {
+      std::cout << words[i];
+      if (i+1 == len) std::cout <<std::endl;
+      else std::cout<< "|";
     }
+  }
 
-    segmentor_release_segmentor(engine);
-    return 0;
+  segmentor_release_segmentor(engine);
+  return 0;
 }
 
diff --git a/examples/cws_cmdline.cpp b/examples/cws_cmdline.cpp
index 001d5e805..4e73ffa44 100644
--- a/examples/cws_cmdline.cpp
+++ b/examples/cws_cmdline.cpp
@@ -19,52 +19,52 @@
 #include "segment_dll.h"
 
 double get_time(void) {
-    struct timeval tv;
-    gettimeofday(&tv, NULL);
-    return tv.tv_sec + (tv.tv_usec / 1000000.0);
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return tv.tv_sec + (tv.tv_usec / 1000000.0);
 }
 
 int main(int argc, char * argv[]) {
-    if (argc < 2) {
-        std::cerr << "cws [model path] [lexicon_file]" << std::endl;
-        return 1;
-    }
+  if (argc < 2) {
+    std::cerr << "cws [model path] [lexicon_file]" << std::endl;
+    return 1;
+  }
 
-    void * engine = 0;
-    if (argc == 2) {
-        engine = segmentor_create_segmentor(argv[1]);
-    } else if (argc == 3) {
-        engine = segmentor_create_segmentor(argv[1], argv[2]);
-    }
+  void * engine = 0;
+  if (argc == 2) {
+    engine = segmentor_create_segmentor(argv[1]);
+  } else if (argc == 3) {
+    engine = segmentor_create_segmentor(argv[1], argv[2]);
+  }
 
-    if (!engine) {
-        return -1;
-    }
-    std::vector<std::string> words;
-    std::string sentence;
+  if (!engine) {
+    return -1;
+  }
+  std::vector<std::string> words;
+  std::string sentence;
 
-    std::cerr << "TRACE: Model is loaded" << std::endl;
-    double tm = get_time();
+  std::cerr << "TRACE: Model is loaded" << std::endl;
+  double tm = get_time();
 
-    while (std::getline(std::cin, sentence, '\n')) {
-        words.clear();
-        if (sentence.size() == 0) { continue; }
-        int len = segmentor_segment(engine, sentence, words);
-        for (int i = 0; i < len; ++ i) {
-            std::cout << words[i];
-            if (i+1 == len) std::cout <<std::endl;
-            else std::cout<< "|";
-        }
+  while (std::getline(std::cin, sentence, '\n')) {
+    words.clear();
+    if (sentence.size() == 0) { continue; }
+    int len = segmentor_segment(engine, sentence, words);
+    for (int i = 0; i < len; ++ i) {
+      std::cout << words[i];
+      if (i+1 == len) std::cout <<std::endl;
+      else std::cout<< "|";
     }
+  }
 
-    segmentor_release_segmentor(engine);
+  segmentor_release_segmentor(engine);
 
-    tm = get_time() - tm;
-    std::cerr << "TRACE: consume "
-        << tm 
-        << " seconds."
-        << std::endl;
+  tm = get_time() - tm;
+  std::cerr << "TRACE: consume "
+            << tm
+            << " seconds."
+            << std::endl;
 
-    return 0;
+  return 0;
 }
 
diff --git a/examples/multi_cws_cmdline.cpp b/examples/multi_cws_cmdline.cpp
index dbf747d91..8accc2369 100644
--- a/examples/multi_cws_cmdline.cpp
+++ b/examples/multi_cws_cmdline.cpp
@@ -12,6 +12,7 @@
  * is not compilable under MSVC
  */
 #include <iostream>
+#include <cstdlib>
 #include <cstring>
 #include <ctime>
 #include <vector>
@@ -91,7 +92,9 @@ void multithreaded_segment( void * args) {
 
 int main(int argc, char ** argv) {
     if (argc < 2 || (0 == strcmp(argv[1], "-h"))) {
-        std::cerr << "Example: ./multi_cws_cmdline [model path] [lexicon file]=NULL threadnum" << std::endl;
+        std::cerr << "Example: ./multi_cws_cmdline "
+                  << "[model path] [lexicon file](optional) threadnum"
+                  << std::endl;
         std::cerr << std::endl;
         std::cerr << "This program recieve input word sequence from stdin." << std::endl;
         std::cerr << "One sentence per line." << std::endl;
diff --git a/examples/ner.cpp b/examples/ner.cpp
index 223e31402..c1c3589e1 100644
--- a/examples/ner.cpp
+++ b/examples/ner.cpp
@@ -4,40 +4,40 @@
 #include "ner_dll.h"
 
 int main(int argc, char * argv[]) {
-    if (argc < 2) {
-        std::cerr << "usage: ./ner [model_path]" << std::endl;
-        return -1;
-    }
-
-    void * engine = ner_create_recognizer(argv[1]);
-    if (!engine) {
-        std::cerr << "failed to load model" << std::endl;
-        return -1;
-    }
-
-    std::vector<std::string> words;
-    std::vector<std::string> postags;
-
-    words.push_back("中国");    postags.push_back("ns");
-    words.push_back("国际");    postags.push_back("n");
-    words.push_back("广播");    postags.push_back("n");
-    words.push_back("电台");    postags.push_back("n");
-    words.push_back("创办");    postags.push_back("v");
-    words.push_back("于");      postags.push_back("p");
-    words.push_back("1941年");  postags.push_back("m");
-    words.push_back("12月");    postags.push_back("m");
-    words.push_back("3日");     postags.push_back("m");
-    words.push_back("。");      postags.push_back("wp");
-
-    std::vector<std::string>    tags;
-
-    ner_recognize(engine, words, postags, tags);
-
-    for (int i = 0; i < tags.size(); ++ i) {
-        std::cout << words[i] << "\t" << postags[i] << "\t" << tags[i] << std::endl;
-    }
-
-    ner_release_recognizer(engine);
-    return 0;
+  if (argc < 2) {
+    std::cerr << "usage: ./ner [model_path]" << std::endl;
+    return -1;
+  }
+
+  void * engine = ner_create_recognizer(argv[1]);
+  if (!engine) {
+    std::cerr << "failed to load model" << std::endl;
+    return -1;
+  }
+
+  std::vector<std::string> words;
+  std::vector<std::string> postags;
+
+  words.push_back("中国");    postags.push_back("ns");
+  words.push_back("国际");    postags.push_back("n");
+  words.push_back("广播");    postags.push_back("n");
+  words.push_back("电台");    postags.push_back("n");
+  words.push_back("创办");    postags.push_back("v");
+  words.push_back("于");      postags.push_back("p");
+  words.push_back("1941年");  postags.push_back("m");
+  words.push_back("12月");    postags.push_back("m");
+  words.push_back("3日");     postags.push_back("m");
+  words.push_back("。");      postags.push_back("wp");
+
+  std::vector<std::string>  tags;
+
+  ner_recognize(engine, words, postags, tags);
+
+  for (int i = 0; i < tags.size(); ++ i) {
+    std::cout << words[i] << "\t" << postags[i] << "\t" << tags[i] << std::endl;
+  }
+
+  ner_release_recognizer(engine);
+  return 0;
 }
 
diff --git a/examples/par.cpp b/examples/par.cpp
index 2db1855e7..02ed9dcf2 100644
--- a/examples/par.cpp
+++ b/examples/par.cpp
@@ -4,34 +4,34 @@
 #include "parser_dll.h"
 
 int main(int argc, char * argv[]) {
-    if (argc < 2) {
-        return -1;
-    }
+  if (argc < 2) {
+    return -1;
+  }
 
-    void * engine = parser_create_parser(argv[1]);
-    if (!engine) {
-        return -1;
-    }
+  void * engine = parser_create_parser(argv[1]);
+  if (!engine) {
+    return -1;
+  }
 
-    std::vector<std::string> words;
-    std::vector<std::string> postags;
+  std::vector<std::string> words;
+  std::vector<std::string> postags;
 
-    words.push_back("一把手");      postags.push_back("n");
-    words.push_back("亲自");        postags.push_back("d");
-    words.push_back("过问");        postags.push_back("v");
-    words.push_back("。");          postags.push_back("wp");
+  words.push_back("一把手");  postags.push_back("n");
+  words.push_back("亲自");    postags.push_back("d");
+  words.push_back("过问");    postags.push_back("v");
+  words.push_back("。");      postags.push_back("wp");
 
-    std::vector<int>            heads;
-    std::vector<std::string>    deprels;
+  std::vector<int>      heads;
+  std::vector<std::string>  deprels;
 
-    parser_parse(engine, words, postags, heads, deprels);
+  parser_parse(engine, words, postags, heads, deprels);
 
-    for (int i = 0; i < heads.size(); ++ i) {
-        std::cout << words[i] << "\t" << postags[i] << "\t" 
-            << heads[i] << "\t" << deprels[i] << std::endl;
-    }
+  for (int i = 0; i < heads.size(); ++ i) {
+    std::cout << words[i] << "\t" << postags[i] << "\t"
+              << heads[i] << "\t" << deprels[i] << std::endl;
+  }
 
-    parser_release_parser(engine);
-    return 0;
+  parser_release_parser(engine);
+  return 0;
 }
 
diff --git a/examples/pos_cmdline.cpp b/examples/pos_cmdline.cpp
index feca053b5..2785bfe33 100644
--- a/examples/pos_cmdline.cpp
+++ b/examples/pos_cmdline.cpp
@@ -21,62 +21,62 @@
 #include "postag_dll.h"
 
 double get_time(void) {
-    struct timeval tv;
-    gettimeofday(&tv, NULL);
-    return tv.tv_sec + (tv.tv_usec / 1000000.0);
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return tv.tv_sec + (tv.tv_usec / 1000000.0);
 }
 
 int main(int argc, char * argv[]) {
-    if (argc < 1 || (0 == strcmp(argv[1], "-h"))) {
-        std::cerr << "Example: ./pos_cmdline [model path]" << std::endl;
-        std::cerr << std::endl;
-        std::cerr << "This program recieve input word sequence from stdin." << std::endl;
-        std::cerr << "One sentence per line. Words are separated by space." << std::endl;
-        std::cerr << std::endl;
-        return 1;
-    }
+  if (argc < 1 || (0 == strcmp(argv[1], "-h"))) {
+    std::cerr << "Example: ./pos_cmdline [model path]" << std::endl;
+    std::cerr << std::endl;
+    std::cerr << "This program recieve input word sequence from stdin." << std::endl;
+    std::cerr << "One sentence per line. Words are separated by space." << std::endl;
+    std::cerr << std::endl;
+    return 1;
+  }
 
-    void * engine = postagger_create_postagger(argv[1]);
-    if (!engine) {
-        std::cerr << "WARNINIG : Failed to load model." << std::endl;
-        return -1;
-    }
+  void * engine = postagger_create_postagger(argv[1]);
+  if (!engine) {
+    std::cerr << "WARNINIG : Failed to load model." << std::endl;
+    return -1;
+  }
 
-    std::string line;
-    std::string word;
-    std::vector<std::string> words;
-    std::vector<std::string> postags;
+  std::string line;
+  std::string word;
+  std::vector<std::string> words;
+  std::vector<std::string> postags;
 
-    std::cerr << "TRACE: Model is loaded" << std::endl;
-    double tm = get_time();
+  std::cerr << "TRACE: Model is loaded" << std::endl;
+  double tm = get_time();
 
-    while (std::getline(std::cin, line, '\n')) {
-        std::stringstream S(line);
-        words.clear();
-        while (S >> word) { words.push_back(word); }
+  while (std::getline(std::cin, line, '\n')) {
+    std::stringstream S(line);
+    words.clear();
+    while (S >> word) { words.push_back(word); }
 
-        if (words.size() == 0) { continue; }
-        int len = postagger_postag(engine, words, postags);
-        if (postags.size() != words.size()) {
-            std::cerr << "WARNINIG: Number of postags is different from number of words"
+    if (words.size() == 0) { continue; }
+    int len = postagger_postag(engine, words, postags);
+    if (postags.size() != words.size()) {
+      std::cerr << "WARNINIG: Number of postags is different from number of words"
                 << std::endl;
-        }
+    }
 
-        for (int i = 0; i < len; ++ i) {
-            std::cout << words[i] << "_" << postags[i];
-            if (i+1 == len) std::cout <<std::endl;
-            else std::cout<< "|";
-        }
+    for (int i = 0; i < len; ++ i) {
+      std::cout << words[i] << "_" << postags[i];
+      if (i+1 == len) std::cout <<std::endl;
+      else std::cout<< "|";
     }
+  }
 
-    postagger_release_postagger(engine);
+  postagger_release_postagger(engine);
 
-    tm = get_time() - tm;
-    std::cerr << "TRACE: consume "
-        << tm 
-        << " seconds."
-        << std::endl;
+  tm = get_time() - tm;
+  std::cerr << "TRACE: consume "
+    << tm 
+    << " seconds."
+    << std::endl;
 
-    return 0;
+  return 0;
 }
 
diff --git a/src/__ltp_dll/LTPResource.cpp b/src/__ltp_dll/LTPResource.cpp
index 080f3073e..61ab87dae 100644
--- a/src/__ltp_dll/LTPResource.cpp
+++ b/src/__ltp_dll/LTPResource.cpp
@@ -20,27 +20,24 @@
 
 #include "logging.hpp"
 
-LTPResource::LTPResource() : 
-    m_segmentor(NULL),
-    m_postagger(NULL),
-    m_ner(NULL),
-    m_parser(NULL),
-    m_isSegmentorResourceLoaded(false),
-    m_isPostaggerResourceLoaded(false),
-    m_isNEResourceLoaded(false),
-    m_isParserResourceLoaded(false),
-    m_isSRLResourceLoaded(false) {
+LTPResource::LTPResource() :
+  m_segmentor(NULL),
+  m_postagger(NULL),
+  m_ner(NULL),
+  m_parser(NULL),
+  m_isSegmentorResourceLoaded(false),
+  m_isPostaggerResourceLoaded(false),
+  m_isNEResourceLoaded(false),
+  m_isParserResourceLoaded(false),
+  m_isSRLResourceLoaded(false) {
 }
 
 LTPResource::~LTPResource() {
-    //ReleaseCRFWSRes();
-    //ReleaseIrlasRes();
-    //ReleaseSvmtaggerRes();
-    //ReleaseNeRes();
-    //ReleaseWsdRes();
-    //ReleaseGParserRes();
-    //ReleaseParserRes();
-    //ReleaseSrlRes();
+  ReleaseSegmentorResource();
+  ReleasePostaggerResource();
+  ReleaseNEResource();
+  ReleaseParserResource();
+  ReleaseSRLResource();
 }
 
 
@@ -49,205 +46,205 @@ LTPResource::~LTPResource() {
  * ======================================================== */
 // function wrapper of segmentor_create_segmentor
 int LTPResource::LoadSegmentorResource(const char * model_file) {
-    //  resource has be loaded.
-    if (m_isSegmentorResourceLoaded) {
-        return 0;
-    }
+  //  resource has be loaded.
+  if (m_isSegmentorResourceLoaded) {
+    return 0;
+  }
 
-    TRACE_LOG("Loading segmentor model from \"%s\" ...", model_file);
+  TRACE_LOG("Loading segmentor model from \"%s\" ...", model_file);
 
-    m_segmentor = segmentor_create_segmentor(model_file);
-    if (0 == m_segmentor) {
-        ERROR_LOG("Failed to load segmentor model");
-        return -1;
-    }
+  m_segmentor = segmentor_create_segmentor(model_file);
+  if (0 == m_segmentor) {
+    ERROR_LOG("Failed to load segmentor model");
+    return -1;
+  }
 
-    m_isSegmentorResourceLoaded = true;
-    TRACE_LOG("segmentor model is loaded.");
-    return 0;
+  m_isSegmentorResourceLoaded = true;
+  TRACE_LOG("segmentor model is loaded.");
+  return 0;
 }
 
 int LTPResource::LoadSegmentorResource(const std::string & model_file) {
-    return LoadSegmentorResource(model_file.c_str());
+  return LoadSegmentorResource(model_file.c_str());
 }
 
 void LTPResource::ReleaseSegmentorResource() {
-    if (!m_isSegmentorResourceLoaded) {
-        return;
-    }
+  if (!m_isSegmentorResourceLoaded) {
+    return;
+  }
 
-    segmentor_release_segmentor(m_segmentor);
+  segmentor_release_segmentor(m_segmentor);
 
-    TRACE_LOG("segmentor model is released.");
+  TRACE_LOG("segmentor model is released.");
 
-    m_segmentor = 0;
-    m_isSegmentorResourceLoaded = false;
+  m_segmentor = 0;
+  m_isSegmentorResourceLoaded = false;
 }
 
 void * LTPResource::GetSegmentor() {
-    return m_segmentor;
+  return m_segmentor;
 }
 
 /* ======================================================== *
  * Postagger related resource management                    *
  * ======================================================== */
 int LTPResource::LoadPostaggerResource(const char * model_file) {
-    if (m_isPostaggerResourceLoaded) {
-        return 0;
-    }
+  if (m_isPostaggerResourceLoaded) {
+    return 0;
+  }
 
-    TRACE_LOG("Loading postagger model from \"%s\" ...", model_file);
+  TRACE_LOG("Loading postagger model from \"%s\" ...", model_file);
 
-    m_postagger = postagger_create_postagger(model_file);
+  m_postagger = postagger_create_postagger(model_file);
 
-    if (0 == m_postagger) {
-        ERROR_LOG("Failed to load postagger model");
-        return -1;
-    }
+  if (0 == m_postagger) {
+    ERROR_LOG("Failed to load postagger model");
+    return -1;
+  }
 
-    m_isPostaggerResourceLoaded = true;
-    TRACE_LOG("postagger model is loaded");
-    return 0;
+  m_isPostaggerResourceLoaded = true;
+  TRACE_LOG("postagger model is loaded");
+  return 0;
 }
 
 int LTPResource::LoadPostaggerResource(const std::string & model_file) {
-    return LoadPostaggerResource(model_file.c_str());
+  return LoadPostaggerResource(model_file.c_str());
 }
 
 void LTPResource::ReleasePostaggerResource() {
-    if (!m_isPostaggerResourceLoaded) {
-        return;
-    }
+  if (!m_isPostaggerResourceLoaded) {
+    return;
+  }
 
-    postagger_release_postagger(m_postagger);
+  postagger_release_postagger(m_postagger);
 
-    m_postagger = 0;
-    m_isPostaggerResourceLoaded = false;
+  m_postagger = 0;
+  m_isPostaggerResourceLoaded = false;
 }
 
 void * LTPResource::GetPostagger() {
-    return m_postagger;
+  return m_postagger;
 }
 
 /* ======================================================== *
  * NER related resource management                          *
  * ======================================================== */
 int LTPResource::LoadNEResource(const char * model_file) {
-    if (m_isNEResourceLoaded) {
-        return 0;
-    }
+  if (m_isNEResourceLoaded) {
+    return 0;
+  }
 
-    TRACE_LOG("Loading NER resource from \"%s\"", model_file);
+  TRACE_LOG("Loading NER resource from \"%s\"", model_file);
 
-    m_ner = ner_create_recognizer(model_file);
+  m_ner = ner_create_recognizer(model_file);
 
-    if (0 == m_ner) {
-        ERROR_LOG("Failed to load ner model");
-        return -1;
-    }
+  if (0 == m_ner) {
+    ERROR_LOG("Failed to load ner model");
+    return -1;
+  }
 
-    m_isNEResourceLoaded = true;
-    TRACE_LOG("NER resource is loaded.");
-    return 0;
+  m_isNEResourceLoaded = true;
+  TRACE_LOG("NER resource is loaded.");
+  return 0;
 }
 
 int LTPResource::LoadNEResource(const std::string & model_file) {
-    return LoadNEResource(model_file.c_str());
+  return LoadNEResource(model_file.c_str());
 }
 
 void LTPResource::ReleaseNEResource() {
-    if (!m_isNEResourceLoaded) {
-        return;
-    }
+  if (!m_isNEResourceLoaded) {
+    return;
+  }
 
-    ner_release_recognizer(m_ner);
+  ner_release_recognizer(m_ner);
 
-    m_ner = NULL;
-    m_isNEResourceLoaded = false;
-    TRACE_LOG("NER resource is released");
+  m_ner = NULL;
+  m_isNEResourceLoaded = false;
+  TRACE_LOG("NER resource is released");
 }
 
 void * LTPResource::GetNER() {
-    return m_ner;
+  return m_ner;
 }
 
 /* ====================================================== *
  * Parser related resource                                *
  * ====================================================== */
 int LTPResource::LoadParserResource(const char * model_file) {
-    if (m_isParserResourceLoaded) {
-        return 0;
-    }
+  if (m_isParserResourceLoaded) {
+    return 0;
+  }
 
-    TRACE_LOG("Loading parser resource from \"%s\"", model_file);
+  TRACE_LOG("Loading parser resource from \"%s\"", model_file);
 
-    m_parser = parser_create_parser(model_file);
-    if (!m_parser) {
-        ERROR_LOG("Failed to create parser");
-        return -1;
-    }
+  m_parser = parser_create_parser(model_file);
+  if (!m_parser) {
+    ERROR_LOG("Failed to create parser");
+    return -1;
+  }
 
-    TRACE_LOG("Parser is loaded.");
+  TRACE_LOG("Parser is loaded.");
 
-    m_isParserResourceLoaded = true;
-    return 0;
+  m_isParserResourceLoaded = true;
+  return 0;
 }
 
 int LTPResource::LoadParserResource(const std::string & model_file) {
-    return LoadParserResource(model_file.c_str());
+  return LoadParserResource(model_file.c_str());
 }
 
 void LTPResource::ReleaseParserResource() {
-    if (!m_isParserResourceLoaded) {
-        return;
-    }
+  if (!m_isParserResourceLoaded) {
+    return;
+  }
 
-    parser_release_parser(m_parser);
-    TRACE_LOG("Parser is released");
+  parser_release_parser(m_parser);
+  TRACE_LOG("Parser is released");
 
-    m_parser = NULL;
-    m_isParserResourceLoaded = false;
+  m_parser = NULL;
+  m_isParserResourceLoaded = false;
 }
 
 void * LTPResource::GetParser() {
-    return m_parser;
+  return m_parser;
 }
 
 /* ======================================================== *
  * SRL related resource management                          *
  * ======================================================== */
 int LTPResource::LoadSRLResource(const char *data_folder) {
-    if (m_isSRLResourceLoaded) {
-        return 0;
-    }
+  if (m_isSRLResourceLoaded) {
+    return 0;
+  }
 
-    TRACE_LOG("Loading SRL resource from \"%s\"", data_folder);
+  TRACE_LOG("Loading SRL resource from \"%s\"", data_folder);
 
-    if (0 != SRL_LoadResource(string(data_folder))) {
-        ERROR_LOG("Failed to load SRL resource.");
-        return -1;
-    }
+  if (0 != SRL_LoadResource(string(data_folder))) {
+    ERROR_LOG("Failed to load SRL resource.");
+    return -1;
+  }
 
-    TRACE_LOG("SRL resource is loaded.");
-    m_isSRLResourceLoaded = true;
-    return 0;
+  TRACE_LOG("SRL resource is loaded.");
+  m_isSRLResourceLoaded = true;
+  return 0;
 }
 
 int LTPResource::LoadSRLResource(const std::string & data_folder) {
-    return LoadSRLResource(data_folder.c_str());
+  return LoadSRLResource(data_folder.c_str());
 }
 
 void LTPResource::ReleaseSRLResource() {
-    if (!m_isSRLResourceLoaded) {
-        return;
-    }
-
-    if (0 != SRL_ReleaseResource()) {
-        ERROR_LOG("Failed to release SRL resource");
-        return;
-    }
+  if (!m_isSRLResourceLoaded) {
+    return;
+  }
 
-    m_isSRLResourceLoaded = false;
+  if (0 != SRL_ReleaseResource()) {
+    ERROR_LOG("Failed to release SRL resource");
     return;
+  }
+
+  m_isSRLResourceLoaded = false;
+  return;
 }
 
diff --git a/src/__ltp_dll/Ltp.cpp b/src/__ltp_dll/Ltp.cpp
index dd4635601..4ddae08aa 100644
--- a/src/__ltp_dll/Ltp.cpp
+++ b/src/__ltp_dll/Ltp.cpp
@@ -29,516 +29,499 @@ using namespace std;
 
 // create a platform
 LTP::LTP() :
-    m_ltpResource(),
-    m_loaded(false) {
-    ReadConfFile();
+  m_ltpResource(),
+  m_loaded(false) {
+  ReadConfFile();
 }
 
 LTP::LTP(const char * config) :
-    m_ltpResource(),
-    m_loaded(false) {
-    ReadConfFile(config);
+  m_ltpResource(),
+  m_loaded(false) {
+  ReadConfFile(config);
 }
 
 LTP::~LTP() {
 }
 
 bool LTP::loaded() {
-    return m_loaded;
+  return m_loaded;
 }
 
-/*
- * discard functions
- */
-/*
-int LTP::CreateDOMFromTxt(const char * cszTxtFileName, XML4NLP& xml) {
-    return xml.CreateDOMFromFile(cszTxtFileName);
-}
-
-int LTP::CreateDOMFromXml(const char * cszXmlFileName, XML4NLP& xml) {
-    return xml.LoadXMLFromFile(cszXmlFileName);
-}
-
-int LTP::SaveDOM(const char * cszSaveFileName, XML4NLP& xml) {
-    return xml.SaveDOM(cszSaveFileName);
-}
-*/
-
 int LTP::ReadConfFile(const char * config_file) {
-    ltp::utility::ConfigParser cfg(config_file);
+  ltp::utility::ConfigParser cfg(config_file);
+
+  if (!cfg) {
+    ERROR_LOG("Failed to open config file \"%s\"", config_file);
+    return -1;
+  }
+
+  std::string buffer;
+
+  int target_mask = 0;
+  // load target from config
+  // initialize target mask
+  if (cfg.get("target", buffer)) {
+    if (buffer == "ws") {
+      target_mask = (1<<1);
+    } else if (buffer == "pos") {
+      target_mask = ((1<<1)|(1<<2));
+    } else if (buffer == "ner") {
+      target_mask = ((1<<1)|(1<<2)|(1<<3));
+    } else if (buffer == "dp") {
+      target_mask = ((1<<1)|(1<<2)|(1<<4));
+    } else if ((buffer == "srl") || (buffer == "all")) {
+      target_mask = ((1<<1)|(1<<2)|(1<<3)|(1<<4)|(1<<5));
+    }
+  } else {
+    WARNING_LOG("No \"target\" config is found, srl is set as default");
+    target_mask = ((1<<1)|(1<<2)|(1<<3)|(1<<4)|(1<<5));
+  }
+
+  int loaded_mask = 0;
+
+  if (target_mask & (1<<1)) {
+    if (cfg.get("segmentor-model", buffer)) {
+      // segment model item exists
+      // load segmentor model
+      if (0 != m_ltpResource.LoadSegmentorResource(buffer)) {
+        ERROR_LOG("in LTP::wordseg, failed to load segmentor resource");
+        return -1;
+      }
+      loaded_mask |= (1<<1);
+    } else {
+      WARNING_LOG("No \"segmentor-model\" config is found");
+    }
+  }
 
-    if (!cfg) {
-        TRACE_LOG("Failed to open config file \"%s\"", config_file);
+  if (target_mask & (1<<2)) {
+    if (cfg.get("postagger-model", buffer)) {
+      // postag model item exists
+      // load postagger model
+      if (0 != m_ltpResource.LoadPostaggerResource(buffer)) {
+        ERROR_LOG("in LTP::postag, failed to load postagger resource.");
         return -1;
+      }
+      loaded_mask |= (1<<2);
+    } else {
+      WARNING_LOG("No \"postagger-model\" config is found");
     }
+  }
 
-    std::string buffer;
-
-    int target_mask = 0;
-    // load target from config
-    // initialize target mask
-    if (cfg.get("target", buffer)) {
-        if (buffer == "ws") {
-            target_mask = (1<<1);
-        } else if (buffer == "pos") {
-            target_mask = ((1<<1)|(1<<2));
-        } else if (buffer == "ner") {
-            target_mask = ((1<<1)|(1<<2)|(1<<3));
-        } else if (buffer == "dp") {
-            target_mask = ((1<<1)|(1<<2)|(1<<4));
-        } else if ((buffer == "srl") || (buffer == "all")) {
-            target_mask = ((1<<1)|(1<<2)|(1<<3)|(1<<4)|(1<<5));
-        }
+  if (target_mask & (1<<3)) {
+    if (cfg.get("ner-model", buffer)) {
+      // ner model item exists
+      // load ner model
+      if (0 != m_ltpResource.LoadNEResource(buffer)) {
+        ERROR_LOG("in LTP::ner, failed to load ner resource");
+        return -1;
+      }
+      loaded_mask |= (1<<3);
     } else {
-        WARNING_LOG("No \"target\" config is found, srl is set as default");
-        target_mask = ((1<<1)|(1<<2)|(1<<3)|(1<<4)|(1<<5));
-    }
-
-    int loaded_mask = 0;
-
-    if (target_mask & (1<<1)) {
-        if (cfg.get("segmentor-model", buffer)) {
-            // segment model item exists
-            // load segmentor model
-            if (0 != m_ltpResource.LoadSegmentorResource(buffer)) {
-                ERROR_LOG("in LTP::wordseg, failed to load segmentor resource");
-                return -1;
-            }
-            loaded_mask |= (1<<1);
-        } else {
-            WARNING_LOG("No \"segmentor-model\" config is found");
-        }
-    }
-
-    if (target_mask & (1<<2)) {
-        if (cfg.get("postagger-model", buffer)) {
-            // postag model item exists
-            // load postagger model
-            if (0 != m_ltpResource.LoadPostaggerResource(buffer)) {
-                ERROR_LOG("in LTP::postag, failed to load postagger resource.");
-                return -1;
-            }
-            loaded_mask |= (1<<2);
-        } else {
-            WARNING_LOG("No \"postagger-model\" config is found");
-        }
-    }
-
-    if (target_mask & (1<<3)) {
-        if (cfg.get("ner-model", buffer)) {
-            // ner model item exists
-            // load ner model
-            if (0 != m_ltpResource.LoadNEResource(buffer)) {
-                ERROR_LOG("in LTP::ner, failed to load ner resource");
-                return -1;
-            }
-            loaded_mask |= (1<<3);
-        } else {
-            WARNING_LOG("No \"ner-model\" config is found");
-        }
-    }
-
-    if (target_mask & (1<<4)) {
-        if (cfg.get("parser-model", buffer)) {
-            //load paser model
-            if ( 0 != m_ltpResource.LoadParserResource(buffer) ) {
-                ERROR_LOG("in LTP::parser, failed to load parser resource");
-                return -1;
-            }
-            loaded_mask |= (1<<4);
-        } else {
-            WARNING_LOG("No \"parser-model\" config is found");
-        }
-    }
-
-    if (target_mask & (1<<5)) {
-        if (cfg.get("srl-data", buffer)) {
-            //load srl model
-            if ( 0 != m_ltpResource.LoadSRLResource(buffer) ) {
-                ERROR_LOG("in LTP::srl, failed to load srl resource");
-                return -1;
-            }
-            loaded_mask |= (1<<5);
-        } else {
-            WARNING_LOG("No \"srl-data\" config is found");
-        }
-    }
-
-    if ((loaded_mask & target_mask) != target_mask) {
-        ERROR_LOG("target is config but resource not loaded.");
+      WARNING_LOG("No \"ner-model\" config is found");
+    }
+  }
+
+  if (target_mask & (1<<4)) {
+    if (cfg.get("parser-model", buffer)) {
+      //load paser model
+      if ( 0 != m_ltpResource.LoadParserResource(buffer) ) {
+        ERROR_LOG("in LTP::parser, failed to load parser resource");
         return -1;
+      }
+      loaded_mask |= (1<<4);
+    } else {
+      WARNING_LOG("No \"parser-model\" config is found");
     }
+  }
 
-    m_loaded = true;
-    return 0;
+  if (target_mask & (1<<5)) {
+    if (cfg.get("srl-data", buffer)) {
+      //load srl model
+      if ( 0 != m_ltpResource.LoadSRLResource(buffer) ) {
+        ERROR_LOG("in LTP::srl, failed to load srl resource");
+        return -1;
+      }
+      loaded_mask |= (1<<5);
+    } else {
+      WARNING_LOG("No \"srl-data\" config is found");
+    }
+  }
+
+  if ((loaded_mask & target_mask) != target_mask) {
+    ERROR_LOG("target is config but resource not loaded.");
+    return -1;
+  }
+
+  m_loaded = true;
+  return 0;
 }
 
 // If you do NOT split sentence explicitly,
 // this will be called according to dependencies among modules
 int LTP::splitSentence_dummy(XML4NLP & xml) {
-    if ( xml.QueryNote(NOTE_SENT) ) {
-        return 0;
-    }
+  if ( xml.QueryNote(NOTE_SENT) ) {
+    return 0;
+  }
 
-    int paraNum = xml.CountParagraphInDocument();
+  int paraNum = xml.CountParagraphInDocument();
 
-    if (paraNum == 0) {
-        ERROR_LOG("in LTP::splitsent, There is no paragraph in doc,");
-        ERROR_LOG("you may have loaded a blank file or have not loaded a file yet.");
-        return -1;
-    }
+  if (paraNum == 0) {
+    ERROR_LOG("in LTP::splitsent, There is no paragraph in doc,");
+    ERROR_LOG("you may have loaded a blank file or have not loaded a file yet.");
+    return -1;
+  }
 
-    for (int i = 0; i < paraNum; ++i) {
-        vector<string> vecSentences;
-        string para;
-        xml.GetParagraph(i, para);
+  for (int i = 0; i < paraNum; ++i) {
+    vector<string> vecSentences;
+    string para;
+    xml.GetParagraph(i, para);
 
-        if (0 == SplitSentence( para, vecSentences )) {
-            ERROR_LOG("in LTP::splitsent, failed to split sentence");
-            return -1;
-        }
+    if (0 == SplitSentence( para, vecSentences )) {
+      ERROR_LOG("in LTP::splitsent, failed to split sentence");
+      return -1;
+    }
 
-        // dummy
-        // vecSentences.push_back(para);
-        if (0 != xml.SetSentencesToParagraph(vecSentences, i)) {
-            ERROR_LOG("in LTP::splitsent, failed to write sentence to xml");
-            return -1;
-        }
+    // dummy
+    // vecSentences.push_back(para);
+    if (0 != xml.SetSentencesToParagraph(vecSentences, i)) {
+      ERROR_LOG("in LTP::splitsent, failed to write sentence to xml");
+      return -1;
     }
+  }
 
-    xml.SetNote(NOTE_SENT);
-    return 0;
+  xml.SetNote(NOTE_SENT);
+  return 0;
 }
 
 // integrate word segmentor into LTP
 int LTP::wordseg(XML4NLP & xml) {
-    if (xml.QueryNote(NOTE_WORD)) {
-        return 0;
-    }
+  if (xml.QueryNote(NOTE_WORD)) {
+    return 0;
+  }
 
-    //
-    if (0 != splitSentence_dummy(xml)) {
-        ERROR_LOG("in LTP::wordseg, failed to perform split sentence preprocess.");
-        return -1;
-    }
+  //
+  if (0 != splitSentence_dummy(xml)) {
+    ERROR_LOG("in LTP::wordseg, failed to perform split sentence preprocess.");
+    return -1;
+  }
 
-    /*if (0 != m_ltpResource.LoadSegmentorResource(m_ltpOption.segmentor_model_path)) {
-        ERROR_LOG("in LTP::wordseg, failed to load segmentor resource");
-        return -1;
-    }*/
+  /*if (0 != m_ltpResource.LoadSegmentorResource(m_ltpOption.segmentor_model_path)) {
+    ERROR_LOG("in LTP::wordseg, failed to load segmentor resource");
+    return -1;
+  }*/
 
-    // get the segmentor pointer
-    void * segmentor = m_ltpResource.GetSegmentor();
-    if (0 == segmentor) {
-        ERROR_LOG("in LTP::wordseg, failed to init a segmentor");
-        return -1;
-    }
+  // get the segmentor pointer
+  void * segmentor = m_ltpResource.GetSegmentor();
+  if (0 == segmentor) {
+    ERROR_LOG("in LTP::wordseg, failed to init a segmentor");
+    return -1;
+  }
 
-    int stnsNum = xml.CountSentenceInDocument();
+  int stnsNum = xml.CountSentenceInDocument();
 
-    if (0 == stnsNum) {
-        ERROR_LOG("in LTP::wordseg, number of sentence equals 0");
-        return -1;
-    }
+  if (0 == stnsNum) {
+    ERROR_LOG("in LTP::wordseg, number of sentence equals 0");
+    return -1;
+  }
 
-    for (int i = 0; i < stnsNum; ++ i) {
-        string strStn = xml.GetSentence(i);
-        vector<string> vctWords;
+  for (int i = 0; i < stnsNum; ++ i) {
+    std::string strStn = xml.GetSentence(i);
+    std::vector<std::string> vctWords;
 
-        if (ltp::strutils::codecs::length(strStn) > MAX_SENTENCE_LEN) {
-            ERROR_LOG("in LTP::wordseg, input sentence is too long");
-            return -1;
-        }
+    if (ltp::strutils::codecs::length(strStn) > MAX_SENTENCE_LEN) {
+      ERROR_LOG("in LTP::wordseg, input sentence is too long");
+      return -1;
+    }
 
-        if (0 == segmentor_segment(segmentor, strStn, vctWords)) {
-            ERROR_LOG("in LTP::wordseg, failed to perform word segment on \"%s\"",
-                    strStn.c_str());
-            return -1;
-        }
+    if (0 == segmentor_segment(segmentor, strStn, vctWords)) {
+      ERROR_LOG("in LTP::wordseg, failed to perform word segment on \"%s\"",
+          strStn.c_str());
+      return -1;
+    }
 
-        if (0 != xml.SetWordsToSentence(vctWords, i)) {
-            ERROR_LOG("in LTP::wordseg, failed to write segment result to xml");
-            return -1;
-        }
+    if (0 != xml.SetWordsToSentence(vctWords, i)) {
+      ERROR_LOG("in LTP::wordseg, failed to write segment result to xml");
+      return -1;
     }
+  }
 
-    xml.SetNote(NOTE_WORD);
-    return 0;
+  xml.SetNote(NOTE_WORD);
+  return 0;
 }
 
 // integrate postagger into LTP
 int LTP::postag(XML4NLP & xml) {
-    if ( xml.QueryNote(NOTE_POS) ) {
-        return 0;
-    }
+  if ( xml.QueryNote(NOTE_POS) ) {
+    return 0;
+  }
 
-    // dependency
-    if (0 != wordseg(xml)) {
-        ERROR_LOG("in LTP::postag, failed to perform word segment preprocess");
-        return -1;
-    }
+  // dependency
+  if (0 != wordseg(xml)) {
+    ERROR_LOG("in LTP::postag, failed to perform word segment preprocess");
+    return -1;
+  }
 
-    /*if (0 != m_ltpResource.LoadPostaggerResource(m_ltpOption.postagger_model_path)) {
-        ERROR_LOG("in LTP::postag, failed to load postagger resource.");
-        return -1;
-    }*/
+  /*if (0 != m_ltpResource.LoadPostaggerResource(m_ltpOption.postagger_model_path)) {
+    ERROR_LOG("in LTP::postag, failed to load postagger resource.");
+    return -1;
+  }*/
 
-    void * postagger = m_ltpResource.GetPostagger();
-    if (0 == postagger) {
-        ERROR_LOG("in LTP::postag, failed to init a postagger");
-        return -1;
-    }
+  void * postagger = m_ltpResource.GetPostagger();
+  if (0 == postagger) {
+    ERROR_LOG("in LTP::postag, failed to init a postagger");
+    return -1;
+  }
 
-    int stnsNum = xml.CountSentenceInDocument();
+  int stnsNum = xml.CountSentenceInDocument();
 
-    if (0 == stnsNum) {
-        ERROR_LOG("in LTP::postag, number of sentence equals 0");
-        return -1;
-    }
+  if (0 == stnsNum) {
+    ERROR_LOG("in LTP::postag, number of sentence equals 0");
+    return -1;
+  }
 
-    for (int i = 0; i < stnsNum; ++i) {
-        vector<string> vecWord;
-        vector<string> vecPOS;
+  for (int i = 0; i < stnsNum; ++i) {
+    vector<string> vecWord;
+    vector<string> vecPOS;
 
-        xml.GetWordsFromSentence(vecWord, i);
+    xml.GetWordsFromSentence(vecWord, i);
 
-        if (0 == vecWord.size()) {
-            ERROR_LOG("Input sentence is empty.");
-            return -1;
-        }
+    if (0 == vecWord.size()) {
+      ERROR_LOG("Input sentence is empty.");
+      return -1;
+    }
 
-        if (vecWord.size() > MAX_WORDS_NUM) {
-            ERROR_LOG("Input sentence is too long.");
-            return -1;
-        }
+    if (vecWord.size() > MAX_WORDS_NUM) {
+      ERROR_LOG("Input sentence is too long.");
+      return -1;
+    }
 
-        if (0 == postagger_postag(postagger, vecWord, vecPOS)) {
-            ERROR_LOG("in LTP::postag, failed to perform postag on sent. #%d", i+1);
-            return -1;
-        }
+    if (0 == postagger_postag(postagger, vecWord, vecPOS)) {
+      ERROR_LOG("in LTP::postag, failed to perform postag on sent. #%d", i+1);
+      return -1;
+    }
 
-        if (xml.SetPOSsToSentence(vecPOS, i) != 0) {
-            ERROR_LOG("in LTP::postag, failed to write postag result to xml");
-            return -1;
-        }
+    if (xml.SetPOSsToSentence(vecPOS, i) != 0) {
+      ERROR_LOG("in LTP::postag, failed to write postag result to xml");
+      return -1;
     }
+  }
 
-    xml.SetNote(NOTE_POS);
+  xml.SetNote(NOTE_POS);
 
-    return 0;
+  return 0;
 }
 
 // perform ner over xml
-int LTP::ner(XML4NLP &   xml) {
-    if ( xml.QueryNote(NOTE_NE) ) {
-        return 0;
-    }
+int LTP::ner(XML4NLP & xml) {
+  if ( xml.QueryNote(NOTE_NE) ) {
+    return 0;
+  }
 
-    // dependency
-    if (0 != postag(xml)) {
-        ERROR_LOG("in LTP::ner, failed to perform postag preprocess");
-        return -1;
-    }
+  // dependency
+  if (0 != postag(xml)) {
+    ERROR_LOG("in LTP::ner, failed to perform postag preprocess");
+    return -1;
+  }
 
-    /*if (0 != m_ltpResource.LoadNEResource(m_ltpOption.ner_model_path)) {
-        ERROR_LOG("in LTP::ner, failed to load ner resource");
-        return -1;
-    }*/
+  /*if (0 != m_ltpResource.LoadNEResource(m_ltpOption.ner_model_path)) {
+    ERROR_LOG("in LTP::ner, failed to load ner resource");
+    return -1;
+  }*/
 
-    void * ner = m_ltpResource.GetNER();
+  void * ner = m_ltpResource.GetNER();
 
-    if (NULL == ner) {
-        ERROR_LOG("in LTP::ner, failed to init a ner.");
-        return -1;
-    }
+  if (NULL == ner) {
+    ERROR_LOG("in LTP::ner, failed to init a ner.");
+    return -1;
+  }
 
-    int stnsNum = xml.CountSentenceInDocument();
+  int stnsNum = xml.CountSentenceInDocument();
 
-    if (stnsNum == 0) {
-        ERROR_LOG("in LTP::ner, number of sentence equals 0");
-        return -1;
-    }
-
-    for (int i = 0; i < stnsNum; ++ i) {
-        vector<string> vecWord;
-        vector<string> vecPOS;
-        vector<string> vecNETag;
+  if (stnsNum == 0) {
+    ERROR_LOG("in LTP::ner, number of sentence equals 0");
+    return -1;
+  }
 
-        if (xml.GetWordsFromSentence(vecWord, i) != 0) {
-            ERROR_LOG("in LTP::ner, failed to get words from xml");
-            return -1;
-        }
+  for (int i = 0; i < stnsNum; ++ i) {
+    vector<string> vecWord;
+    vector<string> vecPOS;
+    vector<string> vecNETag;
 
-        if (xml.GetPOSsFromSentence(vecPOS, i) != 0) {
-            ERROR_LOG("in LTP::ner, failed to get postags from xml");
-            return -1;
-        }
+    if (xml.GetWordsFromSentence(vecWord, i) != 0) {
+      ERROR_LOG("in LTP::ner, failed to get words from xml");
+      return -1;
+    }
 
-        if (0 == vecWord.size()) {
-            ERROR_LOG("Input sentence is empty.");
-            return -1;
-        }
+    if (xml.GetPOSsFromSentence(vecPOS, i) != 0) {
+      ERROR_LOG("in LTP::ner, failed to get postags from xml");
+      return -1;
+    }
 
-        if (vecWord.size() > MAX_WORDS_NUM) {
-            ERROR_LOG("Input sentence is too long.");
-            return -1;
-        }
+    if (0 == vecWord.size()) {
+      ERROR_LOG("Input sentence is empty.");
+      return -1;
+    }
 
-        if (0 == ner_recognize(ner, vecWord, vecPOS, vecNETag)) {
-            ERROR_LOG("in LTP::ner, failed to perform ner on sent. #%d", i+1);
-            return -1;
-        }
+    if (vecWord.size() > MAX_WORDS_NUM) {
+      ERROR_LOG("Input sentence is too long.");
+      return -1;
+    }
 
-        xml.SetNEsToSentence(vecNETag, i);
+    if (0 == ner_recognize(ner, vecWord, vecPOS, vecNETag)) {
+      ERROR_LOG("in LTP::ner, failed to perform ner on sent. #%d", i+1);
+      return -1;
     }
 
-    xml.SetNote(NOTE_NE);
-    return 0;
+    xml.SetNEsToSentence(vecNETag, i);
+  }
+
+  xml.SetNote(NOTE_NE);
+  return 0;
 }
 
 int LTP::parser(XML4NLP & xml) {
-    if ( xml.QueryNote(NOTE_PARSER) ) return 0;
+  if ( xml.QueryNote(NOTE_PARSER) ) return 0;
 
-    if (0 != postag(xml)) {
-        ERROR_LOG("in LTP::parser, failed to perform postag preprocessing");
-        return -1;
-    }
+  if (0 != postag(xml)) {
+    ERROR_LOG("in LTP::parser, failed to perform postag preprocessing");
+    return -1;
+  }
 
-    /*if ( 0 != m_ltpResource.LoadParserResource(m_ltpOption.parser_model_path) ) {
-        ERROR_LOG("in LTP::parser, failed to load parser resource");
-        return -1;
-    }*/
+  /*if ( 0 != m_ltpResource.LoadParserResource(m_ltpOption.parser_model_path) ) {
+    ERROR_LOG("in LTP::parser, failed to load parser resource");
+    return -1;
+  }*/
 
-    void * parser = m_ltpResource.GetParser();
+  void * parser = m_ltpResource.GetParser();
 
-    if (parser == NULL) {
-        ERROR_LOG("in LTP::parser, failed to init a parser");
-        return -1;
-    }
+  if (parser == NULL) {
+    ERROR_LOG("in LTP::parser, failed to init a parser");
+    return -1;
+  }
 
-    int stnsNum = xml.CountSentenceInDocument();
-    if (stnsNum == 0) {
-        ERROR_LOG("in LTP::parser, number of sentences equals 0");
-        return -1;
-    }
+  int stnsNum = xml.CountSentenceInDocument();
+  if (stnsNum == 0) {
+    ERROR_LOG("in LTP::parser, number of sentences equals 0");
+    return -1;
+  }
 
-    for (int i = 0; i < stnsNum; ++i) {
-        vector<string>  vecWord;
-        vector<string>  vecPOS;
-        vector<int>     vecHead;
-        vector<string>  vecRel;
+  for (int i = 0; i < stnsNum; ++i) {
+    std::vector<std::string>  vecWord;
+    std::vector<std::string>  vecPOS;
+    std::vector<int>          vecHead;
+    std::vector<std::string>  vecRel;
 
-        if (xml.GetWordsFromSentence(vecWord, i) != 0) {
-            ERROR_LOG("in LTP::parser, failed to get words from xml");
-            return -1;
-        }
+    if (xml.GetWordsFromSentence(vecWord, i) != 0) {
+      ERROR_LOG("in LTP::parser, failed to get words from xml");
+      return -1;
+    }
 
-        if (xml.GetPOSsFromSentence(vecPOS, i) != 0) {
-            ERROR_LOG("in LTP::parser, failed to get postags from xml");
-            return -1;
-        }
+    if (xml.GetPOSsFromSentence(vecPOS, i) != 0) {
+      ERROR_LOG("in LTP::parser, failed to get postags from xml");
+      return -1;
+    }
 
-        if (0 == vecWord.size()) {
-            ERROR_LOG("Input sentence is empty.");
-            return -1;
-        }
+    if (0 == vecWord.size()) {
+      ERROR_LOG("Input sentence is empty.");
+      return -1;
+    }
 
-        if (vecWord.size() > MAX_WORDS_NUM) {
-            ERROR_LOG("Input sentence is too long.");
-            return -1;
-        }
+    if (vecWord.size() > MAX_WORDS_NUM) {
+      ERROR_LOG("Input sentence is too long.");
+      return -1;
+    }
 
-        if (-1 == parser_parse(parser, vecWord, vecPOS, vecHead, vecRel)) {
-            ERROR_LOG("in LTP::parser, failed to perform parse on sent. #%d", i+1);
-            return -1;
-        }
+    if (-1 == parser_parse(parser, vecWord, vecPOS, vecHead, vecRel)) {
+      ERROR_LOG("in LTP::parser, failed to perform parse on sent. #%d", i+1);
+      return -1;
+    }
 
-        if (0 != xml.SetParsesToSentence(vecHead, vecRel, i)) {
-            ERROR_LOG("in LTP::parser, failed to write parse result to xml");
-            return -1;
-        }
+    if (0 != xml.SetParsesToSentence(vecHead, vecRel, i)) {
+      ERROR_LOG("in LTP::parser, failed to write parse result to xml");
+      return -1;
     }
+  }
 
-    xml.SetNote(NOTE_PARSER);
+  xml.SetNote(NOTE_PARSER);
 
-    return 0;
+  return 0;
 }
 
 int LTP::srl(XML4NLP & xml) {
-    if ( xml.QueryNote(NOTE_SRL) ) return 0;
+  if ( xml.QueryNote(NOTE_SRL) ) return 0;
 
-    // dependency
-    if (0 != ner(xml)) {
-        ERROR_LOG("in LTP::srl, failed to perform ner preprocess");
-        return -1;
+  // dependency
+  if (0 != ner(xml)) {
+    ERROR_LOG("in LTP::srl, failed to perform ner preprocess");
+    return -1;
+  }
+
+  if (0 != parser(xml)) {
+    ERROR_LOG("in LTP::srl, failed to perform parsing preprocess");
+    return -1;
+  }
+
+  /*if ( 0 != m_ltpResource.LoadSRLResource(m_ltpOption.srl_data_dir) ) {
+    ERROR_LOG("in LTP::srl, failed to load srl resource");
+    return -1;
+  }*/
+
+  int stnsNum = xml.CountSentenceInDocument();
+  if (stnsNum == 0) {
+    ERROR_LOG("in LTP::srl, number of sentence equals 0");
+    return -1;
+  }
+
+  for (int i = 0; i < stnsNum; ++i) {
+    vector<string>              vecWord;
+    vector<string>              vecPOS;
+    vector<string>              vecNE;
+    vector< pair<int, string> > vecParse;
+    vector< pair<int, vector< pair<const char *, pair< int, int > > > > > vecSRLResult;
+
+    if (xml.GetWordsFromSentence(vecWord, i) != 0) {
+      ERROR_LOG("in LTP::ner, failed to get words from xml");
+      return -1;
     }
 
-    if (0 != parser(xml)) {
-        ERROR_LOG("in LTP::srl, failed to perform parsing preprocess");
-        return -1;
+    if (xml.GetPOSsFromSentence(vecPOS, i) != 0) {
+      ERROR_LOG("in LTP::ner, failed to get postags from xml");
+      return -1;
     }
 
-    /*if ( 0 != m_ltpResource.LoadSRLResource(m_ltpOption.srl_data_dir) ) {
-        ERROR_LOG("in LTP::srl, failed to load srl resource");
-        return -1;
-    }*/
+    if (xml.GetNEsFromSentence(vecNE, i) != 0) {
+      ERROR_LOG("in LTP::ner, failed to get ner result from xml");
+      return -1;
+    }
 
-    int stnsNum = xml.CountSentenceInDocument();
-    if (stnsNum == 0) {
-        ERROR_LOG("in LTP::srl, number of sentence equals 0");
+    if (xml.GetParsesFromSentence(vecParse, i) != 0) {
+      ERROR_LOG("in LTP::ner, failed to get parsing result from xml");
+      return -1;
+    }
+
+    if (0 != SRL(vecWord, vecPOS, vecNE, vecParse, vecSRLResult)) {
+      ERROR_LOG("in LTP::srl, failed to perform srl on sent. #%d", i+1);
+      return -1;
+    }
+
+    int j = 0;
+    for (; j < vecSRLResult.size(); ++j) {
+      vector<string>        vecType;
+      vector< pair<int, int> >  vecBegEnd;
+      int k = 0;
+
+      for (; k < vecSRLResult[j].second.size(); ++k) {
+        vecType.push_back(vecSRLResult[j].second[k].first);
+        vecBegEnd.push_back(vecSRLResult[j].second[k].second);
+      }
+
+      if (0 != xml.SetPredArgToWord(i, vecSRLResult[j].first, vecType, vecBegEnd)) {
         return -1;
+      }
     }
+  }
 
-    for (int i = 0; i < stnsNum; ++i) {
-        vector<string>              vecWord;
-        vector<string>              vecPOS;
-        vector<string>              vecNE;
-        vector< pair<int, string> > vecParse;
-        vector< pair< int, vector< pair<const char *, pair< int, int > > > > > vecSRLResult;
-
-        if (xml.GetWordsFromSentence(vecWord, i) != 0) {
-            ERROR_LOG("in LTP::ner, failed to get words from xml");
-            return -1;
-        }
-
-        if (xml.GetPOSsFromSentence(vecPOS, i) != 0) {
-            ERROR_LOG("in LTP::ner, failed to get postags from xml");
-            return -1;
-        }
-
-        if (xml.GetNEsFromSentence(vecNE, i) != 0) {
-            ERROR_LOG("in LTP::ner, failed to get ner result from xml");
-            return -1;
-        }
-
-        if (xml.GetParsesFromSentence(vecParse, i) != 0) {
-            ERROR_LOG("in LTP::ner, failed to get parsing result from xml");
-            return -1;
-        }
-
-        if (0 != SRL(vecWord, vecPOS, vecNE, vecParse, vecSRLResult)) {
-            ERROR_LOG("in LTP::srl, failed to perform srl on sent. #%d", i+1);
-            return -1;
-        }
-
-        int j = 0;
-        for (; j < vecSRLResult.size(); ++j) {
-            vector<string>              vecType;
-            vector< pair<int, int> >    vecBegEnd;
-            int k = 0;
-
-            for (; k < vecSRLResult[j].second.size(); ++k) {
-                vecType.push_back(vecSRLResult[j].second[k].first);
-                vecBegEnd.push_back(vecSRLResult[j].second[k].second);
-            }
-
-            if (0 != xml.SetPredArgToWord(i, vecSRLResult[j].first, vecType, vecBegEnd)) {
-                return -1;
-            }
-        }
-    }
-
-    xml.SetNote(NOTE_SRL);
-    return 0;
+  xml.SetNote(NOTE_SRL);
+  return 0;
 }
 
diff --git a/src/__ltp_dll/Ltp.h b/src/__ltp_dll/Ltp.h
index cb77d55d5..1dc387fc6 100644
--- a/src/__ltp_dll/Ltp.h
+++ b/src/__ltp_dll/Ltp.h
@@ -16,103 +16,104 @@ using namespace std;
 
 // extern ofstream ltp_log_file;
 #define MAX_SENTENCE_LEN 300
-#define MAX_WORDS_NUM    70
+#define MAX_WORDS_NUM  70
 
 class LTP {
 public:
 
-    /*
-     * the constructor with config filepath specified to `conf/ltp.cnf`
-     */
-    LTP();
-
-    /*
-     * the another constructor with user specified config file
-     *
-     *  @param[in]  cfg_file    the path to the config file
-     */
-    LTP(const char * cfg_file);
-
-    /*
-     * deallocate the ltp resource
-     */
-    ~LTP();
-
-    /*
-     * return true on the resource successful loaded, otherwise false
-     */
-    bool loaded();
-
-    // discard
-    // int CreateDOMFromTxt(const char * cszTxtFileName, XML4NLP& m_xml4nlp);
-
-    // discard
-    // int CreateDOMFromXml(const char * cszXmlFileName, XML4NLP& m_xml4nlp);
-
-    // save dom tree
-    // int SaveDOM(const char *cszSaveFileName, XML4NLP& m_xml4nlp);
-
-    /*
-     * do word segmentation.
-     *
-     *  @param[in/out]  xml     the xml storing ltp result
-     *  @return         int     0 on success, otherwise -1
-     */
-    int wordseg(XML4NLP & xml);
-
-    /*
-     * do postagging
-     *
-     *  @param[in/out]  xml     the xml storing ltp result
-     *  @return         int     0 on success, otherwise -1
-     */
-    int postag(XML4NLP & xml);
-
-    /*
-     * do name entities recognization
-     *
-     *  @param[in/out]  xml     the xml storing ltp result
-     *  @return         int     0 on success, otherwise -1
-     */
-    int ner(XML4NLP & xml);
-
-    /*
-     * do dependency parsing
-     *
-     *  @param[in/out]  xml     the xml storing ltp result
-     *  @return         int     0 on success, otherwise -1
-     */
-    int parser(XML4NLP & xml);
-
-    /*
-     * do semantic role labeling
-     *
-     *  @param[in/out]  xml     the xml storing ltp result
-     *  @return         int     0 on success, otherwise -1
-     */
-    int srl(XML4NLP & xml);
-
+  /*
+   * the constructor with config filepath specified to `conf/ltp.cnf`
+   */
+  LTP();
+
+  /*
+   * the another constructor with user specified config file
+   *
+   *  @param[in]  cfg_file  the path to the config file
+   */
+  LTP(const char * cfg_file);
+
+  /*
+   * deallocate the ltp resource
+   */
+  ~LTP();
+
+  /*
+   * return true on the resource successful loaded, otherwise false
+   */
+  bool loaded();
+
+  // discard
+  // int CreateDOMFromTxt(const char * cszTxtFileName, XML4NLP& m_xml4nlp);
+
+  // discard
+  // int CreateDOMFromXml(const char * cszXmlFileName, XML4NLP& m_xml4nlp);
+
+  // save dom tree
+  // int SaveDOM(const char *cszSaveFileName, XML4NLP& m_xml4nlp);
+
+  /*
+   * do word segmentation.
+   *
+   *  @param[in/out]  xml   the xml storing ltp result
+   *  @return         int   0 on success, otherwise -1
+   */
+  int wordseg(XML4NLP & xml);
+
+  /*
+   * do postagging
+   *
+   *  @param[in/out]  xml   the xml storing ltp result
+   *  @return         int   0 on success, otherwise -1
+   */
+  int postag(XML4NLP & xml);
+
+  /*
+   * do name entities recognization
+   *
+   *  @param[in/out]  xml   the xml storing ltp result
+   *  @return         int   0 on success, otherwise -1
+   */
+  int ner(XML4NLP & xml);
+
+  /*
+   * do dependency parsing
+   *
+   *  @param[in/out]  xml   the xml storing ltp result
+   *  @return         int   0 on success, otherwise -1
+   */
+  int parser(XML4NLP & xml);
+
+  /*
+   * do semantic role labeling
+   *
+   *  @param[in/out]  xml   the xml storing ltp result
+   *  @return         int   0 on success, otherwise -1
+   */
+  int srl(XML4NLP & xml);
+
+  int splitSentence_dummy(XML4NLP & xml);
 private:
 
-    /*
-     * split the sentence
-     *
-     *  @param[in/out]  xml     the xml storing ltp result
-     *  @return         int     0 on success, otherwise -1
-     */
-    int splitSentence_dummy(XML4NLP & xml);
-
-    /*
-     * parse the config file, and load resource according the config
-     *
-     *  @param[in]  confFileName    the config file
-     *  @return     int             0 on success, otherwise -1
-     */
-    int ReadConfFile(const char *confFileName = "conf/ltp.cnf");
+  /*
+   * split the sentence
+   *
+   *  @param[in/out]  xml   the xml storing ltp result
+   *  @return         int   0 on success, otherwise -1
+   */
+  //int splitSentence_dummy(XML4NLP & xml);
+
+  /*
+   * parse the config file, and load resource according the config
+   *
+   *  @param[in]  confFileName  the config file
+   *  @return     int           0 on success, otherwise -1
+   */
+  int ReadConfFile(const char *confFileName = "conf/ltp.cnf");
 
 private:
-    LTPResource m_ltpResource;      /*< the ltp resources */
-    bool        m_loaded;           /*< use to sepcify if the resource is loaded */
+  LTPResource m_ltpResource;    /*< the ltp resources */
+  bool        m_loaded;         /*< use to sepcify if the resource is loaded */
 };
 
 #endif  //  end for __LTP_H__
diff --git a/src/__xml4nlp/Xml4nlp.cpp b/src/__xml4nlp/Xml4nlp.cpp
index 5584cfa65..498fce10c 100644
--- a/src/__xml4nlp/Xml4nlp.cpp
+++ b/src/__xml4nlp/Xml4nlp.cpp
@@ -11,13 +11,13 @@
 #include "Xml4nlp.h"
 #include "MyLib.h"
 
-const char * const NOTE_SENT        = "sent";
-const char * const NOTE_WORD        = "word";
-const char * const NOTE_POS         = "pos";
-const char * const NOTE_NE          = "ne";
-const char * const NOTE_PARSER      = "parser";
-const char * const NOTE_WSD         = "wsd";
-const char * const NOTE_SRL         = "srl";
+const char * const NOTE_SENT    = "sent";
+const char * const NOTE_WORD    = "word";
+const char * const NOTE_POS     = "pos";
+const char * const NOTE_NE      = "ne";
+const char * const NOTE_PARSER  = "parser";
+const char * const NOTE_WSD     = "wsd";
+const char * const NOTE_SRL     = "srl";
 //const char * const NOTE_CLASS = "class";
 //const char * const NOTE_SUM = "sum";
 //const char * const NOTE_CR = "cr";
@@ -46,15 +46,15 @@ const char * const XML4NLP::TAG_END         = "end";
 const char * const XML4NLP::TAG_ID          = "id";
 
 XML4NLP::XML4NLP() {
-    m_document.documentPtr = NULL; 
-    m_note.nodePtr           = NULL;
-    m_summary.nodePtr        = NULL;
-    m_textclass.nodePtr      = NULL;
-    m_coref.nodePtr          = NULL;
+  document.documentPtr = NULL;
+  note.nodePtr         = NULL;
+  summary.nodePtr      = NULL;
+  textclass.nodePtr    = NULL;
+  coref.nodePtr        = NULL;
 }
 
 XML4NLP::~XML4NLP() {
-    m_tiXmlDoc.Clear();
+  m_tiXmlDoc.Clear();
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
@@ -62,29 +62,29 @@ XML4NLP::~XML4NLP() {
 /// the paragraphs are separated by CR ("\r\n")
 /////////////////////////////////////////////////////////////////////////////////////
 int XML4NLP::CreateDOMFromFile(const char* fileName) {
-    ClearDOM();
+  ClearDOM();
 
-    if (0 != BuildDOMFrame()) return -1;
+  if (0 != BuildDOMFrame()) return -1;
 
-    ifstream in;
-    in.open(fileName);
-    if ( !in.is_open() ) {
-        cerr << "xml4nlp load file error: " << fileName << endl;
-        return -1;
-    }
-
-    string line;
-    int i = 0;
-    while (getline(in, line)) {
-        clean_str(line); // Zhenghua Li, 2007-8-31, 15:57
-        // remove_space_gbk(line);
-        if (line.empty()) {
-            continue;
-        }
+  ifstream in;
+  in.open(fileName);
+  if ( !in.is_open() ) {
+    cerr << "xml4nlp load file error: " << fileName << endl;
+    return -1;
+  }
 
-        if (0 != BuildParagraph(line, i++)) return -1;
+  string line;
+  int i = 0;
+  while (getline(in, line)) {
+    clean_str(line); // Zhenghua Li, 2007-8-31, 15:57
+    // remove_space_gbk(line);
+    if (line.empty()) {
+      continue;
     }
-    return 0;
+
+    if (0 != BuildParagraph(line, i++)) return -1;
+  }
+  return 0;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
@@ -92,39 +92,38 @@ int XML4NLP::CreateDOMFromFile(const char* fileName) {
 /// the paragraphs are separated by CR ("\r\n")
 /////////////////////////////////////////////////////////////////////////////////////
 int XML4NLP::CreateDOMFromString(const string & str) {
-    ClearDOM();
+  ClearDOM();
 
-    if (0 != BuildDOMFrame()) return -1;
+  if (0 != BuildDOMFrame()) return -1;
 
-    string strTmp = str;
-    replace_char_by_char(strTmp, '\r', '\n');
+  string strTmp = str;
+  replace_char_by_char(strTmp, '\r', '\n');
 
-    // std::cout << strTmp << std::endl;
-    istringstream in(strTmp);	// How to use istringstream?
-    string line;
-    int i = 0;
-    while (getline(in, strTmp)) {
-        clean_str(strTmp);
+  // std::cout << strTmp << std::endl;
+  istringstream in(strTmp);  // How to use istringstream?
+  int i = 0;
+  while (getline(in, strTmp)) {
+    clean_str(strTmp);
 
-        if (strTmp.empty()) {
-            continue;
-        }
+    if (strTmp.empty()) {
+      continue;
+    }
 
-        if (0 != BuildParagraph(strTmp, i++)) {
-            return -1;
-        }
+    if (0 != BuildParagraph(strTmp, i++)) {
+      return -1;
     }
+  }
 
-    return 0;
+  return 0;
 }
 
 void XML4NLP::ReportTiXmlDocErr() const {
-    cerr << "[XML4NLP ERROR REPORT]" << endl;
-    cerr << "description : " << m_tiXmlDoc.ErrorDesc() << endl;
-    cerr << "location :    " << endl;
-    cerr << "row :         " << m_tiXmlDoc.ErrorRow() << endl;
-    cerr << "col :         " << m_tiXmlDoc.ErrorCol() << endl;
-    cerr << "=====================" << endl;
+  cerr << "[XML4NLP ERROR REPORT]" << endl;
+  cerr << "description : " << m_tiXmlDoc.ErrorDesc() << endl;
+  cerr << "location :  " << endl;
+  cerr << "row :     " << m_tiXmlDoc.ErrorRow() << endl;
+  cerr << "col :     " << m_tiXmlDoc.ErrorCol() << endl;
+  cerr << "=====================" << endl;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
@@ -135,1468 +134,1102 @@ void XML4NLP::ReportTiXmlDocErr() const {
 /// note: the input file must be a XML file.
 /////////////////////////////////////////////////////////////////////////////////////
 int XML4NLP::LoadXMLFromFile(const char* fileName) {
-    ClearDOM();
+  ClearDOM();
 
-    if ( !m_tiXmlDoc.LoadFile(fileName) ) {
-        cerr << "load xml file error: " << fileName << endl;
-        ReportTiXmlDocErr();
-        return -1;
-    }
+  if ( !m_tiXmlDoc.LoadFile(fileName) ) {
+    cerr << "load xml file error: " << fileName << endl;
+    ReportTiXmlDocErr();
+    return -1;
+  }
 
-    return InitXmlStructure();
+  return InitXmlStructure();
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
 /// load a xml file from a string and parse it.
 /////////////////////////////////////////////////////////////////////////////////////
 int XML4NLP::LoadXMLFromString(const char * str) {
-    ClearDOM();
-    m_tiXmlDoc.Parse(str);
+  ClearDOM();
+  m_tiXmlDoc.Parse(str);
 
-    if (m_tiXmlDoc.Error()) {
-        ReportTiXmlDocErr();
-        return -1;
-    }
+  if (m_tiXmlDoc.Error()) {
+    ReportTiXmlDocErr();
+    return -1;
+  }
 
-    if (-1 == InitXmlStructure()) {
-        return -1;
-    }
+  if (-1 == InitXmlStructure()) {
+    return -1;
+  }
 
-    if (!LTMLValidation()) {
-        // failed LTML Validation
-        return -1;
-    }
+  if (!LTMLValidation()) {
+    // failed LTML Validation
+    return -1;
+  }
 
-    return 0;
+  return 0;
 }
 
 int XML4NLP::LoadXMLFromString(const std::string & str) {
-    return LoadXMLFromString(str.c_str());
+  return LoadXMLFromString(str.c_str());
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
 /// clear the DOM tree, delete all nodes that allocated before.
 /////////////////////////////////////////////////////////////////////////////////////
 void XML4NLP::ClearDOM() {
-    m_tiXmlDoc.Clear();
+  m_tiXmlDoc.Clear();
 
-    m_document.documentPtr = NULL;
-    m_document.paragraphs.clear();
-    m_note.nodePtr = NULL;
-    m_summary.nodePtr = NULL;
-    m_textclass.nodePtr = NULL;
-    m_coref.nodePtr = NULL;
-    m_coref.vecEntity.clear();
+  document.documentPtr = NULL;
+  document.paragraphs.clear();
+  note.nodePtr = NULL;
+  summary.nodePtr = NULL;
+  textclass.nodePtr = NULL;
+  coref.nodePtr = NULL;
+  coref.vecEntity.clear();
 
-    m_vecBegWordIdxOfStns.clear();
-    m_vecBegStnsIdxOfPara.clear();
+  m_vecBegWordIdxOfStns.clear();
+  m_vecBegStnsIdxOfPara.clear();
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
 /// save the DOM tree to a XML file.
 /////////////////////////////////////////////////////////////////////////////////////
 int XML4NLP::SaveDOM(const char* fileName) {
-    if (!m_tiXmlDoc.SaveFile(fileName)) {
-        ReportTiXmlDocErr();
-        return -1;
-    }
+  if (!m_tiXmlDoc.SaveFile(fileName)) {
+    ReportTiXmlDocErr();
+    return -1;
+  }
 
-    return 0;
+  return 0;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
 /// save the DOM tree to a XML string.
 /////////////////////////////////////////////////////////////////////////////////////
 void XML4NLP::SaveDOM(string &strDocument) const {
-    TiXmlPrinter printer;
-    m_tiXmlDoc.Accept(&printer);
-    strDocument = printer.CStr();
+  TiXmlPrinter printer;
+  m_tiXmlDoc.Accept(&printer);
+  strDocument = printer.CStr();
 }
 
 // ----------------------------------------------------------------some counting functions
 int XML4NLP::CountParagraphInDocument() const {
-    return m_document.paragraphs.size();
+  return document.paragraphs.size();
 }
 
-int XML4NLP::CountSentenceInParagraph(int paragraphIdx) const {
-    if ( 0 != CheckRange(paragraphIdx) ) return 0;
-    return m_document.paragraphs[paragraphIdx].sentences.size();
+int XML4NLP::CountSentenceInParagraph(int pid) const {
+  if ( 0 != CheckRange(pid) ) return 0;
+  return document.paragraphs[pid].sentences.size();
 }
 
 int XML4NLP::CountSentenceInDocument() const {
-    int stnsNumInDoc = 0;
-    int paragraphNum = m_document.paragraphs.size();
-    for (int i = 0; i < paragraphNum; ++i) {
-        stnsNumInDoc += m_document.paragraphs[i].sentences.size();
-    }
-    return stnsNumInDoc;
+  int stnsNumInDoc = 0;
+  int paragraphNum = document.paragraphs.size();
+  for (int i = 0; i < paragraphNum; ++i) {
+    stnsNumInDoc += document.paragraphs[i].sentences.size();
+  }
+  return stnsNumInDoc;
 }
 
-int XML4NLP::CountWordInSentence(int paragraphIdx, int sentenceIdx) const {
-    if ( 0 != CheckRange(paragraphIdx, sentenceIdx) ) return 0;
-    return m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words.size();
+int XML4NLP::CountWordInSentence(int pid, int sid) const {
+  if ( 0 != CheckRange(pid, sid) ) return 0;
+  return document.paragraphs[pid].sentences[sid].words.size();
 }
 
-int XML4NLP::CountWordInSentence(int sentenceIdx) const {
-    pair<int, int> paraIdx_sentIdx;
-    if ( 0 != MapGlobalSentIdx2paraIdx_sentIdx(sentenceIdx, paraIdx_sentIdx) ) return 0;
-    return m_document.paragraphs[paraIdx_sentIdx.first].sentences[paraIdx_sentIdx.second].words.size();
+int XML4NLP::CountWordInSentence(int global_sid) const {
+  int pid, sid;
+  if ( 0 != DecodeGlobalId(global_sid, pid, sid) ) return 0;
+  return document.paragraphs[pid].sentences[sid].words.size();
 }
 
-int XML4NLP::CountWordInParagraph(int paragraphIdx) const {
-    if ( 0 != CheckRange(paragraphIdx) ) return -1;
-    int totalWordNum = 0;
-    int sentNum = m_document.paragraphs[paragraphIdx].sentences.size();
-    for (int i=0; i < sentNum; ++i) {
-        totalWordNum += m_document.paragraphs[paragraphIdx].sentences[i].words.size();
-    }
-    return totalWordNum;
+int XML4NLP::CountWordInParagraph(int pid) const {
+  if ( 0 != CheckRange(pid) ) return -1;
+  int nr_words = 0;
+  int nr_sents = document.paragraphs[pid].sentences.size();
+
+  for (int i = 0; i < nr_sents; ++ i) {
+    nr_words += document.paragraphs[pid].sentences[i].words.size();
+  }
+  return nr_words;
 }
 
 int XML4NLP::CountWordInDocument() const {
-    int totalWordNum = 0;
-    int paraNum = m_document.paragraphs.size();
-    for (int i=0; i<paraNum; ++i) {
-        int sentNum = m_document.paragraphs[i].sentences.size();
-        for (int j=0; j<sentNum; ++j) {
-            totalWordNum += m_document.paragraphs[i].sentences[j].words.size();
-        }
+  int nr_word = 0;
+  int nr_para = document.paragraphs.size();
+  for (int i = 0; i < nr_para; ++ i) {
+    int nr_sent = document.paragraphs[i].sentences.size();
+    for (int j = 0; j < nr_sent; ++ j) {
+      nr_word += document.paragraphs[i].sentences[j].words.size();
     }
-    return totalWordNum;
+  }
+  return nr_word;
 }
 
-const char * XML4NLP::GetParagraph(int paragraphIdx) const {
-    if (0 != CheckRange(paragraphIdx)) return NULL;
-    if (QueryNote(NOTE_SENT)) return NULL;
+const char * XML4NLP::GetParagraph(int pid) const {
+  if (0 != CheckRange(pid)) return NULL;
+  if (QueryNote(NOTE_SENT)) return NULL;
 
-    TiXmlElement *paraPtr = m_document.paragraphs[paragraphIdx].paragraphPtr;
-    return paraPtr->GetText();
+  TiXmlElement *paraPtr = document.paragraphs[pid].paragraphPtr;
+  return paraPtr->GetText();
 }
 
-int XML4NLP::GetParagraph(int paragraphIdx, string &strParagraph) const {
-    if (0 != CheckRange(paragraphIdx)) {
-        return -1;
-    }
+int XML4NLP::GetParagraph(int pid, string & str) const {
+  if (0 != CheckRange(pid)) { return -1; }
 
-    const Paragraph_t &paragraph = m_document.paragraphs[paragraphIdx];
+  const Paragraph &paragraph = document.paragraphs[pid];
 
-    if (paragraph.sentences.empty()) {
-        strParagraph = paragraph.paragraphPtr->GetText() ;
-    } else {
-        strParagraph = "";
-        const vector<Sentence_t> &sentences = paragraph.sentences;
-        for (int i=0; i<sentences.size(); ++i) {
-            strParagraph += sentences[i].sentencePtr->Attribute(TAG_CONT);
-        }
+  if (paragraph.sentences.empty()) {
+    str = paragraph.paragraphPtr->GetText() ;
+  } else {
+    str = "";
+    const vector<Sentence> &sentences = paragraph.sentences;
+    for (int i=0; i<sentences.size(); ++i) {
+      str += sentences[i].sentencePtr->Attribute(TAG_CONT);
     }
+  }
 
-    return 0;
-}
-
-const char* XML4NLP::GetSentence(int paragraphIdx, int sentenceIdx) const {
-    if (0 != CheckRange(paragraphIdx, sentenceIdx)) return NULL;
-    return m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].sentencePtr->Attribute(TAG_CONT);
-}
-
-const char* XML4NLP::GetSentence(int sentenceIdx) const {
-    pair<int, int> paraIdx_sentIdx;
-    if (0 != MapGlobalSentIdx2paraIdx_sentIdx(sentenceIdx, paraIdx_sentIdx)) return NULL;
-    return GetSentence(paraIdx_sentIdx.first, paraIdx_sentIdx.second);
+  return 0;
 }
 
-const char* XML4NLP::GetWord(int paragraphIdx, int sentenceIdx, int wordIdx) const {
-    if ( 0 != CheckRange(paragraphIdx, sentenceIdx, wordIdx) ) return NULL;
-    return m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words[wordIdx].wordPtr->Attribute(TAG_CONT);
-}
+#define EXTEND_FUNCTION(return_type, function_name) \
+  return_type function_name (int global_sid) const { \
+    int pid, sid; \
+    if (0 != DecodeGlobalId(global_sid, pid, sid)) { return NULL; } \
+    return (function_name)(pid, sid); \
+  }
 
-const char* XML4NLP::GetWord(int globalSentIdx, int wordIdx) const {
-    pair<int, int> paraIdx_sentIdx;
-    if (0 != MapGlobalSentIdx2paraIdx_sentIdx(globalSentIdx, paraIdx_sentIdx)) return NULL;
-    return GetWord(paraIdx_sentIdx.first, paraIdx_sentIdx.second, wordIdx);
+const char* XML4NLP::GetSentence(int pid, int sid) const {
+  if (0 != CheckRange(pid, sid)) return NULL;
+  return document.paragraphs[pid].sentences[sid].sentencePtr->Attribute(TAG_CONT);
 }
 
-const char* XML4NLP::GetWord(int globalWordIdx) const {
-    int paraIdx, sentIdx, wordIdx;
-    if (0 != MapGlobalWordIdx2paraIdx_sentIdx_wordIdx(globalWordIdx, paraIdx, sentIdx, wordIdx)) return NULL;
-    return GetWord(paraIdx, sentIdx, wordIdx);
-}
+EXTEND_FUNCTION(const char *, XML4NLP::GetSentence)
 
-const char *XML4NLP::GetPOS(int paragraphIdx, int sentenceIdx, int wordIdx) const {
-    if (0 != CheckRange(paragraphIdx, sentenceIdx, wordIdx)) return NULL;
-    return m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words[wordIdx].wordPtr->Attribute(TAG_POS);
+#define EXTEND_FUNCTION2(return_type, function_name, tag_name, failed_return) \
+return_type function_name (int pid, int sid, int wid) const { \
+  if (0 != CheckRange(pid, sid, wid)) { return failed_return; } \
+  return document.paragraphs[pid].sentences[sid].words[wid].wordPtr->Attribute(tag_name); \
+} \
+\
+return_type function_name (int global_sid, int wid) const { \
+  int pid, sid; \
+  if (0 != DecodeGlobalId(global_sid, pid, sid)) { return failed_return; } \
+  return function_name (pid, sid, wid); \
+} \
+\
+return_type function_name (int global_wid) const { \
+  int pid, sid, wid; \
+  if (0 != DecodeGlobalId(global_wid, pid, sid, wid)) { return failed_return; } \
+  return function_name (pid, sid, wid); \
 }
 
-const char *XML4NLP::GetPOS(int globalSentIdx, int wordIdx) const {
-    pair<int, int> paraIdx_sentIdx;
-    if (0 != MapGlobalSentIdx2paraIdx_sentIdx(globalSentIdx, paraIdx_sentIdx)) return NULL;
-    return GetPOS(paraIdx_sentIdx.first, paraIdx_sentIdx.second, wordIdx);
-}
-
-const char *XML4NLP::GetPOS(int globalWordIdx) const {
-    int paraIdx, sentIdx, wordIdx;
-    if (0 != MapGlobalWordIdx2paraIdx_sentIdx_wordIdx(globalWordIdx, paraIdx, sentIdx, wordIdx)) return NULL;
-    return GetPOS(paraIdx, sentIdx, wordIdx);
-}
-
-const char *XML4NLP::GetNE(int paragraphIdx, int sentenceIdx, int wordIdx) const {
-    if ( 0 != CheckRange(paragraphIdx, sentenceIdx, wordIdx) ) return NULL;
-    return m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words[wordIdx].wordPtr->Attribute(TAG_NE);
-}
-
-const char *XML4NLP::GetNE(int globalSentIdx, int wordIdx) const {
-    pair<int, int> paraIdx_sentIdx;
-    if (0 != MapGlobalSentIdx2paraIdx_sentIdx(globalSentIdx, paraIdx_sentIdx)) return NULL;
-    return GetNE(paraIdx_sentIdx.first, paraIdx_sentIdx.second, wordIdx);
-}
-
-const char *XML4NLP::GetNE(int globalWordIdx) const {
-    int paraIdx, sentIdx, wordIdx;
-    if (0 != MapGlobalWordIdx2paraIdx_sentIdx_wordIdx(globalWordIdx, paraIdx, sentIdx, wordIdx)) return NULL;
-    return GetNE(paraIdx, sentIdx, wordIdx);
-}
-
-
-int XML4NLP::GetWSD(pair<const char *, const char *> &WSD_explanation, 
-        int paragraphIdx, 
-        int sentenceIdx, 
-        int wordIdx) const {
-   if (0 != CheckRange(paragraphIdx, sentenceIdx, wordIdx)) return -1;
+EXTEND_FUNCTION2 (const char *, XML4NLP::GetWord, TAG_CONT, NULL)
+EXTEND_FUNCTION2 (const char *, XML4NLP::GetPOS,  TAG_POS,  NULL)
+EXTEND_FUNCTION2 (const char *, XML4NLP::GetNE,   TAG_NE,   NULL)
 
-   WSD_explanation.first  = m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words[wordIdx].wordPtr->Attribute(TAG_WSD);
-   WSD_explanation.second = m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words[wordIdx].wordPtr->Attribute(TAG_WSD_EXP);
+int XML4NLP::GetWSD(WSDResult & explanation, int pid, int sid, int wid) const {
+   if (0 != CheckRange(pid, sid, wid)) return -1;
+   explanation.first  = document.paragraphs[pid].sentences[sid].words[wid].wordPtr->Attribute(TAG_WSD);
+   explanation.second = document.paragraphs[pid].sentences[sid].words[wid].wordPtr->Attribute(TAG_WSD_EXP);
    return 0;
 }
 
-int XML4NLP::GetWSD(pair<const char *, const char *> & WSD_explanation, 
-        int globalSentIdx, 
-        int wordIdx) const {
-   pair<int, int> paraIdx_sentIdx;
-   if (0 != MapGlobalSentIdx2paraIdx_sentIdx(globalSentIdx, paraIdx_sentIdx)) return -1;
-   return GetWSD(WSD_explanation, paraIdx_sentIdx.first, paraIdx_sentIdx.second);
-}
-
-int XML4NLP::GetWSD(pair<const char *, const char *> & WSD_explanation, 
-        int globalWordIdx) const {
-    int paraIdx, sentIdx, wordIdx;
-    if (0 != MapGlobalWordIdx2paraIdx_sentIdx_wordIdx(globalWordIdx, paraIdx, sentIdx, wordIdx)) return -1;
-    return GetWSD(WSD_explanation, paraIdx, sentIdx, wordIdx);
-}
-
-int XML4NLP::GetParse(pair<int, const char *> & parent_relation, 
-        int paragraphIdx, 
-        int sentenceIdx, 
-        int wordIdx) const {
-    if (0 != CheckRange(paragraphIdx, sentenceIdx, wordIdx)) return -1;
-    const char *cszParent = m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words[wordIdx].wordPtr->Attribute(TAG_PSR_PARENT);
-    parent_relation.first   = (cszParent == NULL ? 0 : atoi(cszParent));
-    parent_relation.second  = m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words[wordIdx].wordPtr->Attribute(TAG_PSR_RELATE);
-    return 0;
-}
-
-int XML4NLP::GetParse(pair<int, const char *> & parent_relation, 
-        int globalSentIdx, 
-        int wordIdx) const {
-    pair<int, int> paraIdx_sentIdx;
-    if (0 != MapGlobalSentIdx2paraIdx_sentIdx(globalSentIdx, paraIdx_sentIdx)) return -1;
-    return GetParse(parent_relation, paraIdx_sentIdx.first, paraIdx_sentIdx.second);
-}
-
-int XML4NLP::GetParse(pair<int, const char *> &parent_relation, 
-        int globalWordIdx) const {
-    int paraIdx, sentIdx, wordIdx;
-    if (0 != MapGlobalWordIdx2paraIdx_sentIdx_wordIdx(globalWordIdx, paraIdx, sentIdx, wordIdx)) return -1;
-    return GetParse(parent_relation, paraIdx, sentIdx, wordIdx);
-}
-
-int XML4NLP::MapGlobalSentIdx2paraIdx_sentIdx(int sentenceIdx, 
-        pair<int, int> & paraIdx_sentIdx) const {
-    int startStnsIdxOfPara = 0;
-    for (int paraIdx=0; paraIdx < m_document.paragraphs.size(); ++paraIdx) {
-        if (startStnsIdxOfPara + m_document.paragraphs[paraIdx].sentences.size() > sentenceIdx) {
-            paraIdx_sentIdx.first = paraIdx;
-            paraIdx_sentIdx.second = sentenceIdx - startStnsIdxOfPara;
-            return 0;
-        }
-        startStnsIdxOfPara += m_document.paragraphs[paraIdx].sentences.size();
+int XML4NLP::GetParse(ParseResult & relation, int pid, int sid, int wid) const {
+  if (0 != CheckRange(pid, sid, wid)) return -1;
+  const char * head = document.paragraphs[pid].sentences[sid].words[wid].wordPtr->Attribute(TAG_PSR_PARENT);
+  relation.first  = (head == NULL ? 0 : atoi(head));
+  relation.second = document.paragraphs[pid].sentences[sid].words[wid].wordPtr->Attribute(TAG_PSR_RELATE);
+  return 0;
+}
+
+#define EXTEND_FUNCTION3(return_type, function_name, output_type, failed_return) \
+  return_type function_name (output_type & output, int global_sid, int wid) const { \
+    int pid, sid; \
+    if (0 != DecodeGlobalId(global_sid, pid, sid)) { return failed_return; } \
+    return function_name(output, pid, sid, wid); \
+  }\
+\
+  return_type function_name (output_type & output, int global_wid) const { \
+    int pid, wid, sid; \
+    if (0 != DecodeGlobalId(global_wid, pid, sid, wid)) { return failed_return; } \
+    return function_name(output, pid, sid, wid); \
+  }
+
+EXTEND_FUNCTION3 (int, XML4NLP::GetWSD,   WSDResult,    -1)
+EXTEND_FUNCTION3 (int, XML4NLP::GetParse, ParseResult,  -1)
+
+int XML4NLP::DecodeGlobalId(int global_sid, int & pid, int & sid) const {
+  int startStnsIdxOfPara = 0;
+  for (pid = 0; pid < document.paragraphs.size(); ++ pid) {
+    int len = document.paragraphs[pid].sentences.size();
+    if (startStnsIdxOfPara + len > global_sid) {
+      sid = global_sid - startStnsIdxOfPara;
+      return 0;
+    }
+    startStnsIdxOfPara += len;
+  }
+  return -1;
+}
+
+int XML4NLP::DecodeGlobalId(int global_wid, int & pid, int & sid, int & wid) const {
+  int startWordIdxOfStns = 0;
+  for (pid = 0; pid < document.paragraphs.size(); ++ pid) {
+    const vector<Sentence> &sentences = document.paragraphs[pid].sentences;
+    for (sid = 0; sid < sentences.size(); ++ sid) {
+      if (startWordIdxOfStns + sentences[sid].words.size() > global_wid) {
+        wid = global_wid - startWordIdxOfStns;
+        return 0;
+      }
+      startWordIdxOfStns += sentences[sid].words.size();
     }
-    return -1;
+  }
+  return -1;
 }
 
-int XML4NLP::MapGlobalWordIdx2paraIdx_sentIdx_wordIdx(int globalWordIdx, 
-        int & paraIdx, 
-        int & sentIdx, 
-        int & wordIdx) const {
-    int startWordIdxOfStns = 0;
-    for (paraIdx=0; paraIdx < m_document.paragraphs.size(); ++paraIdx) {
-        const vector<Sentence_t> &sentences = m_document.paragraphs[paraIdx].sentences;
-        for (sentIdx=0; sentIdx < sentences.size(); ++sentIdx) {
-            if (startWordIdxOfStns + sentences[sentIdx].words.size() > globalWordIdx) {
-                wordIdx = globalWordIdx - startWordIdxOfStns;
-                return 0;
-            }
-            startWordIdxOfStns += sentences[sentIdx].words.size();
-        }
-    }
+int XML4NLP::GetSentencesFromParagraph(vector<const char *> &vecSentence,
+    int paragraphIdx) const {
+  if (0 != CheckRange(paragraphIdx)) return -1;
+  if (document.paragraphs[paragraphIdx].sentences.empty()) {
     return -1;
-}
-
-int XML4NLP::GetSentencesFromParagraph(vector<const char *> &vecSentence, 
-        int paragraphIdx) const {
-    if (0 != CheckRange(paragraphIdx)) return -1;
-    if (m_document.paragraphs[paragraphIdx].sentences.empty()) {
-        return -1;
-    }
+  }
 
-    const vector<Sentence_t> & sentences = m_document.paragraphs[paragraphIdx].sentences;
-    if (vecSentence.size() != sentences.size()) {
-        return -1;
-    }
+  const vector<Sentence> & sentences = document.paragraphs[paragraphIdx].sentences;
+  if (vecSentence.size() != sentences.size()) {
+    return -1;
+  }
 
-    for (int i=0; i < sentences.size(); ++i) {
-        vecSentence[i] = sentences[i].sentencePtr->Attribute(TAG_CONT);
-    }
+  for (int i=0; i < sentences.size(); ++i) {
+    vecSentence[i] = sentences[i].sentencePtr->Attribute(TAG_CONT);
+  }
 
-    return 0;
+  return 0;
 }
 
-int XML4NLP::GetSentencesFromParagraph(vector<string> &vecSentence, 
-        int paragraphIdx) const {
-    if (0 != CheckRange(paragraphIdx)) return -1;
+int XML4NLP::GetSentencesFromParagraph(vector<string> &vecSentence,
+    int paragraphIdx) const {
+  if (0 != CheckRange(paragraphIdx)) return -1;
 
-    if (m_document.paragraphs[paragraphIdx].sentences.empty()) {
-        return -1;
-    }
+  if (document.paragraphs[paragraphIdx].sentences.empty()) {
+    return -1;
+  }
 
-    vecSentence.clear();
-    const vector<Sentence_t> &sentences = m_document.paragraphs[paragraphIdx].sentences;
-    for (int i = 0; i < sentences.size(); ++ i) {
-        vecSentence.push_back( sentences[i].sentencePtr->Attribute(TAG_CONT) );
-    }
-    return 0;
+  vecSentence.clear();
+  const vector<Sentence> &sentences = document.paragraphs[paragraphIdx].sentences;
+  for (int i = 0; i < sentences.size(); ++ i) {
+    vecSentence.push_back( sentences[i].sentencePtr->Attribute(TAG_CONT) );
+  }
+  return 0;
 }
 
 int XML4NLP::SetSentencesToParagraph(const vector<string> &vecSentence, int paragraphIdx) {
-    if (0 != CheckRange(paragraphIdx)) {
-        return -1;
-    }
+  if (0 != CheckRange(paragraphIdx)) {
+    return -1;
+  }
 
-    if (!m_document.paragraphs[paragraphIdx].sentences.empty()) {
-        return -1;
-    }
+  if (!document.paragraphs[paragraphIdx].sentences.empty()) {
+    return -1;
+  }
 
-    Paragraph_t & paragraph         = m_document.paragraphs[paragraphIdx];
-    TiXmlElement * paragraphPtr     = paragraph.paragraphPtr;
-    vector<Sentence_t> &sentences   = paragraph.sentences;
+  Paragraph & paragraph     = document.paragraphs[paragraphIdx];
+  TiXmlElement * paragraphPtr   = paragraph.paragraphPtr;
+  vector<Sentence> &sentences   = paragraph.sentences;
 
-    TiXmlText *textPtr = paragraphPtr->FirstChild()->ToText();
-    if (textPtr == NULL) {
-        return -1;
-    } else {
-        paragraphPtr->RemoveChild(textPtr);
-    }
+  TiXmlText *textPtr = paragraphPtr->FirstChild()->ToText();
+  if (textPtr == NULL) {
+    return -1;
+  } else {
+    paragraphPtr->RemoveChild(textPtr);
+  }
+
+  for (int i = 0; i < vecSentence.size(); ++i) {
+    TiXmlElement *sentencePtr = new TiXmlElement(TAG_SENT);
+    sentencePtr->SetAttribute(TAG_ID, static_cast<int>(i));
+    sentencePtr->SetAttribute(TAG_CONT, vecSentence[i].c_str());
+    paragraphPtr->LinkEndChild(sentencePtr);
+
+    sentences.push_back( Sentence() );
+    sentences[sentences.size()-1].sentencePtr = sentencePtr;
+  }
+
+  return 0;
+}
+
+#define EXTEND_FUNCTION4(return_type, function_name, tag_name) \
+  return_type function_name (std::vector<const char *> & output, int pid, int sid) const { \
+    return GetInfoFromSentence(output, pid, sid, tag_name); \
+  } \
+\
+  return_type function_name (std::vector<std::string> & output, int pid, int sid) const { \
+    return GetInfoFromSentence(output, pid, sid, tag_name); \
+  } \
+\
+  return_type function_name (std::vector<const char *> & output, int global_sid) const { \
+    return GetInfoFromSentence(output, global_sid, tag_name); \
+  } \
+\
+  return_type function_name (std::vector<std::string> & output, int global_sid) const { \
+    return GetInfoFromSentence(output, global_sid, tag_name); \
+  }
+
+EXTEND_FUNCTION4 (int, XML4NLP::GetWordsFromSentence, TAG_CONT);
+EXTEND_FUNCTION4 (int, XML4NLP::GetPOSsFromSentence,  TAG_POS);
+EXTEND_FUNCTION4 (int, XML4NLP::GetNEsFromSentence,   TAG_NE);
+
+int XML4NLP::SetWordsToSentence(const std::vector<std::string> & input,
+                                int pid,
+                                int sid) {
+  if (0 != CheckRange(pid, sid)) return -1;
+
+  Sentence &sentence = document.paragraphs[pid].sentences[sid];
+  if (!sentence.words.empty()) {
+    return -1;
+  }
 
-    for (int i = 0; i < vecSentence.size(); ++i) {
-        TiXmlElement *sentencePtr = new TiXmlElement(TAG_SENT);
-        sentencePtr->SetAttribute(TAG_ID, static_cast<int>(i));
-        sentencePtr->SetAttribute(TAG_CONT, vecSentence[i].c_str());
-        paragraphPtr->LinkEndChild(sentencePtr);
+  for (int i = 0; i < input.size(); ++ i) {
+    TiXmlElement *wordPtr = new TiXmlElement(TAG_WORD);
+    wordPtr->SetAttribute(TAG_ID, i);
+    wordPtr->SetAttribute(TAG_CONT, input[i].c_str());
+    sentence.sentencePtr->LinkEndChild(wordPtr);
 
-        sentences.push_back( Sentence_t() );
-        sentences[sentences.size()-1].sentencePtr = sentencePtr;
-    }
-
-    return 0;
+    sentence.words.push_back( Word() );
+    sentence.words[sentence.words.size() - 1].wordPtr = wordPtr;
+  }
+  return 0;
 }
 
-int XML4NLP::GetWordsFromSentence(vector<const char *> & vecWord,
-        int paragraphIdx,
-        int sentenceIdx) const {
-    return GetInfoFromSentence(vecWord, paragraphIdx, sentenceIdx, TAG_CONT);
+int XML4NLP::SetWordsToSentence(const std::vector<std::string> & input,
+                                int global_sid) {
+  int pid, sid;
+  if (0 != DecodeGlobalId(global_sid, pid, sid)) { return -1; }
+  SetWordsToSentence(input, pid, sid);
+  return 0;
 }
 
-int XML4NLP::GetWordsFromSentence(std::vector<std::string> & vecWord,
-        int paragraphIdx,
-        int sentenceIdx) const {
-    return GetInfoFromSentence(vecWord, paragraphIdx, sentenceIdx, TAG_CONT);
+int XML4NLP::SetPOSsToSentence(const std::vector<std::string> & input,
+                               int pid, int sid) {
+  return SetInfoToSentence(input, pid, sid, TAG_POS);
 }
 
-int XML4NLP::GetWordsFromSentence(std::vector<const char *> & vecWord,
-        int globalSentIdx) const {
-    return GetInfoFromSentence(vecWord, globalSentIdx, TAG_CONT);
+int XML4NLP::SetPOSsToSentence(const std::vector<std::string> & input,
+                               int global_sid) {
+  return SetInfoToSentence(input, global_sid, TAG_POS);
 }
 
-int XML4NLP::GetWordsFromSentence(std::vector<std::string> & vecWord,
-        int globalSentIdx) const {
-    return GetInfoFromSentence(vecWord, globalSentIdx, TAG_CONT);
+int XML4NLP::SetNEsToSentence(const std::vector<std::string> & input,
+                              int pid, int sid) {
+  return SetInfoToSentence(input, pid, sid, TAG_NE);
 }
 
-int XML4NLP::SetWordsToSentence(const vector<string> & vecWord, 
-        int paragraphIdx, 
-        int sentenceIdx) {
-    if (0 != CheckRange(paragraphIdx, sentenceIdx)) return -1;
-
-    Sentence_t &sentence = m_document.paragraphs[paragraphIdx].sentences[sentenceIdx];
-    if (!sentence.words.empty()) {
-        return -1;
-    }
-
-    for (int i = 0; i < vecWord.size(); ++ i) {
-        TiXmlElement *wordPtr = new TiXmlElement(TAG_WORD);
-        wordPtr->SetAttribute(TAG_ID, i);
-        wordPtr->SetAttribute(TAG_CONT, vecWord[i].c_str());
-        sentence.sentencePtr->LinkEndChild(wordPtr);
-
-        sentence.words.push_back( Word_t() );
-        sentence.words[sentence.words.size() - 1].wordPtr = wordPtr;
-    }
-    return 0;
+int XML4NLP::SetNEsToSentence(const std::vector<std::string> & input,
+                              int global_sid) {
+  return SetInfoToSentence(input, global_sid, TAG_NE);
 }
 
-int XML4NLP::SetWordsToSentence(const vector<string> & vecWord,
-        int sentenceIdx) {
-    pair<int, int> paraIdx_sentIdx;
-    if (0 != MapGlobalSentIdx2paraIdx_sentIdx(sentenceIdx, paraIdx_sentIdx)) {
-        return -1;
-    }
-    SetWordsToSentence(vecWord, paraIdx_sentIdx.first, paraIdx_sentIdx.second);
-    return 0;
-}
+int XML4NLP::GetParsesFromSentence(std::vector< ParseResult > &relation,
+                                   int pid, int sid) const {
+  std::vector<const char *> heads;
+  std::vector<const char *> deprels;
 
-int XML4NLP::GetPOSsFromSentence(std::vector<const char *> & vecPOS,
-        int paragraphIdx,
-        int sentenceIdx) const {
-    return GetInfoFromSentence(vecPOS, paragraphIdx, sentenceIdx, TAG_POS);
-}
+  int nr_words = CountWordInSentence(pid, sid);
+  relation.resize(nr_words);
 
-int XML4NLP::GetPOSsFromSentence(std::vector<const char *> &vecPOS, 
-        int globalSentIdx) const {
-    return GetInfoFromSentence(vecPOS, globalSentIdx, TAG_POS);
-}
+  if (0 != GetInfoFromSentence(heads, pid, sid, TAG_PSR_PARENT)) {
+    return -1;
+  }
 
-int XML4NLP::GetPOSsFromSentence(std::vector<std::string> &vecPOS, 
-        int paragraphIdx, 
-        int sentenceIdx) const {
-    return GetInfoFromSentence(vecPOS, paragraphIdx, sentenceIdx, TAG_POS);
-}
+  if (0 != GetInfoFromSentence(deprels, pid, sid, TAG_PSR_RELATE)) {
+    return -1;
+  }
 
-int XML4NLP::GetPOSsFromSentence(std::vector<std::string> &vecPOS, 
-        int globalSentIdx) const {
-    return GetInfoFromSentence(vecPOS, globalSentIdx, TAG_POS);
-}
+  for (int i = 0; i < nr_words; ++ i) {
+    relation[i].first = atoi( heads[i] );
+    relation[i].second = deprels[i];
+  }
 
-int XML4NLP::SetPOSsToSentence(const std::vector<std::string> &vecPOS,
-        int paragraphIdx,
-        int sentenceIdx) {
-    return SetInfoToSentence(vecPOS, paragraphIdx, sentenceIdx, TAG_POS);
+  return 0;
 }
 
-int XML4NLP::SetPOSsToSentence(const std::vector<std::string> & vecPOS,
-        int sentenceIdx) {
-    return SetInfoToSentence(vecPOS, sentenceIdx, TAG_POS);
-}
+int XML4NLP::GetParsesFromSentence(std::vector< ParseResult > & relation,
+                                   int global_sid) const {
+  std::vector<const char *> heads;
+  std::vector<const char *> deprels;
 
-int XML4NLP::GetNEsFromSentence(std::vector<const char *> & vecNE,
-        int paragraphIdx,
-        int sentenceIdx) const {
-    return GetInfoFromSentence(vecNE, paragraphIdx, sentenceIdx, TAG_NE);
-}
+  int nr_words = CountWordInSentence(global_sid);
+  relation.resize(nr_words);
 
-int XML4NLP::GetNEsFromSentence(std::vector<const char *> & vecNE, 
-        int globalSentIdx) const {
-    return GetInfoFromSentence(vecNE, globalSentIdx, TAG_NE);
-}
+  heads.resize(nr_words);
+  deprels.resize(nr_words);
 
-int XML4NLP::GetNEsFromSentence(std::vector<std::string> &vecNE, 
-        int paragraphIdx, 
-        int sentenceIdx) const {
-    return GetInfoFromSentence(vecNE, paragraphIdx, sentenceIdx, TAG_NE);
-}
+  if (0 != GetInfoFromSentence(heads, global_sid, TAG_PSR_PARENT)) {
+    return -1;
+  }
 
-int XML4NLP::GetNEsFromSentence(std::vector<std::string> & vecNE, 
-        int globalSentIdx) const {
-    return GetInfoFromSentence(vecNE, globalSentIdx, TAG_NE);
-}
+  if (0 != GetInfoFromSentence(deprels, global_sid, TAG_PSR_RELATE)) {
+    return -1;
+  }
 
-int XML4NLP::SetNEsToSentence(const std::vector<std::string> & vecNE, 
-        int paragraphIdx, 
-        int sentenceIdx) {
-    return SetInfoToSentence(vecNE, paragraphIdx, sentenceIdx, TAG_NE);
-}
+  for (int i = 0; i < nr_words; ++ i) {
+    relation[i].first = atoi( heads[i] );
+    relation[i].second = deprels[i];
+  }
 
-int XML4NLP::SetNEsToSentence(const std::vector<std::string> & vecNE,
-        int sentenceIdx) {
-    return SetInfoToSentence(vecNE, sentenceIdx, TAG_NE);
+  return 0;
 }
 
-int XML4NLP::GetParsesFromSentence(vector< pair<int, const char *> > &vecParse, 
-        int paragraphIdx, 
-        int sentenceIdx) const {
-    vector<const char *> vecParent;
-    vector<const char *> vecRelate;
-    int wordNum = CountWordInSentence(paragraphIdx, sentenceIdx);
-    if (wordNum != vecParse.size()) {
-        cerr << "vecParse.size() does not equal to the word num in the sentence, should resize first" << endl;
-        return -1;
-    }
-
-    // vecParent.resize(wordNum);
-    // vecRelate.resize(wordNum);
-    if (0 != GetInfoFromSentence(vecParent, paragraphIdx, sentenceIdx, TAG_PSR_PARENT)) {
-        return -1;
-    }
-
-    if (0 != GetInfoFromSentence(vecRelate, paragraphIdx, sentenceIdx, TAG_PSR_RELATE)) {
-        return -1;
-    }
 
-    for (int i=0; i < vecParent.size(); ++ i) {
-        vecParse[i].first = atoi( vecParent[i] );
-        vecParse[i].second = vecRelate[i];
-    }
+int XML4NLP::GetParsesFromSentence(std::vector< std::pair<int, std::string > > & relation,
+                                   int pid,
+                                   int sid) const {
+  std::vector< ParseResult > parse;
+  if (0 != GetParsesFromSentence(parse, pid, sid)) {
+    return -1;
+  }
 
-    return 0;
+  relation.resize( parse.size() );
+  for (int i = 0; i < parse.size(); ++ i) {
+    relation[i].first = parse[i].first;
+    relation[i].second = parse[i].second;
+  }
+  return 0;
 }
 
-int XML4NLP::GetParsesFromSentence(vector< pair<int, const char *> > & vecParse, 
-        int sentenceIdx) const {
-    vector<const char *> vecParent;
-    vector<const char *> vecRelate;
-    int wordNum = CountWordInSentence(sentenceIdx);
-    if (wordNum != vecParse.size()) {
-        cerr << "vecParse.size() does not equal to the word num in the sentence, should resize first" << endl;
-        return -1;
-    }
-
-    vecParent.resize(wordNum);
-    vecRelate.resize(wordNum);
-    if (0 != GetInfoFromSentence(vecParent, sentenceIdx, TAG_PSR_PARENT)) {
-        return -1;
-    }
-
-    if (0 != GetInfoFromSentence(vecRelate, sentenceIdx, TAG_PSR_RELATE)) {
-        return -1;
-    }
+int XML4NLP::GetParsesFromSentence(std::vector< std::pair<int, std::string> > & relation,
+                                   int global_sid) const {
+  std::vector< ParseResult > parse;
+  if (0 != GetParsesFromSentence(parse, global_sid)) {
+    return -1;
+  }
 
-    for (int i=0; i < vecParent.size(); ++i) {
-        vecParse[i].first = atoi( vecParent[i] );
-        vecParse[i].second = vecRelate[i];
-    }
+  relation.resize( parse.size() );
+  for (int i = 0; i < parse.size(); ++ i) {
+    relation[i].first  = parse[i].first;
+    relation[i].second = parse[i].second;
+  }
 
-    return 0;
+  return 0;
 }
 
+int XML4NLP::SetParsesToSentence(const std::vector< std::pair<int, std::string> > & relation,
+                                 int pid, int sid) {
+  if (0 != CheckRange(pid, sid)) return -1;
 
-int XML4NLP::GetParsesFromSentence(vector< pair<int, string> > &vecParse, 
-        int paragraphIdx, 
-        int sentenceIdx) const {
-    vector<string> vecParent;
-    vector<string> vecRelate;
-    if (0 != GetInfoFromSentence(vecParent, paragraphIdx, sentenceIdx, TAG_PSR_PARENT)) {
-        return -1;
-    }
-    if (0 != GetInfoFromSentence(vecRelate, paragraphIdx, sentenceIdx, TAG_PSR_RELATE)) {
-        return -1;
-    }
-
-    vecParse.clear();
-    // Assume their sizes of the two vector are equal. Is it OK?
-    for (int i=0; i < vecParent.size(); ++i) {
-        int parentIdx = atoi( vecParent[i].c_str() );
-        vecParse.push_back( make_pair(static_cast<int>(parentIdx), vecRelate[i]) );
-    }
+  std::vector<Word> & words = document.paragraphs[pid].sentences[sid].words;
 
-    return 0;
-}
+  if (words.size() != relation.size()) {
+    std::cerr << "word number does not equal to vecInfo's size in paragraph"
+              << pid
+              << " sentence "
+              << sid << std::endl;
+    return -1;
+  }
+
+  if (words[0].wordPtr->Attribute(TAG_PSR_PARENT) != NULL) {
+    std::cerr << "Attribute \""
+              << TAG_PSR_PARENT
+              << "\" already exists in paragraph"
+              << pid
+              << " sentence "
+              << sid << std::endl;
+    return -1;
+  }
+
+  if (words[0].wordPtr->Attribute(TAG_PSR_RELATE) != NULL) {
+    std::cerr << "Attribute \""
+              << TAG_PSR_RELATE
+              << "\" already exists in paragraph"
+              << pid
+              << " sentence "
+              << sid << endl;
+    return -1;
+  }
 
-int XML4NLP::GetParsesFromSentence(vector< pair<int, string> > &vecParse, 
-        int sentenceIdx) const {
-    vector<string> vecParent;
-    vector<string> vecRelate;
-    if (0 != GetInfoFromSentence(vecParent, sentenceIdx, TAG_PSR_PARENT)) {
-        return -1;
-    }
-    if (0 != GetInfoFromSentence(vecRelate, sentenceIdx, TAG_PSR_RELATE)) {
-        return -1;
-    }
+  for (int i = 0; i < words.size(); ++ i) {
+    words[i].wordPtr->SetAttribute(TAG_PSR_PARENT, relation[i].first);
+    words[i].wordPtr->SetAttribute(TAG_PSR_RELATE, relation[i].second.c_str());
+  }
 
-    vecParse.clear();
-    // Assume their sizes of the two vector are equal. Is it OK?
-    for (int i=0; i < vecParent.size(); ++i) {
-        int parentIdx = atoi( vecParent[i].c_str() );
-        vecParse.push_back( make_pair(static_cast<int>(parentIdx), vecRelate[i]) );
-    }
-
-    return 0;
+  return 0;
 }
 
-int XML4NLP::SetParsesToSentence(const vector< pair<int, string> > &vecParse, 
-        int paragraphIdx, 
-        int sentenceIdx) {
-    if (0 != CheckRange(paragraphIdx, sentenceIdx)) return -1;
-    vector<Word_t> &words = m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words;
-    if (words.size() != vecParse.size()) {
-        cerr << "word number does not equal to vecInfo's size in paragraph" << paragraphIdx
-            << " sentence " << sentenceIdx << endl;
-        return -1;
-    }
-
-    if (words[0].wordPtr->Attribute(TAG_PSR_PARENT) != NULL) {
-        cerr << "Attribute \"" << TAG_PSR_PARENT << "\" already exists in paragraph" << paragraphIdx
-            << " sentence " << sentenceIdx << endl;
-        return -1;
-    }
-
-    if (words[0].wordPtr->Attribute(TAG_PSR_RELATE) != NULL) {
-        cerr << "Attribute \"" << TAG_PSR_RELATE << "\" already exists in paragraph" << paragraphIdx
-            << " sentence " << sentenceIdx << endl;
-        return -1;
-    }
-
-    for (int i = 0; i < words.size(); ++i) {
-        words[i].wordPtr->SetAttribute(TAG_PSR_PARENT, vecParse[i].first);
-        words[i].wordPtr->SetAttribute(TAG_PSR_RELATE, vecParse[i].second.c_str());
-    }
-
-    return 0;
+int XML4NLP::SetParsesToSentence(const std::vector< std::pair<int, std::string> > & relation,
+                                 int global_sid) {
+  int pid, sid;
+  if (0 != DecodeGlobalId(global_sid, pid, sid)) return -1;
+  return SetParsesToSentence(relation, pid, sid);
 }
 
-int XML4NLP::SetParsesToSentence(const vector< pair<int, string> > &vecParse, int sentenceIdx) {
-    pair<int, int> paraIdx_sentIdx;
-    if (0 != MapGlobalSentIdx2paraIdx_sentIdx(sentenceIdx, paraIdx_sentIdx)) return -1;
-
-    vector<Word_t> &words = m_document.paragraphs[paraIdx_sentIdx.first].sentences[paraIdx_sentIdx.second].words;
-    if (words.size() != vecParse.size()) {
-        cerr << "word number does not equal to vecInfo's size in paragraph" << paraIdx_sentIdx.first
-            << " sentence " << paraIdx_sentIdx.second << endl;
-        return -1;
-    }
-    if (words[0].wordPtr->Attribute(TAG_PSR_PARENT) != NULL)
-    {
-        cerr << "Attribute \"" << TAG_PSR_PARENT << "\" already exists in paragraph" << paraIdx_sentIdx.first
-            << " sentence " << paraIdx_sentIdx.second << endl;
-        return -1;
-    }
-    if (words[0].wordPtr->Attribute(TAG_PSR_RELATE) != NULL)
-    {
-        cerr << "Attribute \"" << TAG_PSR_RELATE << "\" already exists in paragraph" << paraIdx_sentIdx.first
-            << " sentence " << paraIdx_sentIdx.second << endl;
-        return -1;
-    }
-
-    for (int i = 0; i < words.size(); ++i)
-    {
-        words[i].wordPtr->SetAttribute(TAG_PSR_PARENT, vecParse[i].first);
-        words[i].wordPtr->SetAttribute(TAG_PSR_RELATE, vecParse[i].second.c_str());
-    }
-    return 0;
+int XML4NLP::SetParsesToSentence(const std::vector<int> & heads,
+                                 const std::vector<std::string> & deprels,
+                                 int pid,
+                                 int sid) {
+  if (0 != SetInfoToSentence(heads,   pid, sid, TAG_PSR_PARENT)) return -1;
+  if (0 != SetInfoToSentence(deprels, pid, sid, TAG_PSR_RELATE)) return -1;
+  return 0;
 }
 
-int XML4NLP::SetParsesToSentence(const vector<int> &vecHead, const vector<string> &vecRel, int paragraphIdx, int sentenceIdx)
-{
-    if (0 != SetInfoToSentence(vecHead, paragraphIdx, sentenceIdx, TAG_PSR_PARENT)) return -1;
-    if (0 != SetInfoToSentence(vecRel, paragraphIdx, sentenceIdx, TAG_PSR_RELATE)) return -1;
-    return 0;
-}
+int XML4NLP::SetParsesToSentence(const std::vector<int> & heads,
+                                 const std::vector<std::string> & deprels,
+                                 int global_sid) {
+  // decreasing vecHead index
+  std::vector<int> d_heads;
+  for (int i = 0; i < heads.size(); ++ i) {
+    d_heads.push_back( heads[i] - 1 );
+    // std::cout << d_heads[i] << " " << deprels[i] << std::endl;
+  }
 
-int XML4NLP::SetParsesToSentence(const vector<int> &vecHead, const vector<string> &vecRel, int sentenceIdx)
-{
-    // decreasing vecHead index
-    vector<int> d_vecHead;
-    for (int i = 0; i < vecHead.size(); i++)
-    {
-        d_vecHead.push_back(vecHead[i] - 1);
-    }
+  if (0 != SetInfoToSentence(d_heads, global_sid, TAG_PSR_PARENT)) return -1;
+  if (0 != SetInfoToSentence(deprels, global_sid, TAG_PSR_RELATE)) return -1;
 
-    if (0 != SetInfoToSentence(d_vecHead, sentenceIdx, TAG_PSR_PARENT)) return -1;
-    if (0 != SetInfoToSentence(vecRel, sentenceIdx, TAG_PSR_RELATE)) return -1;
-    return 0;
+  // std::string buffer;
+  // SaveDOM(buffer);
+  // std::cout << buffer << std::endl;
+  return 0;
 }
 
-// ----------------------------------------------------------------for text summarization
-const char* XML4NLP::GetTextSummary() const
-{
-    if (m_summary.nodePtr != NULL)
-    {
-        return m_summary.nodePtr->GetText();
-    }
-    else
-    {
-        cerr << "have not done text summary." << endl;
-        return NULL;
-    }
+const char * XML4NLP::GetTextSummary() const {
+  if (summary.nodePtr != NULL) {
+    return summary.nodePtr->GetText();
+  } else {
+    std::cerr << "have not done text summary." << std::endl;
+    return NULL;
+  }
 }
 
-int XML4NLP::SetTextSummary(const char* cszTextSum)
-{
-    if (m_summary.nodePtr != NULL)
-    {
-        cerr << "has done text summary" << endl;
-        return -1;
-    }
+int XML4NLP::SetTextSummary(const char* cszTextSum) {
+  if (summary.nodePtr != NULL) {
+    std::cerr << "has done text summary" << std::endl;
+    return -1;
+  }
 
-    m_summary.nodePtr = new TiXmlElement(TAG_SUM);
-    m_tiXmlDoc.RootElement()->LinkEndChild(m_summary.nodePtr);
-    TiXmlText *textPtr = new TiXmlText(cszTextSum);
-    m_summary.nodePtr->LinkEndChild(textPtr);
+  summary.nodePtr = new TiXmlElement(TAG_SUM);
+  m_tiXmlDoc.RootElement()->LinkEndChild(summary.nodePtr);
+  TiXmlText * textPtr = new TiXmlText(cszTextSum);
+  summary.nodePtr->LinkEndChild(textPtr);
 
-    return 0;
+  return 0;
 }
 
-// ----------------------------------------------------------------for text classification
-const char* XML4NLP::GetTextClass() const
-{
-    if (m_textclass.nodePtr != NULL)
-    {
-        return m_textclass.nodePtr->GetText();
-    }
-    else
-    {
-        cerr << "have not done text class." << endl;
-        return NULL;
-    }
+const char * XML4NLP::GetTextClass() const {
+  if (textclass.nodePtr != NULL) {
+    return textclass.nodePtr->GetText();
+  } else {
+    cerr << "have not done text class." << endl;
+    return NULL;
+  }
 }
 
-int XML4NLP::SetTextClass(const char* cszTextClass)
-{
-    if (m_textclass.nodePtr != NULL)
-    {
-        cerr << "has done text classify" << endl;
-        return -1;
-    }
+int XML4NLP::SetTextClass(const char* cszTextClass) {
+  if (textclass.nodePtr != NULL) {
+    cerr << "has done text classify" << endl;
+    return -1;
+  }
 
-    m_textclass.nodePtr = new TiXmlElement(TAG_CLASS);
-    m_tiXmlDoc.RootElement()->LinkEndChild(m_textclass.nodePtr);
-    TiXmlText *textPtr = new TiXmlText(cszTextClass);
-    m_textclass.nodePtr->LinkEndChild(textPtr);
-    return 0;
+  textclass.nodePtr = new TiXmlElement(TAG_CLASS);
+  m_tiXmlDoc.RootElement()->LinkEndChild(textclass.nodePtr);
+  TiXmlText *textPtr = new TiXmlText(cszTextClass);
+  textclass.nodePtr->LinkEndChild(textPtr);
+  return 0;
 }
 
 // ----------------------------------------------------------------for SRL
-int XML4NLP::CountPredArgToWord(int paragraphIdx, int sentenceIdx, int wordIdx) const
-{
-    if (0 != CheckRange(paragraphIdx, sentenceIdx, wordIdx)) return -1;
-
-    TiXmlElement *wordPtr = m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words[wordIdx].wordPtr;
-    TiXmlElement *argPtr = wordPtr->FirstChildElement(TAG_SRL_ARG);
-    if (argPtr == NULL)
-    {
-        //cerr << "\"" << TAG_SRL_ARG << "\" does not exists in word " << wordIdx
-        //	<< " of sentence " << sentenceIdx  << " of paragraph " << paragraphIdx << endl;
-        return 0;
-    }
+int XML4NLP::CountPredArgToWord(int pid, int sid, int wid) const {
+  if (0 != CheckRange(pid, sid, wid)) return -1;
 
-    int counter = 0;
-    do
-    {
-        ++counter;
-        argPtr = argPtr->NextSiblingElement(TAG_SRL_ARG);
-    } while (argPtr != NULL);
+  TiXmlElement *wordPtr = document.paragraphs[pid].sentences[sid].words[wid].wordPtr;
+  TiXmlElement *argPtr = wordPtr->FirstChildElement(TAG_SRL_ARG);
 
-    return counter;
-}
+  if (argPtr == NULL) {
+    return 0;
+  }
 
-int XML4NLP::CountPredArgToWord(int globalSentIdx, int wordIdx) const
-{
-    pair<int, int> paraIdx_sentIdx;
-    if (0 != MapGlobalSentIdx2paraIdx_sentIdx(globalSentIdx, paraIdx_sentIdx)) return -1;
-
-    TiXmlElement *wordPtr = m_document.paragraphs[paraIdx_sentIdx.first].sentences[paraIdx_sentIdx.second].words[wordIdx].wordPtr;
-    TiXmlElement *argPtr = wordPtr->FirstChildElement(TAG_SRL_ARG);
-    if (argPtr == NULL)
-    {
-        //cerr << "\"" << TAG_SRL_ARG << "\" does not exists in word " << wordIdx
-        //	<< " of sentence " << sentenceIdx  << " of paragraph " << paragraphIdx << endl;
-        return 0;
-    }
+  int nr_args = 0;
 
-    int counter = 0;
-    do
-    {
-        ++counter;
-        argPtr = argPtr->NextSiblingElement(TAG_SRL_ARG);
-    } while (argPtr != NULL);
+  do {
+    ++ nr_args;
+    argPtr = argPtr->NextSiblingElement(TAG_SRL_ARG);
+  } while (argPtr != NULL);
 
-    return counter;
+  return nr_args;
 }
 
-int XML4NLP::CountPredArgToWord(int globalWordIdx) const
-{
-    int paraIdx, sentIdx, wordIdx;
-    if (0 != MapGlobalWordIdx2paraIdx_sentIdx_wordIdx(globalWordIdx, paraIdx, sentIdx, wordIdx)) return -1;
-
-    TiXmlElement *wordPtr = m_document.paragraphs[paraIdx].sentences[sentIdx].words[wordIdx].wordPtr;
-    TiXmlElement *argPtr = wordPtr->FirstChildElement(TAG_SRL_ARG);
-    if (argPtr == NULL)
-    {
-        //cerr << "\"" << TAG_SRL_ARG << "\" does not exists in word " << wordIdx
-        //	<< " of sentence " << sentenceIdx  << " of paragraph " << paragraphIdx << endl;
-        return 0;
-    }
-
-    int counter = 0;
-    do
-    {
-        ++counter;
-        argPtr = argPtr->NextSiblingElement(TAG_SRL_ARG);
-    } while (argPtr != NULL);
-
-    return counter;
+int XML4NLP::CountPredArgToWord(int global_sid, int wid) const {
+  int pid, sid;
+  if (0 != DecodeGlobalId(global_sid, pid, sid)) return -1;
+  return CountPredArgToWord(pid, sid, wid);
 }
 
-
-int XML4NLP::GetPredArgToWord(	int paragraphIdx, int sentenceIdx, int wordIdx,
-        vector<const char *> &vecType, vector< pair<int, int> > &vecBegEnd) const
-{
-    if (0 != CheckRange(paragraphIdx, sentenceIdx, wordIdx)) return -1;
-
-    TiXmlElement *wordPtr = m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words[wordIdx].wordPtr;
-
-    TiXmlElement *argPtr = wordPtr->FirstChildElement(TAG_SRL_ARG);
-    if (argPtr == NULL)
-    {
-        cerr << "\"" << TAG_SRL_ARG << "\" does not exists in word " << wordIdx
-            << " of sentence " << sentenceIdx  << " of paragraph " << paragraphIdx << endl;
-        return -1;
-    }
-
-    if (vecType.size() != vecBegEnd.size())
-    {
-        cerr << "vecType's size() != vecBegEnd.size(), should resize() first." << endl;
-        return -1;
-    }
-    if (vecType.empty())
-    {
-        cerr << "vecType is empty" << endl;
-        return -1;
-    }
-
-    int i = 0;
-    do
-    {
-        const char *cszType = argPtr->Attribute(TAG_SRL_TYPE);
-        const char *cszBeg = argPtr->Attribute(TAG_BEGIN);
-        const char *cszEnd = argPtr->Attribute(TAG_END);
-        vecType[i] = cszType;
-        int uiBeg = static_cast<int>(cszBeg != NULL ? atoi(cszBeg) : 0);
-        int uiEnd = static_cast<int>(cszEnd != NULL ? atoi(cszEnd) : 0);
-        vecBegEnd[i].first = uiBeg;
-        vecBegEnd[i].second = uiEnd;
-
-        argPtr = argPtr->NextSiblingElement(TAG_SRL_ARG);
-        ++i;
-    } while (argPtr != NULL && i < vecType.size());
-
-    if ( ! (argPtr == NULL && i == vecType.size()) )
-    {
-        if (argPtr == NULL)
-        {
-            cerr << "vecType.size() is too large" << endl;
-        }
-        else
-        {
-            cerr << "vecType.size() is too small" << endl;
-        }
-
-        return -1;
-    }
-
-    return 0;	
+int XML4NLP::CountPredArgToWord(int global_wid) const {
+  int pid, sid, wid;
+  if (0 != DecodeGlobalId(global_wid, pid, sid, wid)) return -1;
+  return CountPredArgToWord(pid, sid, wid);
 }
 
-int XML4NLP::GetPredArgToWord(	int sentenceIdx, int wordIdx,
-        vector<const char *> &vecType, vector< pair<int, int> > &vecBegEnd) const
-{
-    pair<int, int> paraIdx_sentIdx;
-    if (0 != MapGlobalSentIdx2paraIdx_sentIdx(sentenceIdx, paraIdx_sentIdx)) return -1;
-
-    TiXmlElement *wordPtr = m_document.paragraphs[paraIdx_sentIdx.first].sentences[paraIdx_sentIdx.second].words[wordIdx].wordPtr;
-    TiXmlElement *argPtr = wordPtr->FirstChildElement(TAG_SRL_ARG);
-    if (argPtr == NULL)
-    {
-        cerr << "\"" << TAG_SRL_ARG << "\" does not exists in word " << wordIdx
-            << " of sentence " << paraIdx_sentIdx.first  << " of paragraph " << paraIdx_sentIdx.first << endl;
-        return -1;
-    }
-
-    if (vecType.size() != vecBegEnd.size())
-    {
-        cerr << "vecType's size() != vecBegEnd.size(), should resize() first." << endl;
-        return -1;
-    }
-    if (vecType.empty())
-    {
-        cerr << "vecType is empty" << endl;
-        return -1;
-    }
-
-    int i = 0;
-    do
-    {
-        const char *cszType = argPtr->Attribute(TAG_SRL_TYPE);
-        const char *cszBeg = argPtr->Attribute(TAG_BEGIN);
-        const char *cszEnd = argPtr->Attribute(TAG_END);
-        vecType[i] = cszType;
-        int uiBeg = static_cast<int>(cszBeg != NULL ? atoi(cszBeg) : 0);
-        int uiEnd = static_cast<int>(cszEnd != NULL ? atoi(cszEnd) : 0);
-        //vecBegEnd.push_back( make_pair(uiBeg, uiEnd) );
-        vecBegEnd[i].first = uiBeg;
-        vecBegEnd[i].second = uiEnd;
-
-        argPtr = argPtr->NextSiblingElement(TAG_SRL_ARG);
-        ++i;
-    } while (argPtr != NULL && i < vecType.size());
-
-    if ( ! (argPtr == NULL && i == vecType.size()) )
-    {
-        if (argPtr == NULL)
-        {
-            cerr << "vecType.size() is too large" << endl;
-        }
-        else
-        {
-            cerr << "vecType.size() is too small" << endl;
-        }
 
-        return -1;
-    }
+int XML4NLP::GetPredArgToWord(int pid,
+                              int sid,
+                              int wid,
+                              std::vector<const char *> & role,
+                              std::vector< std::pair<int, int> > & range) const {
+  if (0 != CheckRange(pid, sid, wid)) return -1;
 
-    return 0;	
-}
+  TiXmlElement *wordPtr = document.paragraphs[pid].sentences[sid].words[wid].wordPtr;
+  TiXmlElement *argPtr = wordPtr->FirstChildElement(TAG_SRL_ARG);
 
-int XML4NLP::GetPredArgToWord(	int globalWordIdx,
-        vector<const char *> &vecType, vector< pair<int, int> > &vecBegEnd) const
-{
-    int paraIdx, sentIdx, wordIdx;
-    if (0 != MapGlobalWordIdx2paraIdx_sentIdx_wordIdx(globalWordIdx, paraIdx, sentIdx, wordIdx)) return -1;
-
-    TiXmlElement *wordPtr = m_document.paragraphs[paraIdx].sentences[sentIdx].words[wordIdx].wordPtr;
-    TiXmlElement *argPtr = wordPtr->FirstChildElement(TAG_SRL_ARG);
-    if (argPtr == NULL)
-    {
-        cerr << "\"" << TAG_SRL_ARG << "\" does not exists in word " << wordIdx
-            << " of sentence " << paraIdx  << " of paragraph " << sentIdx << endl;
-        return -1;
-    }
-
-    if (vecType.size() != vecBegEnd.size())
-    {
-        cerr << "vecType's size() != vecBegEnd.size(), should resize() first." << endl;
-        return -1;
-    }
-    if (vecType.empty())
-    {
-        cerr << "vecType is empty" << endl;
-        return -1;
-    }
-
-    int i = 0;
-    do
-    {
-        const char *cszType = argPtr->Attribute(TAG_SRL_TYPE);
-        const char *cszBeg = argPtr->Attribute(TAG_BEGIN);
-        const char *cszEnd = argPtr->Attribute(TAG_END);
-        int uiBeg = static_cast<int>(cszBeg != NULL ? atoi(cszBeg) : 0);
-        int uiEnd = static_cast<int>(cszEnd != NULL ? atoi(cszEnd) : 0);
-        vecType[i] = cszType;
-        vecBegEnd[i].first = uiBeg;
-        vecBegEnd[i].second = uiEnd;
-
-        argPtr = argPtr->NextSiblingElement(TAG_SRL_ARG);
-        ++i;
-    } while (argPtr != NULL && i < vecType.size());
-
-    if ( ! (argPtr == NULL && i == vecType.size()) )
-    {
-        if (argPtr == NULL)
-        {
-            cerr << "vecType.size() is too large" << endl;
-        }
-        else
-        {
-            cerr << "vecType.size() is too small" << endl;
-        }
-
-        return -1;
-    }
+  if (argPtr == NULL) {
+    std::cerr << "\""
+              << TAG_SRL_ARG
+              << "\" does not exists in word "
+              << wid
+              << " of sentence "
+              << sid
+              << " of paragraph "
+              << pid << std::endl;
+    return -1;
+  }
 
-    return 0;
-}
+  if (role.size() != range.size()) {
+    std::cerr << "role's size() != range.size(), should resize() first." << std::endl;
+    return -1;
+  }
 
-int XML4NLP::GetPredArgToWord(	int paragraphIdx, int sentenceIdx, int wordIdx, 
-        vector<string> &vecType, vector< pair<int, int> > &vecBegEnd) const
-{
-    if (0 != CheckRange(paragraphIdx, sentenceIdx, wordIdx)) return -1;
-
-    TiXmlElement *wordPtr = m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words[wordIdx].wordPtr;
-
-    vecType.clear();
-    vecBegEnd.clear();
-    TiXmlElement *argPtr = wordPtr->FirstChildElement(TAG_SRL_ARG);
-    if (argPtr == NULL)
-    {
-        cerr << "\"" << TAG_SRL_ARG << "\" does not exists in word " << wordIdx
-            << " of sentence " << sentenceIdx  << " of paragraph " << paragraphIdx << endl;
-        return -1;
+  if (role.empty()) {
+    cerr << "role is empty" << endl;
+    return -1;
+  }
+
+  int i = 0;
+
+  do {
+    const char *cszType = argPtr->Attribute(TAG_SRL_TYPE);
+    const char *cszBeg = argPtr->Attribute(TAG_BEGIN);
+    const char *cszEnd = argPtr->Attribute(TAG_END);
+    role[i] = cszType;
+    int uiBeg = static_cast<int>(cszBeg != NULL ? atoi(cszBeg) : 0);
+    int uiEnd = static_cast<int>(cszEnd != NULL ? atoi(cszEnd) : 0);
+    range[i].first = uiBeg;
+    range[i].second = uiEnd;
+
+    argPtr = argPtr->NextSiblingElement(TAG_SRL_ARG);
+    ++i;
+  } while (argPtr != NULL && i < role.size());
+
+  if ( ! (argPtr == NULL && i == role.size()) ) {
+    if (argPtr == NULL) {
+      cerr << "role.size() is too large" << endl;
+    } else {
+      cerr << "role.size() is too small" << endl;
     }
 
-    do
-    {
-        const char *cszType = argPtr->Attribute(TAG_SRL_TYPE);
-        const char *cszBeg = argPtr->Attribute(TAG_BEGIN);
-        const char *cszEnd = argPtr->Attribute(TAG_END);
-        vecType.push_back(cszType != NULL ? cszType : "" );
-        int uiBeg = static_cast<int>(cszBeg != NULL ? atoi(cszBeg) : 0);
-        int uiEnd = static_cast<int>(cszEnd != NULL ? atoi(cszEnd) : 0);
-        vecBegEnd.push_back( make_pair(uiBeg, uiEnd) );
+    return -1;
+  }
+
+  return 0;
+}
+
+int XML4NLP::GetPredArgToWord(int global_sid,
+                              int wid,
+                              std::vector<const char *> & role,
+                              std::vector< std::pair<int, int> > & range) const {
+  int pid, sid;
+  if (0 != DecodeGlobalId(global_sid, pid, sid)) return -1;
+  return GetPredArgToWord(pid, sid, wid, role, range);
+}
+
+int XML4NLP::GetPredArgToWord(int global_wid,
+                              std::vector<const char *> & role,
+                              std::vector< std::pair<int, int> > & range) const {
+  int pid, sid, wid;
+  if (0 != DecodeGlobalId(global_wid, pid, sid, wid)) return -1;
+  return GetPredArgToWord(pid, sid, wid, role, range);
+}
+
+int XML4NLP::GetPredArgToWord(int pid,
+                              int sid,
+                              int wid,
+                              std::vector<std::string> & role,
+                              std::vector< std::pair<int, int> > & range) const {
+  std::vector<const char *> role2;
+  int ret = GetPredArgToWord(pid, sid, wid, role2, range);
+  if (0 != ret) { return ret; }
+
+  role.resize(role2.size());
+  for (int i = 0; i < role2.size(); ++ i) { role[i] = role2[i]; }
+  return 0;
+}
+
+int XML4NLP::GetPredArgToWord(int global_sid,
+                              int wid,
+                              std::vector<std::string> & role,
+                              std::vector< std::pair<int, int> > & range) const {
+  int pid, sid;
+  if (0 != DecodeGlobalId(global_sid, pid, sid)) return -1;
+  return GetPredArgToWord(pid, sid, wid, role, range);
+}
+
+
+int XML4NLP::SetPredArgToWord(int pid,
+                              int sid,
+                              int wid,
+                              const std::vector<std::string> & role,
+                              const std::vector< std::pair<int, int> > & range) {
+  if (0 != CheckRange(pid, sid, wid)) return -1;
+
+  TiXmlElement *wordPtr = document.paragraphs[pid].sentences[sid].words[wid].wordPtr;
+
+  if (wordPtr->FirstChildElement(TAG_SRL_ARG) != NULL) {
+    std::cerr << "\""
+              << TAG_SRL_ARG
+              << "\" already exists in word "
+              << wid
+              << " of sentence "
+              << sid
+              << " of paragraph "
+              << pid << std::endl;
+    return -1;
+  }
 
-        argPtr = argPtr->NextSiblingElement(TAG_SRL_ARG);
-    } while (argPtr != NULL);
+  for (int i = 0; i < role.size(); ++ i) {
+    TiXmlElement *argPtr = new TiXmlElement(TAG_SRL_ARG);
+    argPtr->SetAttribute(TAG_ID, i);
+    argPtr->SetAttribute(TAG_SRL_TYPE, role[i].c_str());
+    argPtr->SetAttribute(TAG_BEGIN, range[i].first);
+    argPtr->SetAttribute(TAG_END, range[i].second);
+    wordPtr->LinkEndChild(argPtr);
+  }
 
-    return 0;
+  return 0;
 }
 
-int XML4NLP::GetPredArgToWord(	int sentenceIdx, int wordIdx, 
-        vector<string> &vecType, vector< pair<int, int> > &vecBegEnd) const
-{
-    pair<int, int> paraIdx_sentIdx;
-    if (0 != MapGlobalSentIdx2paraIdx_sentIdx(sentenceIdx, paraIdx_sentIdx)) return -1;
-
-    TiXmlElement *wordPtr = m_document.paragraphs[paraIdx_sentIdx.first].sentences[paraIdx_sentIdx.second].words[wordIdx].wordPtr;
-
-    vecType.clear();
-    vecBegEnd.clear();
-    TiXmlElement *argPtr = wordPtr->FirstChildElement(TAG_SRL_ARG);
-    if (argPtr == NULL)
-    {
-        cerr << "\"" << TAG_SRL_ARG << "\" does not exists in word " << wordIdx
-            << " of sentence " << paraIdx_sentIdx.first  << " of paragraph " << paraIdx_sentIdx.first << endl;
-        return -1;
-    }
-
-    do
-    {
-        const char *cszType = argPtr->Attribute(TAG_SRL_TYPE);
-        const char *cszBeg = argPtr->Attribute(TAG_BEGIN);
-        const char *cszEnd = argPtr->Attribute(TAG_END);
-        vecType.push_back(cszType != NULL ? cszType : "" );
-        int uiBeg = static_cast<int>(cszBeg != NULL ? atoi(cszBeg) : 0);
-        int uiEnd = static_cast<int>(cszEnd != NULL ? atoi(cszEnd) : 0);
-        vecBegEnd.push_back( make_pair(uiBeg, uiEnd) );
-
-        argPtr = argPtr->NextSiblingElement(TAG_SRL_ARG);
-    } while (argPtr != NULL);
-    return 0;	
+int XML4NLP::SetPredArgToWord(int global_sid,
+                              int wid,
+                              const std::vector<std::string> & role,
+                              const std::vector< std::pair<int, int> > & range) {
+  int pid, sid;
+  if (0 != DecodeGlobalId(global_sid, pid, sid)) return -1;
+  return SetPredArgToWord(pid, sid, wid, role, range);
 }
 
+int XML4NLP::GetMentionOfEntity(std::vector< std::pair<int, int> > &mention,
+                                int entityIdx) const {
+  if (entityIdx >= coref.vecEntity.size()) {
+    cerr << "entity idx is too large" << endl;
+    return -1;
+  }
 
-int XML4NLP::SetPredArgToWord(	int paragraphIdx, int sentenceIdx, int wordIdx, 
-        const vector<string> &vecType, const vector< pair<int, int> > &vecBegEnd)
-{
-
-    if (0 != CheckRange(paragraphIdx, sentenceIdx, wordIdx)) return -1;
-
-    TiXmlElement *wordPtr = m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words[wordIdx].wordPtr;
-
-    if (wordPtr->FirstChildElement(TAG_SRL_ARG) != NULL)
-    {
-        cerr << "\"" << TAG_SRL_ARG << "\" already exists in word " << wordIdx
-            << " of sentence " << sentenceIdx  << " of paragraph " << paragraphIdx << endl;
-        return -1;
-    }
+  const vector<Mention> &mentionRef = coref.vecEntity[entityIdx].vecMention;
+  if (mention.size() != mentionRef.size()) {
+    std::cerr << "mention.size() does not equal to the num of mention,"
+              << " should resize() first"
+              << std::endl;
+    return -1;
+  }
 
-    for (int i = 0; i < vecType.size(); ++i)
-    {
-        TiXmlElement *argPtr = new TiXmlElement(TAG_SRL_ARG);
-        argPtr->SetAttribute(TAG_ID, i);
-        argPtr->SetAttribute(TAG_SRL_TYPE, vecType[i].c_str());
-        argPtr->SetAttribute(TAG_BEGIN, vecBegEnd[i].first);
-        argPtr->SetAttribute(TAG_END, vecBegEnd[i].second);
-        wordPtr->LinkEndChild(argPtr);
+  for (int i=0; i < mentionRef.size(); ++i) {
+    const char *cszBeg = mentionRef[i].mentionPtr->Attribute(TAG_BEGIN);
+    const char *cszEnd = mentionRef[i].mentionPtr->Attribute(TAG_END);
+    if (cszBeg == NULL || cszEnd == NULL) {
+      std::cerr << "mention attribute err in DOM" << std::endl;
+      return -1;
     }
-    return 0;
+    mention[i].first = atoi(cszBeg);
+    mention[i].second = atoi(cszEnd);
+  }
+  return 0;
 }
 
-int XML4NLP::SetPredArgToWord(	int sentenceIdx, int wordIdx, 
-        const vector<string> &vecType, const vector< pair<int, int> > &vecBegEnd)
-{
-    pair<int, int> paraIdx_sentIdx;
-    if (0 != MapGlobalSentIdx2paraIdx_sentIdx(sentenceIdx, paraIdx_sentIdx)) return -1;
-
-    TiXmlElement *wordPtr = m_document.paragraphs[paraIdx_sentIdx.first].sentences[paraIdx_sentIdx.second].words[wordIdx].wordPtr;
+int XML4NLP::GetCoreference(vector< vector< pair<int, int> > > &vecCoref) const {
+  if (coref.nodePtr == NULL) {
+    cerr << "has not done coreference" << endl;
+    return -1;
+  }
+  vecCoref.clear();
+  TiXmlElement *crPtr = coref.nodePtr->FirstChildElement(TAG_COREF_CR);
 
-    if (wordPtr->FirstChildElement(TAG_SRL_ARG) != NULL)
-    {
-        cerr << "\"" << TAG_SRL_ARG << "\" already exists in word " << wordIdx
-            << " of sentence " << paraIdx_sentIdx.first  << " of paragraph " << paraIdx_sentIdx.first << endl;
-        return -1;
-    }
+  for (; crPtr != NULL; crPtr = crPtr->NextSiblingElement(TAG_COREF_CR)) {
+    vecCoref.push_back( vector< pair<int, int> >() );
+    vector< pair<int, int> > &vecRef = vecCoref[vecCoref.size()-1];
+    TiXmlElement *mentPtr = crPtr->FirstChildElement(TAG_COREF_MENT);
 
-    for (int i = 0; i < vecType.size(); ++i)
-    {
-        TiXmlElement *argPtr = new TiXmlElement(TAG_SRL_ARG);
-        argPtr->SetAttribute(TAG_ID, i);
-        argPtr->SetAttribute(TAG_SRL_TYPE, vecType[i].c_str());
-        argPtr->SetAttribute(TAG_BEGIN, vecBegEnd[i].first);
-        argPtr->SetAttribute(TAG_END, vecBegEnd[i].second);
-        wordPtr->LinkEndChild(argPtr);
+    for (; mentPtr != NULL; mentPtr = mentPtr->NextSiblingElement(TAG_COREF_MENT)) {
+      const char *cszBeg = mentPtr->Attribute(TAG_BEGIN);
+      const char *cszEnd = mentPtr->Attribute(TAG_END);
+      int uiBeg = static_cast<int>(cszBeg != NULL ? atoi(cszBeg) : 0);
+      int uiEnd = static_cast<int>(cszEnd != NULL ? atoi(cszEnd) : 0);
+      vecRef.push_back( make_pair(uiBeg, uiEnd) );
     }
-    return 0;	
+  }
+  return 0;
 }
 
-// ----------------------------------------------------------------for coreference resolution
-int XML4NLP::GetMentionOfEntity(vector< pair<int, int> > &vecMention, int entityIdx) const
-{
-    if (entityIdx >= m_coref.vecEntity.size())
-    {
-        cerr << "entity idx is too large" << endl;
-        return -1;
-    }
+int XML4NLP::SetCoreference(const vector< vector< pair<int, int> > > &vecCoref) {
+  if (coref.nodePtr != NULL) {
+    cerr << "has already done coreference" << endl;
+    return -1;
+  }
 
-    const vector<Mention> &vecMentionRef = m_coref.vecEntity[entityIdx].vecMention;
-    if (vecMention.size() != vecMentionRef.size())
-    {
-        cerr << "vecMention.size() does not equal to the num of mention, should resize() first" << endl;
-        return -1;
-    }
+  coref.nodePtr = new TiXmlElement(TAG_COREF);
+  for (int i = 0; i < vecCoref.size(); ++i) {
+    TiXmlElement *crPtr = new TiXmlElement(TAG_COREF_CR);
+    crPtr->SetAttribute(TAG_ID, i);
 
-    for (int i=0; i < vecMentionRef.size(); ++i)
-    {
-        const char *cszBeg = vecMentionRef[i].mentionPtr->Attribute(TAG_BEGIN);
-        const char *cszEnd = vecMentionRef[i].mentionPtr->Attribute(TAG_END);
-        if (cszBeg == NULL || cszEnd == NULL)
-        {
-            cerr << "mention attribute err in DOM" << endl;
-            return -1;
-        }
-        vecMention[i].first = atoi(cszBeg);
-        vecMention[i].second = atoi(cszEnd);
-    }
-    return 0;
-}
+    coref.vecEntity.push_back( Entity() );
+    Entity &entity = coref.vecEntity[coref.vecEntity.size() - 1];
+    entity.entityPtr = crPtr;
 
-int XML4NLP::GetCoreference(vector< vector< pair<int, int> > > &vecCoref) const
-{
-    if (m_coref.nodePtr == NULL)
-    {
-        cerr << "has not done coreference" << endl;
-        return -1;
-    }
-    vecCoref.clear();
-    TiXmlElement *crPtr = m_coref.nodePtr->FirstChildElement(TAG_COREF_CR);
-    for (; crPtr != NULL; crPtr = crPtr->NextSiblingElement(TAG_COREF_CR))
-    {
-        vecCoref.push_back( vector< pair<int, int> >() );
-        vector< pair<int, int> > &vecRef = vecCoref[vecCoref.size()-1];
-        TiXmlElement *mentPtr = crPtr->FirstChildElement(TAG_COREF_MENT);
-        for (; mentPtr != NULL; mentPtr = mentPtr->NextSiblingElement(TAG_COREF_MENT))
-        {
-            const char *cszBeg = mentPtr->Attribute(TAG_BEGIN);
-            const char *cszEnd = mentPtr->Attribute(TAG_END);
-            int uiBeg = static_cast<int>(cszBeg != NULL ? atoi(cszBeg) : 0);
-            int uiEnd = static_cast<int>(cszEnd != NULL ? atoi(cszEnd) : 0);
-            vecRef.push_back( make_pair(uiBeg, uiEnd) );
-        }
-    }
-    return 0;
-}
+    for (int j = 0; j < vecCoref[i].size(); ++j) {
+      TiXmlElement *mentPtr = new TiXmlElement(TAG_COREF_MENT);
+      mentPtr->SetAttribute(TAG_ID, j);
+      mentPtr->SetAttribute(TAG_BEGIN, vecCoref[i][j].first);
+      mentPtr->SetAttribute(TAG_END, vecCoref[i][j].second);
+      crPtr->LinkEndChild(mentPtr);
 
-int XML4NLP::SetCoreference(const vector< vector< pair<int, int> > > &vecCoref)
-{
-    if (m_coref.nodePtr != NULL)
-    {
-        cerr << "has already done coreference" << endl;
-        return -1;
+      entity.vecMention.push_back( Mention() );
+      Mention &mention = entity.vecMention[entity.vecMention.size() - 1];
+      mention.mentionPtr = mentPtr;
     }
 
-    m_coref.nodePtr = new TiXmlElement(TAG_COREF);
-    for (int i = 0; i < vecCoref.size(); ++i)
-    {
-        TiXmlElement *crPtr = new TiXmlElement(TAG_COREF_CR);
-        crPtr->SetAttribute(TAG_ID, i);
-
-        m_coref.vecEntity.push_back( Entity() );
-        Entity &entity = m_coref.vecEntity[m_coref.vecEntity.size() - 1];
-        entity.entityPtr = crPtr;
-
-        for (int j = 0; j < vecCoref[i].size(); ++j)
-        {
-            TiXmlElement *mentPtr = new TiXmlElement(TAG_COREF_MENT);
-            mentPtr->SetAttribute(TAG_ID, j);
-            mentPtr->SetAttribute(TAG_BEGIN, vecCoref[i][j].first);
-            mentPtr->SetAttribute(TAG_END, vecCoref[i][j].second);
-            crPtr->LinkEndChild(mentPtr);
-
-            entity.vecMention.push_back( Mention() );			
-            Mention &mention = entity.vecMention[entity.vecMention.size() - 1];
-            mention.mentionPtr = mentPtr;
-        }
-
-        m_coref.nodePtr->LinkEndChild(crPtr);
-    }
-    m_tiXmlDoc.RootElement()->LinkEndChild(m_coref.nodePtr);
+    coref.nodePtr->LinkEndChild(crPtr);
+  }
+  m_tiXmlDoc.RootElement()->LinkEndChild(coref.nodePtr);
 
-    return 0;
+  return 0;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
 /// initialize the XML DOM tree.
 /// after the process LoadFile(), the DOM tree has been set up
-/// but it is not fully conform to our need, 
+/// but it is not fully conform to our need,
 /// for example, the member "paragraphss" of the class Document has not been initialized,
 /// this function just do this.
 /////////////////////////////////////////////////////////////////////////////////////
 int XML4NLP::InitXmlStructure() {
-    TiXmlElement *xml4nlp       = m_tiXmlDoc.RootElement();
-    m_document.documentPtr      = xml4nlp->FirstChildElement(TAG_DOC);
-    m_note.nodePtr              = xml4nlp->FirstChildElement(TAG_NOTE);
-    // document summary, text classification and coreference is not
-    // provided in current version (v3.0.0)
-    // m_summary.nodePtr           = xml4nlp->FirstChildElement(TAG_SUM);
-    // m_textclass.nodePtr         = xml4nlp->FirstChildElement(TAG_CLASS);
-    // m_coref.nodePtr             = xml4nlp->FirstChildElement(TAG_COREF);
-
-    if (m_document.documentPtr == NULL) { // consider it as wrong for now.
-        cerr << "there is no \"" << TAG_DOC << "\" tag in xml file." << endl;
-        return -1;
-    }
+  TiXmlElement *xml4nlp     = m_tiXmlDoc.RootElement();
+  document.documentPtr    = xml4nlp->FirstChildElement(TAG_DOC);
+  note.nodePtr        = xml4nlp->FirstChildElement(TAG_NOTE);
+  // document summary, text classification and coreference is not
+  // provided in current version (v3.0.0)
+  // summary.nodePtr       = xml4nlp->FirstChildElement(TAG_SUM);
+  // textclass.nodePtr     = xml4nlp->FirstChildElement(TAG_CLASS);
+  // coref.nodePtr       = xml4nlp->FirstChildElement(TAG_COREF);
+
+  if (document.documentPtr == NULL) { // consider it as wrong for now.
+    cerr << "there is no \"" << TAG_DOC << "\" tag in xml file." << endl;
+    return -1;
+  }
 
-    if (0 != InitXmlDocument(m_document)) {
-        return -1;
-    }
+  if (0 != InitXmlDocument(document)) {
+    return -1;
+  }
 
-    if (m_coref.nodePtr != NULL) {
-        if (0 != InitXmlCoref(m_coref)) {
-            return -1;
-        }
+  if (coref.nodePtr != NULL) {
+    if (0 != InitXmlCoref(coref)) {
+      return -1;
     }
+  }
 
-    return 0;
+  return 0;
 }
 
+int XML4NLP::InitXmlCoref(Coref &coref) {
+  TiXmlElement *entityPtr = coref.nodePtr->FirstChildElement(TAG_COREF_CR);
 
-void XML4NLP::CheckNoteForOldLtml()
-{
-    m_note.nodePtr = new TiXmlElement(TAG_NOTE);
-    m_tiXmlDoc.RootElement()->LinkEndChild( m_note.nodePtr );
-    ClearAllNote();
-
-    //	if (m_coref.nodePtr != NULL) SetNote(NOTE_CR);
-    //	if (m_summary.nodePtr != NULL) SetNote(NOTE_SUM);
-    //	if (m_textclass.nodePtr != NULL) SetNote(NOTE_CLASS);
-
-    if ( m_document.paragraphs.empty() ) return;
-    if ( m_document.paragraphs[0].sentences.empty() ) return;
-    SetNote(NOTE_SENT);
-    if ( m_document.paragraphs[0].sentences[0].words.empty() ) return;
-    SetNote(NOTE_WORD);
-    TiXmlElement *wordPtr = m_document.paragraphs[0].sentences[0].words[0].wordPtr;
-    if ( wordPtr->Attribute(TAG_POS) != NULL ) SetNote(NOTE_POS);
-    if ( wordPtr->Attribute(TAG_NE) != NULL ) SetNote(NOTE_NE);
-    if ( wordPtr->Attribute(TAG_WSD) != NULL ) SetNote(NOTE_WSD);			// consider only one attribute, excluding TAG_WSD_EXP
-    if ( wordPtr->Attribute(TAG_PSR_PARENT) != NULL ) SetNote(NOTE_PARSER); // excluding TAG_PSR_RELATE
-    if ( wordPtr->Attribute(TAG_SRL_ARG) != NULL ) SetNote(NOTE_SRL);		// excluding TAG_SRL_TYPE
-}
-
-int XML4NLP::InitXmlCoref(Coref &coref)
-{
-    TiXmlElement *entityPtr = coref.nodePtr->FirstChildElement(TAG_COREF_CR);
-    if (entityPtr == NULL)
-    {
-        return 0;
-    }
-
-    do 
-    {
-        if (0 != InitXmlEntity(coref.vecEntity, entityPtr)) return -1;
-        entityPtr = entityPtr->NextSiblingElement(TAG_COREF_CR);
-    } while (entityPtr != NULL);
+  if (entityPtr == NULL) {
     return 0;
+  }
+
+  do {
+    if (0 != InitXmlEntity(coref.vecEntity, entityPtr)) return -1;
+    entityPtr = entityPtr->NextSiblingElement(TAG_COREF_CR);
+  } while (entityPtr != NULL);
+  return 0;
 }
 
-int XML4NLP::InitXmlEntity(vector<Entity> &vecEntity, TiXmlElement *entityPtr)
-{
-    vecEntity.push_back( Entity() );
-    Entity &entity = vecEntity[vecEntity.size()-1];
-    entity.entityPtr = entityPtr;
-
-    TiXmlElement *mentionPtr = entityPtr->FirstChildElement(TAG_COREF_MENT);
-    if (mentionPtr == NULL) return 0;
-
-    do 
-    {
-        if (0 != InitXmlMention(entity.vecMention, mentionPtr)) return -1;
-        mentionPtr = mentionPtr->NextSiblingElement(TAG_COREF_MENT);
-    } while(mentionPtr != NULL);
-    return 0;
+int XML4NLP::InitXmlEntity(vector<Entity> &vecEntity, TiXmlElement *entityPtr) {
+  vecEntity.push_back( Entity() );
+  Entity &entity = vecEntity[vecEntity.size()-1];
+  entity.entityPtr = entityPtr;
+
+  TiXmlElement *mentionPtr = entityPtr->FirstChildElement(TAG_COREF_MENT);
+  if (mentionPtr == NULL) return 0;
+
+  do {
+    if (0 != InitXmlMention(entity.vecMention, mentionPtr)) return -1;
+    mentionPtr = mentionPtr->NextSiblingElement(TAG_COREF_MENT);
+  } while(mentionPtr != NULL);
+  return 0;
 }
 
-int XML4NLP::InitXmlMention(vector<Mention> &vecMention, TiXmlElement *mentionPtr)
-{
-    vecMention.push_back( Mention() );
-    vecMention[vecMention.size() -1].mentionPtr = mentionPtr;
-    return 0;
+int XML4NLP::InitXmlMention(vector<Mention> &vecMention, TiXmlElement *mentionPtr) {
+  vecMention.push_back( Mention() );
+  vecMention[vecMention.size() -1].mentionPtr = mentionPtr;
+  return 0;
 }
 
-int XML4NLP::InitXmlDocument(Document_t &document)
-{
-    TiXmlElement *paragraphPtr = document.documentPtr->FirstChildElement(TAG_PARA);
-    if (paragraphPtr == NULL)	// consider it as wrong for now.
-    {
-        cerr << "there is no \"" << TAG_PARA << "\" tag in xml file." << endl;
-        return -1;
-    }
+int XML4NLP::InitXmlDocument(Document &document) {
+  TiXmlElement *paragraphPtr = document.documentPtr->FirstChildElement(TAG_PARA);
+  if (paragraphPtr == NULL)   {
+    // consider it as wrong for now.
+    cerr << "there is no \"" << TAG_PARA << "\" tag in xml file." << endl;
+    return -1;
+  }
 
-    do
-    {
-        if (0 != InitXmlParagraph(document.paragraphs, paragraphPtr)) return -1;
-        paragraphPtr = paragraphPtr->NextSiblingElement(TAG_PARA);
-    } while (paragraphPtr != NULL);
-    return 0;
+  do {
+    if (0 != InitXmlParagraph(document.paragraphs, paragraphPtr)) return -1;
+    paragraphPtr = paragraphPtr->NextSiblingElement(TAG_PARA);
+  } while (paragraphPtr != NULL);
+  return 0;
 }
 
-int XML4NLP::InitXmlParagraph(vector<Paragraph_t> &paragraphs, TiXmlElement *paragraphPtr)
+int XML4NLP::InitXmlParagraph(vector<Paragraph> &paragraphs, TiXmlElement *paragraphPtr)
 {
-    paragraphs.push_back( Paragraph_t() );
-    Paragraph_t &paragraph = paragraphs[paragraphs.size()-1];
-    paragraph.paragraphPtr = paragraphPtr;
+  paragraphs.push_back( Paragraph() );
+  Paragraph &paragraph = paragraphs[paragraphs.size()-1];
+  paragraph.paragraphPtr = paragraphPtr;
 
-    TiXmlElement *stnsPtr = paragraphPtr->FirstChildElement(TAG_SENT);
-    if (stnsPtr == NULL) return 0;	// have not split sentence
+  TiXmlElement *stnsPtr = paragraphPtr->FirstChildElement(TAG_SENT);
+  if (stnsPtr == NULL) return 0;  // have not split sentence
 
-    // record the sentence info
-    do {
-        if (0 != InitXmlSentence(paragraph.sentences, stnsPtr)) return -1;
-        stnsPtr = stnsPtr->NextSiblingElement(TAG_SENT);
-    } while(stnsPtr != NULL);
+  // record the sentence info
+  do {
+    if (0 != InitXmlSentence(paragraph.sentences, stnsPtr)) return -1;
+    stnsPtr = stnsPtr->NextSiblingElement(TAG_SENT);
+  } while(stnsPtr != NULL);
 
-    return 0;
+  return 0;
 }
 
-int XML4NLP::InitXmlSentence(vector<Sentence_t> &sentences, TiXmlElement *stnsPtr)
+int XML4NLP::InitXmlSentence(vector<Sentence> &sentences, TiXmlElement *stnsPtr)
 {
-    sentences.push_back( Sentence_t() );
-    Sentence_t &sentence = sentences[sentences.size()-1];
-    sentence.sentencePtr = stnsPtr;
+  sentences.push_back( Sentence() );
+  Sentence &sentence = sentences[sentences.size()-1];
+  sentence.sentencePtr = stnsPtr;
 
-    TiXmlElement *wordPtr = stnsPtr->FirstChildElement(TAG_WORD);
-    if (wordPtr == NULL) return 0;	// have not done word segment
+  TiXmlElement *wordPtr = stnsPtr->FirstChildElement(TAG_WORD);
+  if (wordPtr == NULL) return 0;  // have not done word segment
 
-    do
-    {
-        if (0 != InitXmlWord(sentence.words, wordPtr)) return -1;
-        wordPtr = wordPtr->NextSiblingElement(TAG_WORD);
-    } while(wordPtr != NULL);
+  do
+  {
+    if (0 != InitXmlWord(sentence.words, wordPtr)) return -1;
+    wordPtr = wordPtr->NextSiblingElement(TAG_WORD);
+  } while(wordPtr != NULL);
 
-    return 0;
+  return 0;
 }
 
-int XML4NLP::InitXmlWord(vector<Word_t> &words, TiXmlElement *wordPtr)
-{
-    words.push_back( Word_t() );
-    words[words.size()-1].wordPtr = wordPtr;
-    return 0;
+int XML4NLP::InitXmlWord(vector<Word> &words, TiXmlElement *wordPtr) {
+  words.push_back( Word() );
+  words[words.size()-1].wordPtr = wordPtr;
+  return 0;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
 /// build the initial DOM tree frame.
-/// it creates the XML declaration and the XSL declaration instructions and creates 
+/// it creates the XML declaration and the XSL declaration instructions and creates
 /// a root element "xml4nlp" and a child node "doc".
 /////////////////////////////////////////////////////////////////////////////////////
 int XML4NLP::BuildDOMFrame() {
-    TiXmlDeclaration * xmlDeclaration   = new TiXmlDeclaration("1.0", "utf-8", "");
-    TiXmlElement * xml4nlp              = new TiXmlElement("xml4nlp");
-    m_note.nodePtr                      = new TiXmlElement(TAG_NOTE);
-    m_document.documentPtr            = new TiXmlElement(TAG_DOC);
+  TiXmlDeclaration * xmlDeclaration   = new TiXmlDeclaration("1.0", "utf-8", "");
+  TiXmlElement * xml4nlp        = new TiXmlElement("xml4nlp");
+  note.nodePtr            = new TiXmlElement(TAG_NOTE);
+  document.documentPtr      = new TiXmlElement(TAG_DOC);
 
-    m_tiXmlDoc.LinkEndChild(xmlDeclaration);
-    m_tiXmlDoc.LinkEndChild(xml4nlp);
+  m_tiXmlDoc.LinkEndChild(xmlDeclaration);
+  m_tiXmlDoc.LinkEndChild(xml4nlp);
 
-    xml4nlp->LinkEndChild(m_note.nodePtr);
-    ClearAllNote();
-    xml4nlp->LinkEndChild(m_document.documentPtr);
+  xml4nlp->LinkEndChild(note.nodePtr);
+  ClearAllNote();
+  xml4nlp->LinkEndChild(document.documentPtr);
 
-    return 0;
+  return 0;
 }
 
 bool XML4NLP::LTMLValidation() {
-    // there should not be any attributes in `<xml4nlp>`
-    // but it wont matter
-
-    // is the attributes in `note` legal
-    int state = 0;
-    state |= QueryNote(NOTE_SRL);       state <<= 1;
-    state |= QueryNote(NOTE_NE);        state <<= 1;
-    state |= QueryNote(NOTE_PARSER);    state <<= 1; 
-    state |= QueryNote(NOTE_POS);       state <<= 1;
-    state |= QueryNote(NOTE_WORD);      state <<= 1;
-    state |= QueryNote(NOTE_SENT);
-
-    if (0 == state ||           //     0
-            0x01 == state ||    //     1
-            0x03 == state ||    //    11
-            0x07 == state ||    //   111
-            0x0f == state ||    //  1111
-            0x17 == state ||    // 10111
-            0x1f == state ||    // 11111
-            0x3f == state) {
-    } else {
-        return false;
-    }
-
-    // if sent attribute in note is `y`, there should be an `cont`
-    // attribute in para node.
-    // travel through all the `para` node, query if there is a `cont`
-    // attribute
-    if (!(state & 0x01)) {
-        for (unsigned i = 0; i < m_document.paragraphs.size(); ++ i) {
-            const Paragraph_t & paragraph = m_document.paragraphs[i];
-            if (!paragraph.sentences.size()) {
-                if (!paragraph.paragraphPtr->GetText()) { return false; }
-            } else {
-                for (unsigned j = 0; j < paragraph.sentences.size(); ++ j) {
-                    const Sentence_t & sentence = paragraph.sentences[j];
-                    if (!sentence.sentencePtr->Attribute(TAG_CONT)) { return false; }
-                }
-            }
+  // there should not be any attributes in `<xml4nlp>`
+  // but it wont matter
+  if (!note.nodePtr->Attribute(NOTE_SENT)
+      || !note.nodePtr->Attribute(NOTE_WORD)
+      || !note.nodePtr->Attribute(NOTE_POS)
+      || !note.nodePtr->Attribute(NOTE_PARSER)
+      || !note.nodePtr->Attribute(NOTE_NE)
+      || !note.nodePtr->Attribute(NOTE_SRL)) {
+    return false;
+  }
+
+  // is the attributes in `note` legal
+  int state = 0;
+  state |= QueryNote(NOTE_SRL);     state <<= 1;
+  state |= QueryNote(NOTE_NE);      state <<= 1;
+  state |= QueryNote(NOTE_PARSER);  state <<= 1;
+  state |= QueryNote(NOTE_POS);     state <<= 1;
+  state |= QueryNote(NOTE_WORD);    state <<= 1;
+  state |= QueryNote(NOTE_SENT);
+
+  if (0 == state ||     //     0
+      0x01 == state ||  //     1
+      0x03 == state ||  //    11
+      0x07 == state ||  //   111
+      0x0f == state ||  //  1111
+      0x17 == state ||  // 10111
+      0x1f == state ||  // 11111
+      0x3f == state) {
+  } else {
+    return false;
+  }
+
+  // if sent attribute in note is `y`, there should be an `cont`
+  // attribute in para node.
+  // travel through all the `para` node, query if there is a `cont`
+  // attribute
+  if (!(state & 0x01)) {
+    for (unsigned i = 0; i < document.paragraphs.size(); ++ i) {
+      const Paragraph & paragraph = document.paragraphs[i];
+      if (!paragraph.sentences.size()) {
+        if (!paragraph.paragraphPtr->GetText()) { return false; }
+      } else {
+        for (unsigned j = 0; j < paragraph.sentences.size(); ++ j) {
+          const Sentence & sentence = paragraph.sentences[j];
+          if (!sentence.sentencePtr->Attribute(TAG_CONT)) { return false; }
         }
+      }
     }
+  }
 
 #define FOREACH(p, s, w) \
-    for (unsigned i = 0; i < m_document.paragraphs.size(); ++ i) { \
-        const Paragraph_t & p = m_document.paragraphs[i]; \
-        for (unsigned j = 0; j < p.sentences.size(); ++ j) { \
-            const Sentence_t & s = p.sentences[j]; \
-            for (unsigned k = 0; k < s.words.size(); ++ k) { \
-                const Word_t & w = s.words[k];
+  for (unsigned i = 0; i < document.paragraphs.size(); ++ i) { \
+    const Paragraph & p = document.paragraphs[i]; \
+    for (unsigned j = 0; j < p.sentences.size(); ++ j) { \
+      const Sentence & s = p.sentences[j]; \
+      for (unsigned k = 0; k < s.words.size(); ++ k) { \
+        const Word & w = s.words[k];
 
 #define END }}}
 
-    FOREACH(p, s, w) 
-        // segment check
-        if ((state & 0x02) && (!w.wordPtr->Attribute(TAG_CONT)))        { return false; }
-        if ((state & 0x04) && (!w.wordPtr->Attribute(TAG_POS)))         { return false; }
-        if ((state & 0x08) && (!w.wordPtr->Attribute(TAG_PSR_PARENT)))  { return false; }
-        if ((state & 0x08) && (!w.wordPtr->Attribute(TAG_PSR_RELATE)))  { return false; }
-        if ((state & 0x10) && (!w.wordPtr->Attribute(TAG_NE)))          { return false; }
-    END
+  FOREACH(p, s, w)
+    // segment check
+    if ((state & 0x02) && (!w.wordPtr->Attribute(TAG_CONT)))        { return false; }
+    if ((state & 0x04) && (!w.wordPtr->Attribute(TAG_POS)))         { return false; }
+    if ((state & 0x08) && (!w.wordPtr->Attribute(TAG_PSR_PARENT)))  { return false; }
+    if ((state & 0x08) && (!w.wordPtr->Attribute(TAG_PSR_RELATE)))  { return false; }
+    if ((state & 0x10) && (!w.wordPtr->Attribute(TAG_NE)))          { return false; }
+  END
 
 #undef END
 #undef FOREACH
 
-    return true;
+  return true;
 }
 
 void XML4NLP::ClearAllNote() {
-    ClearNote(NOTE_SENT);
-    ClearNote(NOTE_WORD);
-    ClearNote(NOTE_POS);
-    ClearNote(NOTE_NE);
-    ClearNote(NOTE_PARSER);
-    ClearNote(NOTE_WSD);
-    ClearNote(NOTE_SRL);
-    //	ClearNote(NOTE_CLASS);
-    //	ClearNote(NOTE_SUM);
-    //	ClearNote(NOTE_CR);
+  ClearNote(NOTE_SENT);
+  ClearNote(NOTE_WORD);
+  ClearNote(NOTE_POS);
+  ClearNote(NOTE_NE);
+  ClearNote(NOTE_PARSER);
+  ClearNote(NOTE_WSD);
+  ClearNote(NOTE_SRL);
+  //  ClearNote(NOTE_CLASS);
+  //  ClearNote(NOTE_SUM);
+  //  ClearNote(NOTE_CR);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
@@ -1604,313 +1237,199 @@ void XML4NLP::ClearAllNote() {
 /// in the initial, a paragraph has only one sentence.
 /////////////////////////////////////////////////////////////////////////////////////
 int XML4NLP::BuildParagraph(string& strParagraph, int paragraphIdx) {
-    if (strParagraph == "��ע����ٰ��Ȩ"
-            || strParagraph == "�������аͱ�"
-            || strParagraph == "��עǧ��������Ȩ") {
-        strParagraph = "��ӭʹ�ù�������ҵ��ѧ��Ϣ�����о������Լ���ƽ̨��";
-    } else {
-    }
 
-    TiXmlElement * documentPtr = m_document.documentPtr;
-    vector<Paragraph_t> &paragraphs = m_document.paragraphs;
+  TiXmlElement * documentPtr = document.documentPtr;
+  vector<Paragraph> &paragraphs = document.paragraphs;
 
-    paragraphs.push_back( Paragraph_t() );
-    Paragraph_t &paragraph = paragraphs[paragraphs.size() - 1];
+  paragraphs.push_back( Paragraph() );
+  Paragraph &paragraph = paragraphs[paragraphs.size() - 1];
 
-    paragraph.paragraphPtr = new TiXmlElement(TAG_PARA);
-    paragraph.paragraphPtr->SetAttribute(TAG_ID, paragraphIdx);
-    documentPtr->LinkEndChild(paragraph.paragraphPtr);
+  paragraph.paragraphPtr = new TiXmlElement(TAG_PARA);
+  paragraph.paragraphPtr->SetAttribute(TAG_ID, paragraphIdx);
+  documentPtr->LinkEndChild(paragraph.paragraphPtr);
 
-    TiXmlText *textPtr = new TiXmlText(strParagraph.c_str());
-    paragraph.paragraphPtr->LinkEndChild( textPtr );
+  TiXmlText *textPtr = new TiXmlText(strParagraph.c_str());
+  paragraph.paragraphPtr->LinkEndChild( textPtr );
 
-    return 0;
+  return 0;
 }
 
-int XML4NLP::GetInfoFromSentence(vector<const char *> &vecInfo, 
-        int paragraphIdx, 
-        int sentenceIdx, 
-        const char *attrName) const
-{
-    if (0 != CheckRange(paragraphIdx, sentenceIdx)) return -1;
-
-    const vector<Word_t> &words = m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words;
+int XML4NLP::GetInfoFromSentence(std::vector<const char *> & info,
+                                 int pid,
+                                 int sid,
+                                 const char *attribute_name) const {
+  if (0 != CheckRange(pid, sid)) return -1;
 
-    /*
-       if (vecInfo.size() != words.size())
-       {
-    //		cerr << "vecInfo's size does not equal to word num in the sentence, should resize() first" << endl;
+  const vector<Word> & words = document.paragraphs[pid].sentences[sid].words;
+  if (words[0].wordPtr->Attribute(attribute_name) == NULL) {
     return -1;
-    }
-    */
+  }
 
-    if (words[0].wordPtr->Attribute(attrName) == NULL)
-    {
-        //		cerr << "Attribute \"" << attrName << "\" does not exists in paragraph " << paragraphIdx
-        //			<< " sentence " << sentenceIdx << endl;
-        return -1;
-    }
+  info.resize(words.size());
+  for (int i = 0; i < words.size(); ++ i) {
+    info[i] = words[i].wordPtr->Attribute(attribute_name);
+  }
+  return 0;
+}
 
-    for (int i = 0; i < words.size(); ++i)
-    {
-        vecInfo.push_back(words[i].wordPtr->Attribute(attrName));
-        //vecInfo[i] = words[i].wordPtr->Attribute(attrName);
-    }
-    return 0;
+int XML4NLP::GetInfoFromSentence(std::vector<const char *> & info,
+                                 int global_sid,
+                                 const char *attribute_name) const {
+  int pid, sid;
+  if (0 != DecodeGlobalId(global_sid, pid, sid)) return -1;
+  return GetInfoFromSentence(info, pid, sid, attribute_name);
 }
 
-int XML4NLP::GetInfoFromSentence(vector<const char *> &vecInfo, int sentenceIdx, const char *attrName) const
-{
-    pair<int, int> paraIdx_sentIdx;
-    if (0 != MapGlobalSentIdx2paraIdx_sentIdx(sentenceIdx, paraIdx_sentIdx)) return -1;
 
-    const vector<Word_t> &words = m_document.paragraphs[paraIdx_sentIdx.first].sentences[paraIdx_sentIdx.second].words;
+int XML4NLP::GetInfoFromSentence(std::vector<std::string> &info,
+                                 int pid,
+                                 int sid,
+                                 const char* attribute_name) const {
+  if (0 != CheckRange(pid, sid)) return -1;
+
+  const vector<Word> & words = document.paragraphs[pid].sentences[sid].words;
 
-    /*
-       if (vecInfo.size() != words.size())
-       {
-    //		cerr << "vecInfo's size does not equal to word num in the sentence, should resize() first" << endl;
+  if (words[0].wordPtr->Attribute(attribute_name) == NULL) {
     return -1;
-    }
-    */
+  }
 
-    if (words[0].wordPtr->Attribute(attrName) == NULL)
-    {
-        //		cerr << "Attribute \"" << attrName << "\" does not exists in paragraph " << paraIdx_sentIdx.first
-        //			<< " sentence " << paraIdx_sentIdx.second << endl;
-        return -1;
-    }
+  info.clear();
+  for (int i = 0; i < words.size(); ++ i) {
+    const char * cszAttrValue = words[i].wordPtr->Attribute(attribute_name);
+    info.push_back(cszAttrValue != NULL ? cszAttrValue : "");
+  }
+  return 0;
+}
 
-    for (int i = 0; i < words.size(); ++i)
-    {
-        vecInfo.push_back(words[i].wordPtr->Attribute(attrName));
-        //vecInfo[i] = words[i].wordPtr->Attribute(attrName);
-    }
-    return 0;
+int XML4NLP::GetInfoFromSentence(std::vector<std::string> & info,
+                                 int global_sid,
+                                 const char* attribute_name) const {
+  int pid, sid;
+  if (0 != DecodeGlobalId(global_sid, pid, sid)) return -1;
 
+  return GetInfoFromSentence(info, pid, sid, attribute_name);
 }
 
+int XML4NLP::SetInfoToSentence(const std::vector<std::string> & info,
+                               int pid,
+                               int sid,
+                               const char* attribute_name) {
+  if (0 != CheckRange(pid, sid)) return -1;
 
-int XML4NLP::GetInfoFromSentence(vector<string> &vecInfo, int paragraphIdx, 
-        int sentenceIdx, const char* attrName) const
-{
-    if (0 != CheckRange(paragraphIdx, sentenceIdx)) return -1;
+  std::vector<Word> & words = document.paragraphs[pid].sentences[sid].words;
 
-    const vector<Word_t> &words = m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words;
+  if (words.size() != info.size()) {
+    return -1;
+  }
 
-    if (words[0].wordPtr->Attribute(attrName) == NULL)
-    {
-        //		cerr << "Attribute \"" << attrName << "\" does not exists in paragraph " << paragraphIdx
-        //			<< " sentence " << sentenceIdx << endl;
-        return -1;
-    }
+  if (words[0].wordPtr->Attribute(attribute_name) != NULL) {
+    return -1;
+  }
 
-    vecInfo.clear();
-    for (int i = 0; i < words.size(); ++i)
-    {
-        const char *cszAttrValue = words[i].wordPtr->Attribute(attrName);
-        vecInfo.push_back(cszAttrValue != NULL ? cszAttrValue : "");
-    }
-    return 0;
+  for (int i = 0; i < words.size(); ++ i) {
+    // std::cout << attribute_name << " " << info[i] << std::endl;
+    words[i].wordPtr->SetAttribute(attribute_name, info[i].c_str());
+  }
+  return 0;
 }
 
-int XML4NLP::GetInfoFromSentence(vector<string> &vecInfo, int sentenceIdx, const char* attrName) const
-{
-    pair<int, int> paraIdx_sentIdx;
-    if (0 != MapGlobalSentIdx2paraIdx_sentIdx(sentenceIdx, paraIdx_sentIdx)) return -1;
-
-    const vector<Word_t> &words = m_document.paragraphs[paraIdx_sentIdx.first].sentences[paraIdx_sentIdx.second].words;
+int XML4NLP::SetInfoToSentence(const std::vector<std::string> & info,
+                               int global_sid,
+                               const char * attribute_name) {
+  int pid, sid;
+  if (0 != DecodeGlobalId(global_sid, pid, sid)) return -1;
 
-    if (words[0].wordPtr->Attribute(attrName) == NULL)
-    {
-        //		cerr << "Attribute \"" << attrName << "\" does not exists in paragraph " << paraIdx_sentIdx.first
-        //			<< " sentence " << paraIdx_sentIdx.second << endl;
-        return -1;
-    }
-
-    vecInfo.clear();
-    for (int i = 0; i < words.size(); ++i)
-    {
-        const char *cszAttrValue = words[i].wordPtr->Attribute(attrName);
-        vecInfo.push_back(cszAttrValue != NULL ? cszAttrValue : "");
-    }
-    return 0;
+  return SetInfoToSentence(info, pid, sid, attribute_name);
 }
 
-int XML4NLP::SetInfoToSentence(const vector<string> &vecInfo, int paragraphIdx, 
-        int sentenceIdx, const char* attrName)
-{
-    if (0 != CheckRange(paragraphIdx, sentenceIdx)) return -1;
-
-    vector<Word_t> &words = m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words;
+int XML4NLP::SetInfoToSentence(const std::vector<int> & info,
+                               int pid,
+                               int sid,
+                               const char * attribute_name) {
+  if (0 != CheckRange(pid, sid)) return -1;
 
-    if (words.size() != vecInfo.size())
-    {
-        //		cerr << "word number does not equal to attribute \"" << attrName << "\" num in paragraph " << paragraphIdx
-        //			<< " sentence " << sentenceIdx << endl;
-        return -1;
-    }
-    if (words[0].wordPtr->Attribute(attrName) != NULL)
-    {
-        //		cerr << "Attribute \"" << attrName << "\" already exists in paragraph " << paragraphIdx
-        //			<< " sentence " << sentenceIdx << endl;
-        return -1;
-    }
+  std::vector<Word> & words = document.paragraphs[pid].sentences[sid].words;
 
-    for (int i = 0; i < words.size(); ++i)
-    {
-        words[i].wordPtr->SetAttribute(attrName, vecInfo[i].c_str());
-    }
-    return 0;
-}
+  if (words.size() != info.size()) {
+    return -1;
+  }
 
-int XML4NLP::SetInfoToSentence(const vector<string> &vecInfo, int sentenceIdx, const char* attrName)
-{
-    pair<int, int> paraIdx_sentIdx;
-    if (0 != MapGlobalSentIdx2paraIdx_sentIdx(sentenceIdx, paraIdx_sentIdx)) return -1;
-
-    vector<Word_t> &words = m_document.paragraphs[paraIdx_sentIdx.first].sentences[paraIdx_sentIdx.second].words;
-    if (words.size() != vecInfo.size())
-    {
-        //		cerr << "word number does not equal to attribute \"" << attrName << "\" num in paragraph " << paraIdx_sentIdx.first
-        //			<< " sentence " << paraIdx_sentIdx.second << endl;
-        return -1;
-    }
-    if (words[0].wordPtr->Attribute(attrName) != NULL)
-    {
-        //		cerr << "Attribute \"" << attrName << "\" already exists in paragraph " << paraIdx_sentIdx.first
-        //			<< " sentence " << paraIdx_sentIdx.second << endl;
-        return -1;
-    }
+  if (words[0].wordPtr->Attribute(attribute_name) != NULL) {
+    return -1;
+  }
 
-    for (int i = 0; i < words.size(); ++i)
-    {
-        words[i].wordPtr->SetAttribute(attrName, vecInfo[i].c_str());
-    }
-    return 0;
+  for (int i = 0; i < words.size(); ++ i) {
+    // std::cout << attribute_name << " " << info[i] << std::endl;
+    words[i].wordPtr->SetAttribute(attribute_name, info[i]);
+  }
+  return 0;
 }
 
-int XML4NLP::SetInfoToSentence(const vector<int> &vecInfo, int paragraphIdx, 
-        int sentenceIdx, const char* attrName)
-{
-    if (0 != CheckRange(paragraphIdx, sentenceIdx)) return -1;
-
-    vector<Word_t> &words = m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words;
+int XML4NLP::SetInfoToSentence(const std::vector<int> & info,
+                               int global_sid,
+                               const char * attribute_name) {
+  int pid, sid;
+  if (0 != DecodeGlobalId(global_sid, pid, sid)) return -1;
+  return SetInfoToSentence(info, pid, sid, attribute_name);
+}
 
-    if (words.size() != vecInfo.size())
-    {
-        //		cerr << "word number does not equal to attribute \"" << attrName << "\" num in paragraph " << paragraphIdx
-        //			<< " sentence " << sentenceIdx << endl;
-        return -1;
-    }
-    if (words[0].wordPtr->Attribute(attrName) != NULL)
-    {
-        //		cerr << "Attribute \"" << attrName << "\" already exists in paragraph " << paragraphIdx
-        //			<< " sentence " << sentenceIdx << endl;
-        return -1;
-    }
 
-    for (int i = 0; i < words.size(); ++i)
-    {
-        words[i].wordPtr->SetAttribute(attrName, vecInfo[i]);
-    }
-    return 0;
-}
+int XML4NLP::CheckRange(int pid, int sid, int wid) const {
+  if (pid >= document.paragraphs.size()) {
+    return -1;
+  }
 
-int XML4NLP::SetInfoToSentence(const vector<int> &vecInfo, int sentenceIdx, const char* attrName)
-{
-    pair<int, int> paraIdx_sentIdx;
-    if (0 != MapGlobalSentIdx2paraIdx_sentIdx(sentenceIdx, paraIdx_sentIdx)) return -1;
-
-    vector<Word_t> &words = m_document.paragraphs[paraIdx_sentIdx.first].sentences[paraIdx_sentIdx.second].words;
-    if (words.size() != vecInfo.size())
-    {
-        //		cerr << "word number does not equal to attribute \"" << attrName << "\" num in paragraph " << paraIdx_sentIdx.first
-        //			<< " sentence " << paraIdx_sentIdx.second << endl;
-        return -1;
-    }
-    if (words[0].wordPtr->Attribute(attrName) != NULL)
-    {
-        //		cerr << "Attribute \"" << attrName << "\" already exists in paragraph " << paraIdx_sentIdx.first
-        //			<< " sentence " << paraIdx_sentIdx.second << endl;
-        return -1;
-    }
+  if (sid >= document.paragraphs[pid].sentences.size()) {
+    return -1;
+  }
 
-    for (int i = 0; i < words.size(); ++i)
-    {
-        words[i].wordPtr->SetAttribute(attrName, vecInfo[i]);
-    }
-    return 0;
+  if (wid >= document.paragraphs[pid].sentences[sid].words.size()) {
+    return -1;
+  }
+  return 0;
 }
 
+int XML4NLP::CheckRange(int pid, int sid) const {
+  if (pid >= document.paragraphs.size()) {
+    return -1;
+  }
 
-int XML4NLP::CheckRange(int paragraphIdx, int sentenceIdx, int wordIdx) const
-{
-    if (paragraphIdx >= m_document.paragraphs.size())
-    {
-        //		cerr << "paragraphIdx is too large: " << paragraphIdx << endl;
-        return -1;
-    }
-    if (sentenceIdx >= m_document.paragraphs[paragraphIdx].sentences.size())
-    {
-        //		cerr << "sentenceIdx is too large: " << sentenceIdx << " in paragraph : " << paragraphIdx << endl;
-        return -1;
-    }
-    if (wordIdx >= m_document.paragraphs[paragraphIdx].sentences[sentenceIdx].words.size())
-    {
-        //		cerr << "wordIdx is too large: " << wordIdx << " in sentence : " << sentenceIdx
-        //			<< " of paragraph : " << paragraphIdx << endl;
-        return -1;
-    }
-    return 0;
-}
+  if (sid >= document.paragraphs[pid].sentences.size()) {
+    return -1;
+  }
 
-int XML4NLP::CheckRange(int paragraphIdx, int sentenceIdx) const
-{
-    if (paragraphIdx >= m_document.paragraphs.size())
-    {
-        //		cerr << "paragraphIdx is too large: " << paragraphIdx << endl;
-        return -1;
-    }
-    if (sentenceIdx >= m_document.paragraphs[paragraphIdx].sentences.size())
-    {
-        //		cerr << "sentenceIdx is too large: " << sentenceIdx << " in paragraph : " << paragraphIdx << endl;
-        return -1;
-    }
-    return 0;
+  return 0;
 }
 
 int XML4NLP::CheckRange(int paragraphIdx) const {
-    if (paragraphIdx >= m_document.paragraphs.size()) {
-        //		cerr << "paragraphIdx is too large: " << paragraphIdx << endl;
-        return -1;
-    }
-    return 0;
+  if (paragraphIdx >= document.paragraphs.size()) {
+    return -1;
+  }
+  return 0;
 }
 
 bool XML4NLP::QueryNote(const char *cszNoteName)  const {
-    if (m_note.nodePtr == NULL) return false; // OK?
+  if (note.nodePtr == NULL) return false; // OK?
 
-    return (strcmp(m_note.nodePtr->Attribute(cszNoteName), "y") == 0) ? true : false;
+  return (strcmp(note.nodePtr->Attribute(cszNoteName), "y") == 0) ? true : false;
 }
 
 int XML4NLP::SetNote(const char *cszNoteName) {
-    if (m_note.nodePtr == NULL) {
-        m_note.nodePtr = new TiXmlElement(TAG_NOTE);
-        m_tiXmlDoc.RootElement()->LinkEndChild( m_note.nodePtr );
-    }
-    m_note.nodePtr->SetAttribute(cszNoteName, "y");
-    return 0;
+  if (note.nodePtr == NULL) {
+    note.nodePtr = new TiXmlElement(TAG_NOTE);
+    m_tiXmlDoc.RootElement()->LinkEndChild( note.nodePtr );
+  }
+  note.nodePtr->SetAttribute(cszNoteName, "y");
+  return 0;
 }
 
 int XML4NLP::ClearNote(const char *cszNoteName) {
-    if (m_note.nodePtr == NULL) {
-        m_note.nodePtr = new TiXmlElement(TAG_NOTE);
-        m_tiXmlDoc.RootElement()->LinkEndChild( m_note.nodePtr );
-    }
+  if (note.nodePtr == NULL) {
+    note.nodePtr = new TiXmlElement(TAG_NOTE);
+    m_tiXmlDoc.RootElement()->LinkEndChild( note.nodePtr );
+  }
 
-    m_note.nodePtr->SetAttribute(cszNoteName, "n");
-    return 0;
+  note.nodePtr->SetAttribute(cszNoteName, "n");
+  return 0;
 }
 
-
diff --git a/src/__xml4nlp/Xml4nlp.h b/src/__xml4nlp/Xml4nlp.h
index 5aa0b6683..acbba30d2 100644
--- a/src/__xml4nlp/Xml4nlp.h
+++ b/src/__xml4nlp/Xml4nlp.h
@@ -41,788 +41,786 @@ extern const char * const NOTE_CR;
 /////////////////////////////////////////////////////////////////////////////////////
 class XML4NLP {
 public:
-    XML4NLP();
-    virtual ~XML4NLP();
-
-    // --------------------------------------------------------------
-    // Functions for DOM Tree Creation
-    // --------------------------------------------------------------
-    /*
-     * Create DOM from file, read in each line of the file and store
-     * them in the xml tree.
-     *
-     *  @param[in]  filename    the filename
-     */
-    int CreateDOMFromFile(const char * filename);
-
-    /*
-     * Create DOM from raw string text.
-     *
-     *  @param[in]  str         the string
-     *  @return     int         0 on success, otherwise -1
-     */
-    int CreateDOMFromString(const std::string & str);
-
-    /*
-     * A wrapper of CreateDOMFromString(const std::string & str);
-     *
-     *  @param[in]  str         the string
-     *  @return     int         0 on success, otherwise -1
-     */
-    int CreateDOMFromString(const char * str);
-
-    /*
-     * Load XML DOM from file
-     *
-     *  @param[in]  filename    the file name
-     *  @return     int         0 on success, otherwise -1
-     */
-    int LoadXMLFromFile(const char * fileName);
-
-    /*
-     * Load XML DOM from string
-     *
-     *  @param[in]  str         the string
-     *  @return     int         0 on success, otherwise -1
-     */
-    int LoadXMLFromString(const char * str);
-
-     /*
-     * Load XML DOM from string
-     *
-     *  @param[in]  str         the string
-     */
-    int LoadXMLFromString(const std::string & str);
-
-    /*
-     * Clear the DOM tree
-     */
-    void ClearDOM();
-
-    /*
-     * Save the DOM tree to file
-     *
-     *  @param[in]  filename    the filename
-     *  @return     int         0 on success, otherwise -1
-     */
-    int SaveDOM(const char * fileName);
-
-    /*
-     * Save the DOM tree to strin
-     *
-     *  @param[out] strDocument the str
-     */
-    void SaveDOM(string &strDocument) const;
-
-    /*
-     * Get attributes value in `<note/>`
-     *
-     *  @param[in]  cszNoteName the note name
-     *  @return     bool        return true on `<note/>` exists and 
-     *                          attributes value equals "y", otherwise
-     *                          false.
-     */
-    bool QueryNote(const char * cszNoteName) const;
-
-    /*
-     * Set attributes value in `<note/>` to "y"
-     *
-     *  @param[in]  cszNoteName the note name
-     *  @return     int         return 0
-     */
-    int SetNote(const char * cszNoteName);
-
-    /*
-     * Set attributes value in `<note/>` to "n"
-     *
-     *  @param[in]  cszNoteName the note name
-     *  @return     int         return 0
-     */
-    int ClearNote(const char * cszNoteName);
-
-    /*
-     * Set all nlp attributes value in `<note/>` to "n"
-     *
-     *  @param[in]  cszNoteName the note name
-     *  @return     int         return 0
-     */
-    void ClearAllNote();
-
-    // counting operation
-    /*
-     * count number of paragraph in document
-     *
-     *  @return     int     the number of paragraph
-     */
-    int CountParagraphInDocument() const;
-
-    /*
-     * conut number of sentence in paragraph
-     *
-     *  @param[in]  pid    the index number of paragraph
-     *  @return     int             the number of paragraph
-     */
-    int CountSentenceInParagraph(int pid) const;
-
-    /*
-     * count number of all sentences in document
-     *
-     *  @return     int     the number of all sentences in document
-     */
-    int CountSentenceInDocument() const;
-
-    /*
-     * Count number of words in sentence, given the index of paragraph
-     * and index of sentence.
-     *
-     *  @param[in]  pid     the index of paragraph
-     *  @param[in]  sid     the index of sentence
-     *  @return     int
-     */
-    int CountWordInSentence(int pid, int sid) const;
-
-    /*
-     * Count number of words in sentence, given the global index
-     * of the sentence
-     *
-     *  @param[in]  global_sid      the global index of a sentence
-     *  @return     int             number of sentence
-     */
-    int CountWordInSentence(int global_sid) const;
-
-    /*
-     * Count number of words in paragraph
-     *
-     *  @param[in]  pid         the index of paragraph
-     *  @return     int         number of words in paragraph if legal
-     *                          pid is given, otherwise -1
-     */
-    int CountWordInParagraph(int pid) const;
-
-    /*
-     * Count total number of words in paragraph
-     *
-     *  @return     int         number of words
-     */
-    int CountWordInDocument() const;
-
-    /*
-     * Get content of paragraph and store it in string
-     *
-     *  @param[in]  pid             the index of paragraph
-     *  @param[out] strParagraph    the output string
-     *  @return     int             0 on success, otherwise -1
-     */
-    int GetParagraph(int pid, string & strParagraph) const;
-
-    /*
-     * Get content of paragraph
-     *
-     *  @param[in]  pid             the index of paragraph
-     *  @return     const char *    the pointer to the string, NULL on failure
-     */
-    const char * GetParagraph(int pid) const;
-
-    /*
-     * Get content of sentence
-     *
-     *  @param[in]  pid             the index of paragraph
-     *  @param[in]  sid             the index of sentence
-     *  @return     const char *    the pointer to the string, NULL on failure
-     */
-    const char * GetSentence(int pid, int sid) const;
-
-    /*
-     * Get content of sentence, given the sentence's global index
-     *
-     *  @param[in]  global_sid      the global index of the sentence
-     *  @return     const char *    the pointer to the string, NULL on failure
-     */
-    const char * GetSentence(int global_sid) const;
-
-    /*
-     * Get word content
-     *
-     *  @param[in]  pid             the index of paragraph in document
-     *  @param[in]  sid             the index of sentence in paragraph
-     *  @param[in]  wid             the index of word in sentence
-     *  @return     const char *    the pointer to the string, NULL on failure
-     */
-    const char * GetWord(int pid, int sid, int wid) const;
-
-    /*
-     * Get word content, given the global sentence index
-     *
-     *  @param[in]  global_sid      the global index of the sentence
-     *  @param[in]  wid             the index of word in sentence
-     *  @return     const char *    the pointer to the string, NULL on failure
-     */
-    const char * GetWord(int global_sid, int wid) const;
-
-    /*
-     * Get word content, given the global index of word
-     *
-     *  @param[in]  global_wid      the global index of the sentence
-     *  @return     const char *    the pointer to the string, NULL on failure
-     */
-    const char * GetWord(int glabal_wid) const;
-
-    /*
-     * Get word's postag
-     *
-     *  @param[in]  pid             the index of paragraph
-     *  @param[in]  sid             the index of sentence
-     *  @param[in]  wid             the index of word
-     *  @return     const char *    the pointer to the string, NULL on failure.
-     */
-    const char * GetPOS(int pid, int sid, int wid) const;
-
-    /*
-     * Get word's postag
-     *
-     *  @param[in]  global_sid      the global index of sentence
-     *  @param[in]  wid             the index of the word
-     *  @return     const char *    the pointer to the string, NULL on failure.
-     */
-    const char * GetPOS(int global_sid, int wid) const;
-
-    /*
-     * Get word's postag, given the global index of the word in the document.
-     *
-     *  @param[in]  global_wid      the global index of the word.
-     *  @return     const char *    the pointer to the string, NULL on failure.
-     */
-    const char * GetPOS(int global_wid) const;
-
-    /*
-     * Get word's NER tag
-     *
-     *  @param[in]  pid             the index of paragraph
-     *  @param[in]  sid             the index of sentence
-     *  @param[in]  wid             the index of word
-     *  @return     const char *    the pointer to the tag, NULL on failure.
-     */
-    const char * GetNE(int pid, int sid, int wid) const;
-
-    /*
-     * Get word's NER tag, given the global index of sentence in the document.
-     *
-     *  @param[in]  global_sid      the global index of sentence
-     *  @param[in]  wid             the index of the word
-     *  @return     const char *    the pointer to the tag, NULL on failure.
-     */
-    const char * GetNE(int global_sid, int wid) const;
-
-    /*
-     * Get word's NER, given the global index of the word in the document.
-     *
-     *  @param[in]  global_wid      the global index of the word.
-     *  @return     const char *    the pointer to the string, NULL on failure.
-     */
-    const char * GetNE(int glabalWordIdx) const;
-
-    /*
-     * Get word's WSD result (WSD module is under construction)
-     *
-     *  @param[out] WSD_explanation the explanation of the WSD
-     *  @param[in]  pid             the index of paragraph
-     *  @param[in]  sid             the index of sentence
-     *  @param[in]  wid             the index of word
-     *  @return     int             0 on success, otherwise -1
-     */
-    int GetWSD(pair<const char *, const char *> & WSD_explanation,
-            int pid,
-            int sid,
-            int wid) const;
-
-    /*
-     * Get word's WSD result (WSD module is under construction)
-     *
-     *  @param[out] WSD_explanation the explanation of the WSD
-     *  @param[in]  global_sid      the global index of sentence
-     *  @param[in]  wid             the index of the word
-     *  @return     int             0 on success, -1 on illegal index
-     */
-    int GetWSD(pair<const char *, const char *> & WSD_explanation,
-            int global_sid,
-            int wid) const;
-
-    /*
-     * Get word's WSD result (WSD module is under construction)
-     *
-     *  @param[out] WSD_explanation the explanation of the WSD
-     *  @param[in]  global_wid      the global index of sentence
-     *  @return     int             0 on success, -1 on illegal index
-     */
-    int GetWSD(pair<const char *, const char *> & WSD_explanation,
-            int global_wid) const;
-
-    /*
-     * Get word's parsing result
-     *
-     *  @param[out] parent_relation the (parent, relation) pair
-     *  @param[in]  pid             the index of paragraph
-     *  @param[in]  sid             the index of sentence
-     *  @param[in]  wid             the index of word
-     *  @return     int             0 on success, -1 on illegal index
-     */
-    int GetParse(pair<int, const char *> & parent_relation, 
-            int pid, 
-            int sid, 
-            int wid) const;
-
-    /*
-     * Get word's parsing result
-     *
-     *  @param[out] parent_relation the (parent, relation) pair
-     *  @param[in]  global_sid      the global index of sentence
-     *  @param[in]  wid             the index of the word
-     *  @return     int             0 on success, -1 on illegal index
-     */
-    int GetParse(pair<int, const char *> & parent_relation, 
-            int global_sid, 
-            int wid) const;
-
-    /*
-     * Get word's parsing result
-     *
-     *  @param[out] parent_relation the (parent, relation) pair
-     *  @param[in]  global_wid      the global index of sentence
-     *  @return     int             0 on success, -1 on illegal index
-     */
-    int GetParse(pair<int, const char *> &parent_relation, 
-            int glabal_wid) const;
-
-    /*
-     * Get sentences from paragraph
-     *
-     *  @param[out] vecSentence     the output vector
-     *  @param[in]  paragraphIdx    the index to the paragraph
-     */
-    int GetSentencesFromParagraph(vector<const char *> & vecSentence, 
-            int paragraphIdx) const;
-
-    /*
-     * Get sentences from paragraph
-     *
-     *  @param[out] vectSentence    the output vector
-     *  @param[in]  paragraphIdx    the index to the paragraph
-     */
-    int GetSentencesFromParagraph(vector<string> &vecSents, 
-            int paragraphIdx) const;
-
-    int SetSentencesToParagraph(const vector<string> &vecSents,
-            int paragraphIdx);
-
-    /*
-     * Get words from sentence
-     *
-     *  @param[out] vecWord         the word vector
-     *  @param[in]  paragraphIdx    the index of paragraph
-     *  @param[in]  sentenceIdx     the index of sentence
-     */
-    int GetWordsFromSentence(vector<const char *> &vecWord,
-            int paragraphIdx,
-            int sentenceIdx) const;
-
-    /*
-     * Get words from sentence
-     *
-     *  @param[out] vecWord         the word vector
-     *  @param[in]  globalSentIdx   the global index of sentence
-     */
-    int GetWordsFromSentence(vector<const char *> &vecWord, 
-            int globalSentIdx) const;
-
-    /*
-     * Get words from sentence, std::string interface
-     *
-     *  @param[out] vecWord         the word vector
-     *  @param[in]  paragraphIdx    the index of paragraph
-     *  @param[in]  sentenceIdx     the index of sentence
-     */
-    int GetWordsFromSentence(vector<string> &vecWord, 
-            int paragraphIdx, 
-            int sentenceIdx) const;
-
-    /*
-     * Get words from sentence, std::string interface
-     *
-     *  @param[out] vecWord         the word vector
-     *  @param[in]  globalSentIdx   the global index of sentence
-     */
-    int GetWordsFromSentence(vector<string> &vecWord, 
-            int globalSentIdx) const;
-
-    /*
-     * Set word to sentence
-     *
-     *  @param[in]  vecWord         the words
-     *  @param[in]  paragraphIdx    the index of paragraph
-     *  @param[in]  sentenceIdx     the index of sentence
-     */
-    int SetWordsToSentence(const vector<string> &vecWord, 
-            int paragraphIdx, 
-            int sentenceIdx);
-
-    /*
-     * Set word to sentence
-     *
-     *  @param[in]  vecWord         the words
-     *  @param[in]  sentenceIdx     the global index of sentence
-     */
-    int SetWordsToSentence(const vector<string> &vecWord, 
-            int sentenceIdx);
-
-    // for POS tagging
-    int GetPOSsFromSentence(vector<const char *> & vecPOS,
-            int paragraphIdx, 
-            int sentenceIdx) const;
-
-    int GetPOSsFromSentence(vector<const char *> & vecPOS, 
-            int globalSentIdx) const;
-
-    int GetPOSsFromSentence(vector<string> & vecPOS,
-            int paragraphIdx, 
-            int sentenceIdx) const;
-
-    int GetPOSsFromSentence(vector<string> & vecPOS, 
-            int globalSentIdx) const;
-
-    int SetPOSsToSentence(const vector<string> & vecPOS, 
-            int paragraphIdx,
-            int sentenceIdx);
-
-    int SetPOSsToSentence(const vector<string> & vecPOS, 
-            int sentenceIdx);
-
-    // for NE
-    int GetNEsFromSentence(vector<const char *> &vecNE, 
-            int paragraphIdx, 
-            int sentenceIdx) const;
-
-    int GetNEsFromSentence(vector<const char *> &vecNE, 
-            int globalSentIdx) const;
-
-    int GetNEsFromSentence(vector<string> &vecNE, 
-            int paragraphIdx, 
-            int sentenceIdx) const;
-
-    int GetNEsFromSentence(vector<string> &vecNE, 
-            int globalSentIdx) const;
-
-    int SetNEsToSentence(const vector<string> &vecNE, 
-            int paragraphIdx, 
-            int sentenceIdx);
-
-    int SetNEsToSentence(const vector<string> &vecNE, 
-            int sentenceIdx);
-
-    int GetWSDsFromSentence(vector<const char *> &vecWSD, 
-            int paragraphIdx, 
-            int sentenceIdx) const;
-
-    int GetWSDsFromSentence(vector<const char *> &vecWSD, 
-            int sentenceIdx) const;
-
-    int GetWSDsFromSentence(vector<string> &vecWSD, 
-            int paragraphIdx, 
-            int sentenceIdx) const;
-
-    int GetWSDsFromSentence(vector<string> &vecWSD, 
-            int sentenceIdx) const;
-
-    int SetWSDsToSentence(const vector<string> &vecWSD, 
-            int paragraphIdx, 
-            int sentenceIdx);
-
-    int SetWSDsToSentence(const vector<string> & vecWSD, 
-            int sentenceIdx);
-
-    int GetWSDExplainsFromSentence(vector<const char *> &vecWSDExplain, 
-            int paragraphIdx, 
-            int sentenceIdx) const;
-
-    int GetWSDExplainsFromSentence(vector<const char *> &vecWSDExplain, 
-            int sentenceIdx) const;
-
-    int GetWSDExplainsFromSentence(vector<string> &vecWSDExplain, 
-            int paragraphIdx, 
-            int sentenceIdx) const;
-
-    int GetWSDExplainsFromSentence(vector<string> &vecWSDExplain, 
-            int sentenceIdx) const;
-
-    int SetWSDExplainsToSentence(const vector<string> &vecWSDExplain, 
-            int paragraphIdx,
-            int sentenceIdx);
+  XML4NLP();
+  virtual ~XML4NLP();
+
+  // --------------------------------------------------------------
+  // Functions for DOM Tree Creation
+  // --------------------------------------------------------------
+  /*
+   * Create DOM from file, read in each line of the file and store
+   * them in the xml tree.
+   *
+   *  @param[in]  filename  the filename
+   */
+  int CreateDOMFromFile(const char * filename);
+
+  /*
+   * Create DOM from raw string text.
+   *
+   *  @param[in]  str     the string
+   *  @return     int     0 on success, otherwise -1
+   */
+  int CreateDOMFromString(const std::string & str);
+
+  /*
+   * A wrapper of CreateDOMFromString(const std::string & str);
+   *
+   *  @param[in]  str     the string
+   *  @return     int     0 on success, otherwise -1
+   */
+  int CreateDOMFromString(const char * str);
+
+  /*
+   * Load XML DOM from file
+   *
+   *  @param[in]  filename  the file name
+   *  @return     int     0 on success, otherwise -1
+   */
+  int LoadXMLFromFile(const char * fileName);
+
+  /*
+   * Load XML DOM from string
+   *
+   *  @param[in]  str     the string
+   *  @return     int     0 on success, otherwise -1
+   */
+  int LoadXMLFromString(const char * str);
+
+   /*
+   * Load XML DOM from string
+   *
+   *  @param[in]  str     the string
+   */
+  int LoadXMLFromString(const std::string & str);
+
+  /*
+   * Clear the DOM tree
+   */
+  void ClearDOM();
+
+  /*
+   * Save the DOM tree to file
+   *
+   *  @param[in]  filename  the filename
+   *  @return   int     0 on success, otherwise -1
+   */
+  int SaveDOM(const char * fileName);
+
+  /*
+   * Save the DOM tree to strin
+   *
+   *  @param[out] strDocument the str
+   */
+  void SaveDOM(string &strDocument) const;
+
+  /*
+   * Get attributes value in `<note/>`
+   *
+   *  @param[in]  note_name   the name of the attribute in note
+   *  @return     bool        return true on `<note/>` exists and attributes
+   *                          value equals "y", otherwise false.
+   */
+  bool QueryNote(const char * note_name) const;
+
+  /*
+   * Set attributes value in `<note/>` to "y"
+   *
+   *  @param[in]  note_name   the name of the attribute in note
+   *  @return     int         return 0
+   */
+  int SetNote(const char * note_name);
+
+  /*
+   * Set attributes value in `<note/>` to "n"
+   *
+   *  @param[in]  cszNoteName the note name
+   *  @return   int     return 0
+   */
+  int ClearNote(const char * note_name);
+
+  /*
+   * Set all nlp attributes value in `<note/>` to "n"
+   *
+   *  @param[in]  cszNoteName the note name
+   *  @return   int     return 0
+   */
+  void ClearAllNote();
+
+  // counting operation
+  /*
+   * count number of paragraph in document
+   *
+   *  @return   int   the number of paragraph
+   */
+  int CountParagraphInDocument() const;
+
+  /*
+   * conut number of sentence in paragraph
+   *
+   *  @param[in]  pid  the index number of paragraph
+   *  @return   int       the number of paragraph
+   */
+  int CountSentenceInParagraph(int pid) const;
+
+  /*
+   * count number of all sentences in document
+   *
+   *  @return   int   the number of all sentences in document
+   */
+  int CountSentenceInDocument() const;
+
+  /*
+   * Count number of words in sentence, given the index of paragraph
+   * and index of sentence.
+   *
+   *  @param[in]  pid   the index of paragraph
+   *  @param[in]  sid   the index of sentence
+   *  @return     int
+   */
+  int CountWordInSentence(int pid, int sid) const;
+
+  /*
+   * Count number of words in sentence, given the global index
+   * of the sentence
+   *
+   *  @param[in]  global_sid    the global index of a sentence
+   *  @return     int           number of sentence
+   */
+  int CountWordInSentence(int global_sid) const;
+
+  /*
+   * Count number of words in paragraph
+   *
+   *  @param[in]  pid     the index of paragraph
+   *  @return     int     number of words in paragraph if legal
+   *                      pid is given, otherwise -1
+   */
+  int CountWordInParagraph(int pid) const;
+
+  /*
+   * Count total number of words in paragraph
+   *
+   *  @return   int     number of words
+   */
+  int CountWordInDocument() const;
+
+  /*
+   * Get content of paragraph and store it in string
+   *
+   *  @param[in]  pid           the index of paragraph
+   *  @param[out] strParagraph  the output string
+   *  @return     int           0 on success, otherwise -1
+   */
+  int GetParagraph(int pid, string & strParagraph) const;
+
+  /*
+   * Get content of paragraph
+   *
+   *  @param[in]  pid           the index of paragraph
+   *  @return     const char *  the pointer to the string, NULL on failure
+   */
+  const char * GetParagraph(int pid) const;
+
+  /*
+   * Get content of sentence
+   *
+   *  @param[in]  pid           the index of paragraph
+   *  @param[in]  sid           the index of sentence
+   *  @return     const char *  the pointer to the string, NULL on failure
+   */
+  const char * GetSentence(int pid, int sid) const;
+
+  /*
+   * Get content of sentence, given the sentence's global index
+   *
+   *  @param[in]  global_sid    the global index of the sentence
+   *  @return   const char *  the pointer to the string, NULL on failure
+   */
+  const char * GetSentence(int global_sid) const;
+
+  /*
+   * Get word content
+   *
+   *  @param[in]  pid           the index of paragraph in document
+   *  @param[in]  sid           the index of sentence in paragraph
+   *  @param[in]  wid           the index of word in sentence
+   *  @return     const char *  the pointer to the string, NULL on failure
+   */
+  const char * GetWord(int pid, int sid, int wid) const;
+
+  /*
+   * Get word content, given the global sentence index
+   *
+   *  @param[in]  global_sid    the global index of the sentence
+   *  @param[in]  wid           the index of word in sentence
+   *  @return     const char *  the pointer to the string, NULL on failure
+   */
+  const char * GetWord(int global_sid, int wid) const;
+
+  /*
+   * Get word content, given the global index of word
+   *
+   *  @param[in]  global_wid    the global index of the sentence
+   *  @return     const char *  the pointer to the string, NULL on failure
+   */
+  const char * GetWord(int glabal_wid) const;
+
+  /*
+   * Get word's postag
+   *
+   *  @param[in]  pid           the index of the paragraph
+   *  @param[in]  sid           the index of the sentence
+   *  @param[in]  wid           the index of the word
+   *  @return     const char *  the pointer to the string, NULL on failure.
+   */
+  const char * GetPOS(int pid, int sid, int wid) const;
+
+  /*
+   * Get word's postag
+   *
+   *  @param[in]  global_sid    the global index of sentence
+   *  @param[in]  wid       the index of the word
+   *  @return   const char *  the pointer to the string, NULL on failure.
+   */
+  const char * GetPOS(int global_sid, int wid) const;
+
+  /*
+   * Get word's postag, given the global index of the word in the document.
+   *
+   *  @param[in]  global_wid    the global index of the word.
+   *  @return   const char *  the pointer to the string, NULL on failure.
+   */
+  const char * GetPOS(int global_wid) const;
+
+  /*
+   * Get word's NER tag
+   *
+   *  @param[in]  pid       the index of paragraph
+   *  @param[in]  sid       the index of sentence
+   *  @param[in]  wid       the index of word
+   *  @return   const char *  the pointer to the tag, NULL on failure.
+   */
+  const char * GetNE(int pid, int sid, int wid) const;
+
+  /*
+   * Get word's NER tag, given the global index of sentence in the document.
+   *
+   *  @param[in]  global_sid    the global index of sentence
+   *  @param[in]  wid       the index of the word
+   *  @return   const char *  the pointer to the tag, NULL on failure.
+   */
+  const char * GetNE(int global_sid, int wid) const;
+
+  /*
+   * Get word's NER, given the global index of the word in the document.
+   *
+   *  @param[in]  global_wid    the global index of the word.
+   *  @return   const char *  the pointer to the string, NULL on failure.
+   */
+  const char * GetNE(int glabalWordIdx) const;
+
+  /*
+   * Get word's WSD result (WSD module is under construction)
+   *
+   *  @param[out] WSD_explanation the explanation of the WSD
+   *  @param[in]  pid       the index of paragraph
+   *  @param[in]  sid       the index of sentence
+   *  @param[in]  wid       the index of word
+   *  @return   int       0 on success, otherwise -1
+   */
+  int GetWSD(pair<const char *, const char *> & WSD_explanation,
+      int pid,
+      int sid,
+      int wid) const;
+
+  /*
+   * Get word's WSD result (WSD module is under construction)
+   *
+   *  @param[out] WSD_explanation the explanation of the WSD
+   *  @param[in]  global_sid    the global index of sentence
+   *  @param[in]  wid       the index of the word
+   *  @return   int       0 on success, -1 on illegal index
+   */
+  int GetWSD(pair<const char *, const char *> & WSD_explanation,
+      int global_sid,
+      int wid) const;
+
+  /*
+   * Get word's WSD result (WSD module is under construction)
+   *
+   *  @param[out] WSD_explanation the explanation of the WSD
+   *  @param[in]  global_wid      the global index of sentence
+   *  @return     int             0 on success, -1 on illegal index
+   */
+  int GetWSD(pair<const char *, const char *> & WSD_explanation,
+      int global_wid) const;
+
+  /*
+   * Get word's parsing result
+   *
+   *  @param[out] parent_relation the (parent, relation) pair
+   *  @param[in]  pid       the index of paragraph
+   *  @param[in]  sid       the index of sentence
+   *  @param[in]  wid       the index of word
+   *  @return   int       0 on success, -1 on illegal index
+   */
+  int GetParse(pair<int, const char *> & parent_relation,
+      int pid,
+      int sid,
+      int wid) const;
+
+  /*
+   * Get word's parsing result
+   *
+   *  @param[out] parent_relation the (parent, relation) pair
+   *  @param[in]  global_sid    the global index of sentence
+   *  @param[in]  wid       the index of the word
+   *  @return   int       0 on success, -1 on illegal index
+   */
+  int GetParse(pair<int, const char *> & parent_relation,
+      int global_sid,
+      int wid) const;
+
+  /*
+   * Get word's parsing result
+   *
+   *  @param[out] parent_relation the (parent, relation) pair
+   *  @param[in]  global_wid    the global index of sentence
+   *  @return   int       0 on success, -1 on illegal index
+   */
+  int GetParse(pair<int, const char *> &parent_relation,
+      int glabal_wid) const;
+
+  /*
+   * Get sentences from paragraph
+   *
+   *  @param[out] vecSentence   the output vector
+   *  @param[in]  paragraphIdx  the index to the paragraph
+   */
+  int GetSentencesFromParagraph(vector<const char *> & vecSentence,
+      int paragraphIdx) const;
+
+  /*
+   * Get sentences from paragraph
+   *
+   *  @param[out] vectSentence  the output vector
+   *  @param[in]  paragraphIdx  the index to the paragraph
+   */
+  int GetSentencesFromParagraph(vector<string> &vecSents,
+      int paragraphIdx) const;
+
+  int SetSentencesToParagraph(const vector<string> &vecSents,
+      int paragraphIdx);
+
+  /*
+   * Get words from sentence
+   *
+   *  @param[out] vecWord     the word vector
+   *  @param[in]  paragraphIdx  the index of paragraph
+   *  @param[in]  sentenceIdx   the index of sentence
+   */
+  int GetWordsFromSentence(vector<const char *> &vecWord,
+      int paragraphIdx,
+      int sentenceIdx) const;
+
+  /*
+   * Get words from sentence
+   *
+   *  @param[out] vecWord     the word vector
+   *  @param[in]  globalSentIdx   the global index of sentence
+   */
+  int GetWordsFromSentence(vector<const char *> &vecWord,
+      int globalSentIdx) const;
+
+  /*
+   * Get words from sentence, std::string interface
+   *
+   *  @param[out] vecWord     the word vector
+   *  @param[in]  paragraphIdx  the index of paragraph
+   *  @param[in]  sentenceIdx   the index of sentence
+   */
+  int GetWordsFromSentence(vector<string> &vecWord,
+      int paragraphIdx,
+      int sentenceIdx) const;
+
+  /*
+   * Get words from sentence, std::string interface
+   *
+   *  @param[out] vecWord     the word vector
+   *  @param[in]  globalSentIdx   the global index of sentence
+   */
+  int GetWordsFromSentence(vector<string> &vecWord,
+      int globalSentIdx) const;
+
+  /*
+   * Set word to sentence
+   *
+   *  @param[in]  vecWord     the words
+   *  @param[in]  paragraphIdx  the index of paragraph
+   *  @param[in]  sentenceIdx   the index of sentence
+   */
+  int SetWordsToSentence(const vector<string> &vecWord,
+      int paragraphIdx,
+      int sentenceIdx);
+
+  /*
+   * Set word to sentence
+   *
+   *  @param[in]  vecWord     the words
+   *  @param[in]  sentenceIdx   the global index of sentence
+   */
+  int SetWordsToSentence(const vector<string> &vecWord,
+      int sentenceIdx);
+
+  // for POS tagging
+  int GetPOSsFromSentence(vector<const char *> & vecPOS,
+      int paragraphIdx,
+      int sentenceIdx) const;
+
+  int GetPOSsFromSentence(vector<const char *> & vecPOS,
+      int globalSentIdx) const;
+
+  int GetPOSsFromSentence(vector<string> & vecPOS,
+      int paragraphIdx,
+      int sentenceIdx) const;
+
+  int GetPOSsFromSentence(vector<string> & vecPOS,
+      int globalSentIdx) const;
+
+  int SetPOSsToSentence(const vector<string> & vecPOS,
+      int paragraphIdx,
+      int sentenceIdx);
+
+  int SetPOSsToSentence(const vector<string> & vecPOS,
+      int sentenceIdx);
+
+  // for NE
+  int GetNEsFromSentence(vector<const char *> &vecNE,
+      int paragraphIdx,
+      int sentenceIdx) const;
+
+  int GetNEsFromSentence(vector<const char *> &vecNE,
+      int globalSentIdx) const;
+
+  int GetNEsFromSentence(vector<string> &vecNE,
+      int paragraphIdx,
+      int sentenceIdx) const;
+
+  int GetNEsFromSentence(vector<string> &vecNE,
+      int globalSentIdx) const;
+
+  int SetNEsToSentence(const vector<string> &vecNE,
+      int paragraphIdx,
+      int sentenceIdx);
+
+  int SetNEsToSentence(const vector<string> &vecNE,
+      int sentenceIdx);
+
+  int GetWSDsFromSentence(vector<const char *> &vecWSD,
+      int paragraphIdx,
+      int sentenceIdx) const;
+
+  int GetWSDsFromSentence(vector<const char *> &vecWSD,
+      int sentenceIdx) const;
+
+  int GetWSDsFromSentence(vector<string> &vecWSD,
+      int paragraphIdx,
+      int sentenceIdx) const;
+
+  int GetWSDsFromSentence(vector<string> &vecWSD,
+      int sentenceIdx) const;
+
+  int SetWSDsToSentence(const vector<string> &vecWSD,
+      int paragraphIdx,
+      int sentenceIdx);
+
+  int SetWSDsToSentence(const vector<string> & vecWSD,
+      int sentenceIdx);
+
+  int GetWSDExplainsFromSentence(vector<const char *> &vecWSDExplain,
+      int paragraphIdx,
+      int sentenceIdx) const;
+
+  int GetWSDExplainsFromSentence(vector<const char *> &vecWSDExplain,
+      int sentenceIdx) const;
+
+  int GetWSDExplainsFromSentence(vector<string> &vecWSDExplain,
+      int paragraphIdx,
+      int sentenceIdx) const;
+
+  int GetWSDExplainsFromSentence(vector<string> &vecWSDExplain,
+      int sentenceIdx) const;
+
+  int SetWSDExplainsToSentence(const vector<string> &vecWSDExplain,
+      int paragraphIdx,
+      int sentenceIdx);
 
-    int SetWSDExplainsToSentence(const vector<string> &vecWSDExplain, 
-            int sentenceIdx);
+  int SetWSDExplainsToSentence(const vector<string> &vecWSDExplain,
+      int sentenceIdx);
 
-    // for Parser
-    int GetParsesFromSentence(vector< pair<int, const char *> > &vecParse,
-            int paragraphIdx,
-            int sentenceIdx) const;
+  // for Parser
+  int GetParsesFromSentence(vector< pair<int, const char *> > &vecParse,
+      int paragraphIdx,
+      int sentenceIdx) const;
 
-    int GetParsesFromSentence(vector< pair<int, const char *> > &vecParse,
-            int sentenceIdx) const;
+  int GetParsesFromSentence(vector< pair<int, const char *> > &vecParse,
+      int sentenceIdx) const;
 
-    int GetParsesFromSentence(vector< pair<int, string> > &vecParse,
-            int paragraphIdx, 
-            int sentenceIdx) const;
+  int GetParsesFromSentence(vector< pair<int, string> > &vecParse,
+      int paragraphIdx,
+      int sentenceIdx) const;
 
-    int GetParsesFromSentence(vector< pair<int, string> > &vecParse, 
-            int sentenceIdx) const;
+  int GetParsesFromSentence(vector< pair<int, string> > &vecParse,
+      int sentenceIdx) const;
 
-    int SetParsesToSentence(const vector< pair<int, string> > &vecParse, 
-            int paragraphIdx,
-            int sentenceIdx);
+  int SetParsesToSentence(const vector< pair<int, string> > &vecParse,
+      int paragraphIdx,
+      int sentenceIdx);
 
-    int SetParsesToSentence(const vector< pair<int, string> > &vecParse, 
-            int sentenceIdx);
+  int SetParsesToSentence(const vector< pair<int, string> > &vecParse,
+      int sentenceIdx);
 
-    int SetParsesToSentence(const vector<int> &vecHead, 
-            const vector<string> &vecRel, 
-            int paragraphIdx,
-            int sentenceIdx);
+  int SetParsesToSentence(const vector<int> &vecHead,
+      const vector<string> &vecRel,
+      int paragraphIdx,
+      int sentenceIdx);
 
-    int SetParsesToSentence(const vector<int> &vecHead, 
-            const vector<string> &vecRel, 
-            int sentenceIdx);
+  int SetParsesToSentence(const vector<int> &vecHead,
+      const vector<string> &vecRel,
+      int sentenceIdx);
 
-    // for text summarization
-    const char* GetTextSummary() const;
-    int SetTextSummary(const char* textSum);
+  // for text summarization
+  const char* GetTextSummary() const;
+  int SetTextSummary(const char* textSum);
 
-    // for text classification
-    const char* GetTextClass() const;
-    int SetTextClass(const char* textClass);
+  // for text classification
+  const char* GetTextClass() const;
+  int SetTextClass(const char* textClass);
 
-    // for SRL
-    int CountPredArgToWord(int paragraphIdx, 
-            int sentenceIdx, 
-            int wordIdx) const;
+  // for SRL
+  int CountPredArgToWord(int paragraphIdx,
+      int sentenceIdx,
+      int wordIdx) const;
 
-    int CountPredArgToWord(int globalSentIdx, 
-            int wordIdx) const;
+  int CountPredArgToWord(int globalSentIdx,
+      int wordIdx) const;
 
-    int CountPredArgToWord(int globalWordIdx) const;
+  int CountPredArgToWord(int globalWordIdx) const;
 
-    int GetPredArgToWord(int paragraphIdx, 
-            int sentenceIdx, 
-            int wordIdx,
-            vector<const char *> &vecType, 
-            vector< pair<int, int> > &vecBegEnd) const;
+  int GetPredArgToWord(int paragraphIdx,
+      int sentenceIdx,
+      int wordIdx,
+      vector<const char *> &vecType,
+      vector< pair<int, int> > &vecBegEnd) const;
 
-    int GetPredArgToWord(int globalSentIdx,
-            int wordIdx,
-            vector<const char *> &vecType, 
-            vector< pair<int, int> > &vecBegEnd) const;
+  int GetPredArgToWord(int globalSentIdx,
+      int wordIdx,
+      vector<const char *> &vecType,
+      vector< pair<int, int> > &vecBegEnd) const;
 
-    int GetPredArgToWord(int globalWordIdx,
-            vector<const char *> &vecType, 
-            vector< pair<int, int> > &vecBegEnd) const;
+  int GetPredArgToWord(int globalWordIdx,
+      vector<const char *> &vecType,
+      vector< pair<int, int> > &vecBegEnd) const;
 
-    int GetPredArgToWord(int paragraphIdx,
-            int sentenceIdx,
-            int wordIdx, 
-            vector<string> &vecType, 
-            vector< pair<int, int> > &vecBegEnd) const;
+  int GetPredArgToWord(int paragraphIdx,
+      int sentenceIdx,
+      int wordIdx,
+      vector<string> &vecType,
+      vector< pair<int, int> > &vecBegEnd) const;
 
-    int GetPredArgToWord(int sentenceIdx, 
-            int wordIdx, 
-            vector<string> &vecType, 
-            vector< pair<int, int> > &vecBegEnd) const;
+  int GetPredArgToWord(int sentenceIdx,
+      int wordIdx,
+      vector<string> &vecType,
+      vector< pair<int, int> > &vecBegEnd) const;
 
-    int SetPredArgToWord(int paragraphIdx, 
-            int sentenceIdx, 
-            int wordIdx, 
-            const vector<string> &vecType, 
-            const vector< pair<int, int> > &vecBegEnd);
+  int SetPredArgToWord(int paragraphIdx,
+      int sentenceIdx,
+      int wordIdx,
+      const vector<string> &vecType,
+      const vector< pair<int, int> > &vecBegEnd);
 
-    int SetPredArgToWord(int sentenceIdx, 
-            int wordIdx,
-            const vector<string> &vecType, 
-            const vector< pair<int, int> > &vecBegEnd);
+  int SetPredArgToWord(int sentenceIdx,
+      int wordIdx,
+      const vector<string> &vecType,
+      const vector< pair<int, int> > &vecBegEnd);
 
-    // for coreference resolution
-    int CountEntity() const;
+  // for coreference resolution
+  int CountEntity() const;
 
-    int CountMentionInEntity(int entityIdx);
+  int CountMentionInEntity(int entityIdx);
 
-    int GetMentionOfEntity(vector< pair<int, int> > &vecMention, 
-            int entityIdx) const;
+  int GetMentionOfEntity(vector< pair<int, int> > &vecMention,
+      int entityIdx) const;
 
-    int GetCoreference(vector< vector< pair<int, int> > >& vecCoref) const;
+  int GetCoreference(vector< vector< pair<int, int> > >& vecCoref) const;
 
-    int SetCoreference(const vector< vector< pair<int, int> > >& vecCoref);
+  int SetCoreference(const vector< vector< pair<int, int> > >& vecCoref);
 
 public:
-    int MapGlobalSentIdx2paraIdx_sentIdx(int sentenceIdx, 
-            pair<int, int> &paraIdx_sentIdx) const;
+  int DecodeGlobalId(int global_sid, int & pid, int & sid) const;
 
-    int MapGlobalWordIdx2paraIdx_sentIdx_wordIdx(int globalWordIdx, 
-            int &paraIdx, 
-            int &sentIdx, 
-            int &wordIdx) const;
+  int DecodeGlobalId(int globalWordIdx,
+      int &paraIdx,
+      int &sentIdx,
+      int &wordIdx) const;
 
-    int CheckRange(int paragraphIdx, 
-            int sentenceIdx,
-            int wordIdx) const;
+  int CheckRange(int paragraphIdx,
+      int sentenceIdx,
+      int wordIdx) const;
 
-    int CheckRange(int paragraphIdx, 
-            int sentenceIdx) const;
+  int CheckRange(int paragraphIdx,
+      int sentenceIdx) const;
 
-    int CheckRange(int paragraphIdx) const;
+  int CheckRange(int paragraphIdx) const;
 
-    void ReportTiXmlDocErr() const;
+  void ReportTiXmlDocErr() const;
 
-    int BuildParagraph(string &strParagraph, 
-            int paragraphIdx);
+  int BuildParagraph(string &strParagraph,
+      int paragraphIdx);
 
 private:
-    typedef struct {
-        TiXmlElement *wordPtr;
-    } Word_t;
-
-    typedef struct {
-        vector<Word_t> words;
-        TiXmlElement * sentencePtr;
-    } Sentence_t;
-
-    typedef struct {
-        vector<Sentence_t>  sentences;
-        TiXmlElement *      paragraphPtr;
-    } Paragraph_t;
-
-    typedef struct {
-        vector<Paragraph_t> paragraphs;
-        TiXmlElement *      documentPtr;
-    } Document_t;
-
-    typedef struct {
-        TiXmlElement *nodePtr;
-    } Note, Summary, TextClass;
-
-    typedef struct {
-        TiXmlElement *mentionPtr;
-    } Mention;
-
-    typedef struct {
-        vector<Mention> vecMention;
-        TiXmlElement *entityPtr;
-    } Entity;
-
-    typedef struct {
-        vector<Entity> vecEntity;
-        TiXmlElement *nodePtr;
-    } Coref;
-
+  typedef struct {
+    TiXmlElement *wordPtr;
+  } Word;
+
+  typedef struct {
+    vector<Word> words;
+    TiXmlElement * sentencePtr;
+  } Sentence;
+
+  typedef struct {
+    vector<Sentence>  sentences;
+    TiXmlElement *    paragraphPtr;
+  } Paragraph;
+
+  typedef struct {
+    vector<Paragraph> paragraphs;
+    TiXmlElement *    documentPtr;
+  } Document;
+
+  typedef struct {
+    TiXmlElement *nodePtr;
+  } Note, Summary, TextClass;
+
+  typedef struct {
+    TiXmlElement *mentionPtr;
+  } Mention;
+
+  typedef struct {
+    vector<Mention> vecMention;
+    TiXmlElement *entityPtr;
+  } Entity;
+
+  typedef struct {
+    vector<Entity> vecEntity;
+    TiXmlElement *nodePtr;
+  } Coref;
+
+  typedef std::pair<const char *, const char *> WSDResult;
+  typedef std::pair<int, const char *>          ParseResult;
 private:
-    // initialization during loading txt
-    int BuildDOMFrame();
-
-    // initialization during loading xml
-    int InitXmlStructure();
+  // initialization during loading txt
+  int BuildDOMFrame();
 
-    void CheckNoteForOldLtml();
+  // initialization during loading xml
+  int InitXmlStructure();
 
-    int InitXmlDocument(Document_t & document);
+  int InitXmlDocument(Document & document);
 
-    int InitXmlParagraph(vector<Paragraph_t> & vecParagraph, 
-            TiXmlElement *paragraphPtr);
+  int InitXmlParagraph(vector<Paragraph> & vecParagraph,
+      TiXmlElement *paragraphPtr);
 
-    int InitXmlSentence(vector<Sentence_t> &vecSentence, 
-            TiXmlElement *stnsPtr);
+  int InitXmlSentence(vector<Sentence> &vecSentence,
+      TiXmlElement *stnsPtr);
 
-    int InitXmlWord(vector<Word_t> &vecWord, 
-            TiXmlElement *wordPtr);
+  int InitXmlWord(vector<Word> &vecWord,
+      TiXmlElement *wordPtr);
 
-    int InitXmlCoref(Coref &coref);
+  int InitXmlCoref(Coref &coref);
 
-    int InitXmlEntity(vector<Entity> &vecEntity, 
-            TiXmlElement *entityPtr);
+  int InitXmlEntity(vector<Entity> &vecEntity,
+      TiXmlElement *entityPtr);
 
-    int InitXmlMention(vector<Mention> &vecMention, 
-            TiXmlElement *mentionPtr);
+  int InitXmlMention(vector<Mention> &vecMention,
+      TiXmlElement *mentionPtr);
 
-    int GetInfoFromSentence(vector<const char *> &vecInfo, 
-            int paragraphIdx, 
-            int sentenceIdx, 
-            const char *attrName) const;
+  int GetInfoFromSentence(vector<const char *> &vecInfo,
+      int paragraphIdx,
+      int sentenceIdx,
+      const char *attrName) const;
 
-    int GetInfoFromSentence(vector<const char *> &vecInfo, 
-            int sentenceIdx, 
-            const char *attrName) const;
+  int GetInfoFromSentence(vector<const char *> &vecInfo,
+      int sentenceIdx,
+      const char *attrName) const;
 
-    int GetInfoFromSentence(vector<string> &vec, 
-            int paragraphIdx, 
-            int sentenceIdx, 
-            const char* attrName) const;
+  int GetInfoFromSentence(vector<string> &vec,
+      int paragraphIdx,
+      int sentenceIdx,
+      const char* attrName) const;
 
-    int GetInfoFromSentence(vector<string> &vec, 
-            int sentenceIdx, 
-            const char * attrName) const;
+  int GetInfoFromSentence(vector<string> &vec,
+      int sentenceIdx,
+      const char * attrName) const;
 
-    int SetInfoToSentence(const vector<string> &vec, 
-            int paragraphIdx, 
-            int sentenceIdx, 
-            const char * attrName);
+  int SetInfoToSentence(const vector<string> &vec,
+      int paragraphIdx,
+      int sentenceIdx,
+      const char * attrName);
 
-    int SetInfoToSentence(const vector<string> &vec, 
-            int sentenceIdx, 
-            const char * attrName);
+  int SetInfoToSentence(const vector<string> &vec,
+      int sentenceIdx,
+      const char * attrName);
 
-    int SetInfoToSentence(const vector<int> &vec, 
-            int paragraphIdx, 
-            int sentenceIdx, 
-            const char* attrName);
+  int SetInfoToSentence(const vector<int> &vec,
+      int paragraphIdx,
+      int sentenceIdx,
+      const char* attrName);
 
-    int SetInfoToSentence(const vector<int> &vec, 
-            int sentenceIdx, 
-            const char* attrName);
+  int SetInfoToSentence(const vector<int> &vec,
+      int sentenceIdx,
+      const char* attrName);
 
-    bool LTMLValidation(); 
-    /*-------------------------------------------*/
+  bool LTMLValidation();
+  /*-------------------------------------------*/
 
 private:
-    vector<int> m_vecBegStnsIdxOfPara;
-    vector<int> m_vecBegWordIdxOfStns;
+  vector<int> m_vecBegStnsIdxOfPara;
+  vector<int> m_vecBegWordIdxOfStns;
 
-    Document_t  m_document;
-    Note        m_note;
-    Summary     m_summary;
-    TextClass   m_textclass;
-    Coref       m_coref;
+  Document    document;
+  Note        note;
+  Summary     summary;
+  TextClass   textclass;
+  Coref       coref;
 
-    TiXmlDocument m_tiXmlDoc;
+  TiXmlDocument m_tiXmlDoc;
 
-    /*-------------------------------------------*/
+  /*-------------------------------------------*/
 
 private:
-    static const char * const TAG_DOC;
-    static const char * const TAG_NOTE;
-    static const char * const TAG_SUM;
-    static const char * const TAG_CLASS;
-    static const char * const TAG_COREF;
-    static const char * const TAG_COREF_MENT;
-    static const char * const TAG_COREF_CR;
-    static const char * const TAG_PARA;
-    static const char * const TAG_SENT;
-    static const char * const TAG_WORD;
-    static const char * const TAG_CONT;		//sent, word
-    static const char * const TAG_POS;
-    static const char * const TAG_NE;
-    static const char * const TAG_WSD;
-    static const char * const TAG_WSD_EXP;
-    static const char * const TAG_PSR_PARENT;
-    static const char * const TAG_PSR_RELATE;
-    static const char * const TAG_SRL_ARG;
-    static const char * const TAG_SRL_TYPE;
-    static const char * const TAG_BEGIN;	// cr, srl
-    static const char * const TAG_END;		// cr, srl
-    static const char * const TAG_ID;		// para, sent, word
+  static const char * const TAG_DOC;
+  static const char * const TAG_NOTE;
+  static const char * const TAG_SUM;
+  static const char * const TAG_CLASS;
+  static const char * const TAG_COREF;
+  static const char * const TAG_COREF_MENT;
+  static const char * const TAG_COREF_CR;
+  static const char * const TAG_PARA;
+  static const char * const TAG_SENT;
+  static const char * const TAG_WORD;
+  static const char * const TAG_CONT;		//sent, word
+  static const char * const TAG_POS;
+  static const char * const TAG_NE;
+  static const char * const TAG_WSD;
+  static const char * const TAG_WSD_EXP;
+  static const char * const TAG_PSR_PARENT;
+  static const char * const TAG_PSR_RELATE;
+  static const char * const TAG_SRL_ARG;
+  static const char * const TAG_SRL_TYPE;
+  static const char * const TAG_BEGIN;	// cr, srl
+  static const char * const TAG_END;		// cr, srl
+  static const char * const TAG_ID;		// para, sent, word
 };
 
-#endif      //  end for __LTP_XML4NLP_H__
+#endif    //  end for __LTP_XML4NLP_H__
diff --git a/src/ner/featurespace.h b/src/ner/featurespace.h
index dd2a782d9..53983685d 100644
--- a/src/ner/featurespace.h
+++ b/src/ner/featurespace.h
@@ -11,113 +11,115 @@ namespace ner {
 
 class FeatureSpaceIterator {
 public:
-    FeatureSpaceIterator() : 
-        _dicts(NULL),
-        _i(0),
-        _state(0) {
-        // should be careful about the empty dicts
+  FeatureSpaceIterator()
+    : _dicts(NULL),
+      _num_dicts(-1),
+      _i(0),
+      _state(0) {
+    // should be careful about the empty dicts
+  }
+
+  // initialize the iterator with dicts and number of dicts
+  FeatureSpaceIterator(utility::SmartMap<int> * dicts, int num_dicts)
+    : _dicts(dicts),
+      _num_dicts(num_dicts),
+      _i(0),
+      _state(0) {
+    ++ (*this);
+  }
+
+  ~FeatureSpaceIterator() {
+  }
+
+  const char * key() { return _j.key(); }
+  int id() { return (*_j.value()); }
+  int tid() { return _i; }
+
+  bool operator ==(const FeatureSpaceIterator & other) const {
+    return ((_dicts + _i) == other._dicts);
+  }
+
+  bool operator !=(const FeatureSpaceIterator & other) const {
+    return ((_dicts + _i) != other._dicts);
+  }
+
+  FeatureSpaceIterator & operator = (const FeatureSpaceIterator & other) {
+    if (this != &other) {
+      _dicts     = other._dicts;
+      _i         = other._i;
+      _state     = other._state;
+      _num_dicts = other._num_dicts;
     }
 
-    // initialize the iterator with dicts and number of dicts
-    FeatureSpaceIterator(utility::SmartMap<int> * dicts, int num_dicts) : 
-        _dicts(dicts), 
-        _num_dicts(num_dicts),
-        _i(0), 
-        _state(0) {
-        ++ (*this);
-    }
-
-    ~FeatureSpaceIterator() {
-    }
-
-    const char * key() { return _j.key(); }
-    int id() { return (*_j.value()); }
-    int tid() { return _i; }
-
-    bool operator ==(const FeatureSpaceIterator & other) const {
-        return ((_dicts + _i) == other._dicts); 
-    }
-
-    bool operator !=(const FeatureSpaceIterator & other) const {
-        return ((_dicts + _i) != other._dicts); 
-    }
-
-    FeatureSpaceIterator & operator = (const FeatureSpaceIterator & other) {
-        if (this != &other) {
-            _dicts  = other._dicts;
-            _i      = other._i;
-            _state  = other._state;
-        }
-
-        return *this;
-    }
-
-    void operator ++() {
-        switch (_state) {
-            case 0:
-                for (_i = 0; ; ++ _i) {
-                    if (_dicts[_i].begin() == _dicts[_i].end()) {
-                        _state = 1;
-                        return;
-                    }
-                    for (_j = _dicts[_i].begin(); _j != _dicts[_i].end(); ++ _j) {
-                        _state = 1;
-                        return;
-            case 1:;
-                    }
-                }
+    return *this;
+  }
+
+  void operator ++() {
+    switch (_state) {
+      case 0:
+        for (_i = 0; ; ++ _i) {
+          if (_dicts[_i].begin() == _dicts[_i].end()) {
+            _state = 1;
+            return;
+          }
+          for (_j = _dicts[_i].begin(); _j != _dicts[_i].end(); ++ _j) {
+            _state = 1;
+            return;
+      case 1:;
+          }
         }
     }
+  }
 
-    int _i;
-    int _state;
-    int _num_dicts;
-    utility::SmartMap<int>::const_iterator  _j;
-    utility::SmartMap<int> * _dicts;
+  int _i;
+  int _state;
+  int _num_dicts;
+  utility::SmartMap<int>::const_iterator  _j;
+  utility::SmartMap<int> * _dicts;
 };
 
 class FeatureSpace {
 public:
-    FeatureSpace(int num_labels = 1);
-    ~FeatureSpace();
-
-    int retrieve(int tid, const char * key, bool create);
-    int index(int tid, const char * key, int lid = 0);
-    int index(int prev_lid, int lid);
-    int num_features();
-    int dim();
-    void set_num_labels(int num_labeles);
-
-    /*
-     * dump the feature space to a output stream
-     *
-     *  @param[in]  ofs     the output stream
-     */
-    void dump(std::ostream & ofs);
-
-    /*
-     * load the feature space from a input stream
-     *
-     *  @param[in]  num_labels  the number of labels
-     *  @param[in]  ifs         the input stream
-     */
-    bool load(int num_labeles, std::istream & ifs);
-
-    FeatureSpaceIterator begin() {
-        return FeatureSpaceIterator(dicts, _num_dicts);
-    }
-
-    FeatureSpaceIterator end() {
-        return FeatureSpaceIterator(dicts + _num_dicts, _num_dicts);
-    }
+  FeatureSpace(int num_labels = 1);
+  ~FeatureSpace();
+
+  int retrieve(int tid, const char * key, bool create);
+  int index(int tid, const char * key, int lid = 0);
+  int index(int prev_lid, int lid);
+  int num_features();
+  int dim();
+  void set_num_labels(int num_labeles);
+
+  /*
+   * dump the feature space to a output stream
+   *
+   *  @param[in]  ofs   the output stream
+   */
+  void dump(std::ostream & ofs);
+
+  /*
+   * load the feature space from a input stream
+   *
+   *  @param[in]  num_labels  the number of labels
+   *  @param[in]  ifs     the input stream
+   */
+  bool load(int num_labeles, std::istream & ifs);
+
+  FeatureSpaceIterator begin() {
+    return FeatureSpaceIterator(dicts, _num_dicts);
+  }
+
+  FeatureSpaceIterator end() {
+    return FeatureSpaceIterator(dicts + _num_dicts, _num_dicts);
+  }
 private:
-    int _offset;
-    int _num_labels;
-    int _num_dicts;
-    utility::SmartMap<int> * dicts;
+  int _offset;
+  int _num_labels;
+  int _num_dicts;
+  utility::SmartMap<int> * dicts;
 };
 
-}       //  end for namespace ner
-}       //  end for namespace ltp
+}     //  end for namespace ner
+}     //  end for namespace ltp
 
 #endif  //  end for __LTP_NER_FEATURE_SPACE_H__
diff --git a/src/ner/featurevec.h b/src/ner/featurevec.h
index 96574fb97..1e0652652 100644
--- a/src/ner/featurevec.h
+++ b/src/ner/featurevec.h
@@ -6,32 +6,32 @@ namespace ner {
 
 struct FeatureVector {
 public:
-    FeatureVector () : n(0), idx(0), val(0) {
-    }
+  FeatureVector () : n(0), idx(0), val(0), loff(0) {
+  }
 
-    ~FeatureVector() {
-    }
+  ~FeatureVector() {
+  }
 
-    void clear() {
-        if (idx) {
-            delete [](idx);
-            idx = 0;
-        }
+  void clear() {
+    if (idx) {
+      delete [](idx);
+      idx = 0;
+    }
 
-        if (val) {
-            delete [](val);
-            val = 0;
-        }
+    if (val) {
+      delete [](val);
+      val = 0;
     }
+  }
 
 public:
-    int      n;
-    int *    idx;
-    double * val;
-    int      loff;
+  int      n;
+  int *    idx;
+  double * val;
+  int      loff;
 };
 
-}       //  end for namespace segmentor
-}       //  end for namespace ltp
+}     //  end for namespace segmentor
+}     //  end for namespace ltp
 
 #endif  //  end for __LTP_SEGMENTOR_FEATRUE_VECTOR_H__
diff --git a/src/ner/instance.h b/src/ner/instance.h
index 7df9423d9..e67b84e79 100644
--- a/src/ner/instance.h
+++ b/src/ner/instance.h
@@ -11,169 +11,168 @@ namespace ner {
 
 class Instance {
 public:
-    Instance() {}
+  Instance() {}
 
-    ~Instance() {
-        cleanup();
+  ~Instance() {
+    cleanup();
+  }
+
+  inline size_t size() const {
+    return forms.size();
+  }
+
+  int num_errors() {
+    int len = size();
+    if ((len != tagsidx.size()) || (len != predicted_tagsidx.size())) {
+      return len;
     }
 
-    inline size_t size() const {
-        return forms.size();
+    int ret = 0;
+    for (int i = 0; i < len; ++ i) {
+      if (tagsidx[i] != predicted_tagsidx[i]) {
+        ++ ret;
+      }
     }
 
-    int num_errors() {
-        int len = size();
-        if ((len != tagsidx.size()) || (len != predicted_tagsidx.size())) {
-            return len;
-        }
+    return ret;
+  }
 
-        int ret = 0;
-        for (int i = 0; i < len; ++ i) {
-            if (tagsidx[i] != predicted_tagsidx[i]) {
-                ++ ret;
-            }
-        }
+  int num_corrected_predicted_tags() {
+    int len = size();
+    int ret = 0;
 
-        return ret;
+    for (int i = 0; i < len; ++ i) {
+      if (tagsidx[i] == predicted_tagsidx[i]) {
+        ++ ret;
+      }
     }
 
-    int num_corrected_predicted_tags() {
-        int len = size();
-        int ret = 0;
+    return ret;
+  }
 
-        for (int i = 0; i < len; ++ i) {
-            if (tagsidx[i] == predicted_tagsidx[i]) {
-                ++ ret;
-            }
-        }
+  int num_gold_entities() {
+    int ret = 0;
+    if (entities.size() == 0) {
+      return size();
+    }
 
-        return ret;
+    for (int i = 0; i < entities_tags.size(); ++ i) {
+      if (entities_tags[i] != "O") {
+        ++ ret;
+      }
     }
 
-    int num_gold_entities() {
-        int ret = 0;
-        if (entities.size() == 0) {
-            return size();
-        }
+    return ret;
+  }
 
-        for (int i = 0; i < entities_tags.size(); ++ i) {
-            if (entities_tags[i] != "O") {
-                ++ ret;
-            }
-        }
+  int num_predicted_entities() {
+    int ret = 0;
+    if (predicted_entities.size() == 0) {
+      return size();
+    }
 
-        return ret;
+    for (int i = 0; i < predicted_entities_tags.size(); ++ i) {
+      if (predicted_entities_tags[i] != "O") {
+        ++ ret;
+      }
     }
 
-    int num_predicted_entities() {
-        int ret = 0;
-        if (predicted_entities.size() == 0) {
-            return size();
-        }
+    return ret;
+  }
 
-        for (int i = 0; i < predicted_entities_tags.size(); ++ i) {
-            if (predicted_entities_tags[i] != "O") {
-                ++ ret;
-            }
-        }
+  int num_recalled_entites() {
+    int len = 0;
+    int ret = 0;
+    int gold_len = 0, predicted_len = 0;
 
-        return ret;
+    for (int i = 0; i < entities.size(); ++ i) {
+      len += entities[i].size();
     }
 
-    int num_recalled_entites() {
-        int len = 0;
-        int ret = 0;
-        int gold_len = 0, predicted_len = 0;
-
-        for (int i = 0; i < entities.size(); ++ i) {
-            len += entities[i].size();
+    for (int i = 0, j = 0; i < entities.size() && j < predicted_entities.size(); ) {
+      if ((entities[i] == predicted_entities[j]) && 
+          (entities_tags[i] == predicted_entities_tags[j])) {
+        if (entities_tags[i] != "O") {
+          ++ ret;
         }
 
-        for (int i = 0, j = 0; i < entities.size() && j < predicted_entities.size(); ) {
-            if ((entities[i] == predicted_entities[j]) && 
-                    (entities_tags[i] == predicted_entities_tags[j])) {
-                if (entities_tags[i] != "O") {
-                    ++ ret;
-                }
-
-                gold_len += entities[i].size();
-                predicted_len += predicted_entities[j].size();
-
-                ++ i;
-                ++ j;
-            } else {
-                gold_len += entities[i].size();
-                predicted_len += predicted_entities[j].size();
-
-                ++ i;
-                ++ j;
-
-                while (gold_len < len && predicted_len < len) {
-                    if (gold_len < predicted_len) {
-                        gold_len += entities[i].size();
-                        ++ i;
-                    } else if (gold_len > predicted_len) {
-                        predicted_len += predicted_entities[j].size();
-                        ++ j;
-                    } else {
-                        break;
-                    }
-                }
-            }
+        gold_len += entities[i].size();
+        predicted_len += predicted_entities[j].size();
+
+        ++ i;
+        ++ j;
+      } else {
+        gold_len += entities[i].size();
+        predicted_len += predicted_entities[j].size();
+
+        ++ i;
+        ++ j;
+
+        while (gold_len < len && predicted_len < len) {
+          if (gold_len < predicted_len) {
+            gold_len += entities[i].size();
+            ++ i;
+          } else if (gold_len > predicted_len) {
+            predicted_len += predicted_entities[j].size();
+            ++ j;
+          } else {
+            break;
+          }
         }
-
-        return ret;
+      }
     }
 
-    int cleanup() {
-        int len = 0;
-        if ((len = uni_features.total_size()) > 0) {
-            int d1 = uni_features.nrows();
-            int d2 = uni_features.ncols();
-
-            for (int i = 0; i < d1; ++ i) {
-                if (uni_features[i][0]) {
-                    uni_features[i][0]->clear();
-                }
-                for (int j = 0; j < d2; ++ j) {
-                    if (uni_features[i][j]) {
-                        delete uni_features[i][j];
-                    }
-                }
-            }
+    return ret;
+  }
+
+  int cleanup() {
+    if (uni_features.total_size() > 0) {
+      int d1 = uni_features.nrows();
+      int d2 = uni_features.ncols();
+
+      for (int i = 0; i < d1; ++ i) {
+        if (uni_features[i][0]) {
+          uni_features[i][0]->clear();
+        }
+        for (int j = 0; j < d2; ++ j) {
+          if (uni_features[i][j]) {
+            delete uni_features[i][j];
+          }
         }
+      }
+    }
 
-        uni_features.dealloc();
-        uni_scores.dealloc();
-        bi_scores.dealloc();
+    uni_features.dealloc();
+    uni_scores.dealloc();
+    bi_scores.dealloc();
 
-        features.zero();
-        predicted_features.zero();
+    features.zero();
+    predicted_features.zero();
 
-        return 0;
-    }
+    return 0;
+  }
 public:
-    std::vector< std::string >  raw_forms;
-    std::vector< std::string >  forms;
-    std::vector< std::string >  postags;
-    std::vector< std::string >  tags;
-    std::vector< int >          tagsidx;
-    std::vector< std::string >  predicted_tags;
-    std::vector< int >          predicted_tagsidx;
-    std::vector< std::string >  entities;
-    std::vector< std::string >  entities_tags;
-    std::vector< std::string >  predicted_entities;
-    std::vector< std::string >  predicted_entities_tags;
-
-    math::SparseVec             features;                   /*< the gold features */
-    math::SparseVec             predicted_features;         /*< the predicted features */
-
-    math::Mat< FeatureVector *> uni_features;
-    math::Mat< double >         uni_scores;
-    math::Mat< double >         bi_scores;
+  std::vector< std::string >  raw_forms;
+  std::vector< std::string >  forms;
+  std::vector< std::string >  postags;
+  std::vector< std::string >  tags;
+  std::vector< int >          tagsidx;
+  std::vector< std::string >  predicted_tags;
+  std::vector< int >          predicted_tagsidx;
+  std::vector< std::string >  entities;
+  std::vector< std::string >  entities_tags;
+  std::vector< std::string >  predicted_entities;
+  std::vector< std::string >  predicted_entities_tags;
+
+  math::SparseVec       features;           /*< the gold features */
+  math::SparseVec       predicted_features;     /*< the predicted features */
+
+  math::Mat< FeatureVector *> uni_features;
+  math::Mat< double >     uni_scores;
+  math::Mat< double >     bi_scores;
 };
 
-}       //  end for namespace ner
-}       //  end for namespace ltp
+}     //  end for namespace ner
+}     //  end for namespace ltp
 
 #endif  //  end for __LTP_NER_INSTANCE_H__
diff --git a/src/ner/model.cpp b/src/ner/model.cpp
index eb9bf8599..b44bd8193 100644
--- a/src/ner/model.cpp
+++ b/src/ner/model.cpp
@@ -9,77 +9,78 @@ Model::Model() {
 Model::~Model() {
 }
 
-void Model::save(std::ostream & ofs) {
-    // write a signature into the file
-    char chunk[16] = {'o','t','c','w','s', '\0'};
-    ofs.write(chunk, 16);
+void
+Model::save(std::ostream & ofs) {
+  // write a signature into the file
+  char chunk[16] = {'o','t','n','e','r', '\0'};
+  ofs.write(chunk, 16);
 
-    int off = ofs.tellp();
+  int off = ofs.tellp();
 
-    unsigned labels_offset      = 0;
-    unsigned lexicon_offset     = 0;
-    unsigned feature_offset     = 0;
-    unsigned parameter_offset   = 0;
+  unsigned labels_offset    = 0;
+  unsigned lexicon_offset   = 0;
+  unsigned feature_offset   = 0;
+  unsigned parameter_offset   = 0;
 
-    write_uint(ofs, 0); //  the label offset
-    write_uint(ofs, 0); //  the cluster lexicon offset
-    write_uint(ofs, 0); //  the features offset
-    write_uint(ofs, 0); //  the parameter offset
+  write_uint(ofs, 0); //  the label offset
+  write_uint(ofs, 0); //  the cluster lexicon offset
+  write_uint(ofs, 0); //  the features offset
+  write_uint(ofs, 0); //  the parameter offset
 
-    labels_offset = ofs.tellp();
-    labels.dump(ofs);
+  labels_offset = ofs.tellp();
+  labels.dump(ofs);
 
-    lexicon_offset = ofs.tellp();
-    cluster_lexicon.dump(ofs);
+  lexicon_offset = ofs.tellp();
+  cluster_lexicon.dump(ofs);
 
-    feature_offset = ofs.tellp();
-    space.dump(ofs);
+  feature_offset = ofs.tellp();
+  space.dump(ofs);
 
-    parameter_offset = ofs.tellp();
-    param.dump(ofs);
+  parameter_offset = ofs.tellp();
+  param.dump(ofs);
 
-    ofs.seekp(off);
-    write_uint(ofs, labels_offset);
-    write_uint(ofs, lexicon_offset);
-    write_uint(ofs, feature_offset);
-    write_uint(ofs, parameter_offset);
+  ofs.seekp(off);
+  write_uint(ofs, labels_offset);
+  write_uint(ofs, lexicon_offset);
+  write_uint(ofs, feature_offset);
+  write_uint(ofs, parameter_offset);
 }
 
 bool Model::load(std::istream & ifs) {
-    char chunk[16];
-    ifs.read(chunk, 16);
-
-    if (strcmp(chunk, "otcws")) {
-        return false;
-    }
-
-    unsigned labels_offset    = read_uint(ifs);
-    unsigned lexicon_offset   = read_uint(ifs);
-    unsigned feature_offset   = read_uint(ifs);
-    unsigned parameter_offset = read_uint(ifs);
-
-    ifs.seekg(labels_offset);
-    if (!labels.load(ifs)) {
-        return false;
-    }
-
-    ifs.seekg(lexicon_offset);
-    if (!cluster_lexicon.load(ifs)) {
-        return false;
-    }
-
-    ifs.seekg(feature_offset);
-    if (!space.load(labels.size(), ifs)) {
-        return false;
-    }
-
-    ifs.seekg(parameter_offset);
-    if (!param.load(ifs)) {
-        return false;
-    }
-
-    return true;
+  char chunk[16];
+  ifs.read(chunk, 16);
+
+  if (strcmp(chunk, "otner")) {
+    return false;
+  }
+
+  unsigned labels_offset  = read_uint(ifs);
+  unsigned lexicon_offset   = read_uint(ifs);
+  unsigned feature_offset   = read_uint(ifs);
+  unsigned parameter_offset = read_uint(ifs);
+
+  ifs.seekg(labels_offset);
+  if (!labels.load(ifs)) {
+    return false;
+  }
+
+  ifs.seekg(lexicon_offset);
+  if (!cluster_lexicon.load(ifs)) {
+    return false;
+  }
+
+  ifs.seekg(feature_offset);
+  if (!space.load(labels.size(), ifs)) {
+    return false;
+  }
+
+  ifs.seekg(parameter_offset);
+  if (!param.load(ifs)) {
+    return false;
+  }
+
+  return true;
 }
 
-}       //  end for namespace ner
-}       //  end for namespace ltp
+}     //  end for namespace ner
+}     //  end for namespace ltp
diff --git a/src/ner/model.h b/src/ner/model.h
index 7534a1814..ec898b70e 100644
--- a/src/ner/model.h
+++ b/src/ner/model.h
@@ -13,50 +13,50 @@ using namespace ltp::utility;
 
 class Model {
 public:
-    Model();
-    ~Model();
-
-    /*
-     * get number of labels;
-     *
-     *  @return     int     the number of labels
-     */
-    inline int num_labels(void) {
-        return labels.size();
-    }
-
-    /*
-     * save the model to a output stream
-     *
-     *  @param[out] ofs     the output stream
-     */
-    void save(std::ostream & ofs);
-
-    /*
-     * load the model from an input stream
-     *
-     *  @param[in]  ifs     the input stream
-     */
-    bool load(std::istream & ifs);
+  Model();
+  ~Model();
+
+  /*
+   * get number of labels;
+   *
+   *  @return   int   the number of labels
+   */
+  inline int num_labels(void) {
+    return labels.size();
+  }
+
+  /*
+   * save the model to a output stream
+   *
+   *  @param[out] ofs   the output stream
+   */
+  void save(std::ostream & ofs);
+
+  /*
+   * load the model from an input stream
+   *
+   *  @param[in]  ifs   the input stream
+   */
+  bool load(std::istream & ifs);
 public:
-    IndexableSmartMap   labels;
-    FeatureSpace        space;
-    Parameters          param;
+  IndexableSmartMap   labels;
+  FeatureSpace        space;
+  Parameters          param;
 
-    SmartMap<int>       cluster_lexicon;
+  SmartMap<int>       cluster_lexicon;
 private:
-    void write_uint(std::ostream & out, unsigned int val) {
-        out.write(reinterpret_cast<const char *>(&val), sizeof(unsigned int));
-    }
-
-    unsigned int read_uint(std::istream & in) {
-        char p[4];
-        in.read(reinterpret_cast<char*>(p), sizeof(unsigned int));
-        return *reinterpret_cast<const unsigned int*>(p);
-    }
+  void write_uint(std::ostream & out, unsigned int val) {
+    out.write(reinterpret_cast<const char *>(&val), sizeof(unsigned int));
+  }
+
+  unsigned int read_uint(std::istream & in) {
+    char p[4];
+    in.read(reinterpret_cast<char*>(p), sizeof(unsigned int));
+    return *reinterpret_cast<const unsigned int*>(p);
+  }
 };
 
-}       //  end for namespace ner
-}       //  end for namespace ltp
+}     //  end for namespace ner
+}     //  end for namespace ltp
 
 #endif  //  end for __LTP_NER_MODEL_H__
diff --git a/src/ner/ner.cpp b/src/ner/ner.cpp
index 40e4ba5fc..897eee707 100644
--- a/src/ner/ner.cpp
+++ b/src/ner/ner.cpp
@@ -20,723 +20,734 @@
 namespace ltp {
 namespace ner {
 
-NER::NER() :
-   model(0),
-   decoder(0) {
+NER::NER() 
+  : model(0),
+    decoder(0),
+    __TRAIN__(false),
+    __TEST__(false),
+    __DUMP__(false) {
 }
 
-NER::NER(ltp::utility::ConfigParser & cfg) :
-    model(0),
-    decoder(0) {
-    parse_cfg(cfg);
+NER::NER(ltp::utility::ConfigParser & cfg)
+  : model(0),
+    decoder(0),
+    __TRAIN__(false),
+    __TEST__(false),
+    __DUMP__(false) {
+  parse_cfg(cfg);
 }
 
 NER::~NER() {
-    if (model) {
-        delete model;
-    }
+  if (model) {
+    delete model;
+  }
 
-    if (decoder) {
-        delete decoder;
-    }
+  if (decoder) {
+    delete decoder;
+  }
 }
 
-void NER::run(void) {
-    if (__TRAIN__) {
-        train();
-    }
+void
+NER::run(void) {
+  if (__TRAIN__) {
+    train();
+  }
 
-    if (__TEST__) {
-        test();
-    }
+  if (__TEST__) {
+    test();
+  }
 
-    if (__DUMP__) {
-        dump();
-    }
+  if (__DUMP__) {
+    dump();
+  }
 
-    for (int i = 0; i < train_dat.size(); ++ i) {
-        if (train_dat[i]) {
-            delete train_dat[i];
-        }
+  for (int i = 0; i < train_dat.size(); ++ i) {
+    if (train_dat[i]) {
+      delete train_dat[i];
     }
+  }
 }
 
-bool NER::parse_cfg(ltp::utility::ConfigParser & cfg) {
-    std::string strbuf;
-    int         intbuf;
-
-    __TRAIN__ = false;
-
-    train_opt.train_file    = "";
-    train_opt.holdout_file  = "";
-    train_opt.algorithm     = "pa";
-    train_opt.model_name    = "";
-    train_opt.max_iter      = 10;
-    train_opt.display_interval = 5000;
+bool
+NER::parse_cfg(ltp::utility::ConfigParser & cfg) {
+  std::string strbuf;
+  int         intbuf;
 
-    if (cfg.has_section("train")) {
-        TRACE_LOG("Training mode specified.");
-        __TRAIN__ = true;
 
-        if (cfg.get("train", "train-file", strbuf)) {
-            train_opt.train_file = strbuf;
-        } else {
-            ERROR_LOG("train-file config item is not found.");
-            return false;
-        }
+  train_opt.train_file        = "";
+  train_opt.holdout_file      = "";
+  train_opt.algorithm         = "pa";
+  train_opt.model_name        = "";
+  train_opt.max_iter          = 10;
+  train_opt.display_interval  = 5000;
 
-        if (cfg.get("train", "holdout-file", strbuf)) {
-            train_opt.holdout_file = strbuf;
-        } else {
-            ERROR_LOG("holdout-file config item is not found.");
-            return false;
-        }
+  if (cfg.has_section("train")) {
+    TRACE_LOG("Training mode specified.");
+    __TRAIN__ = true;
 
-        if (cfg.get("train", "algorithm", strbuf)) {
-            train_opt.algorithm = strbuf;
-        } else {
-            WARNING_LOG("algorithm is not configed, [PA] is set as default");
-        }
+    if (cfg.get("train", "train-file", strbuf)) {
+      train_opt.train_file = strbuf;
+    } else {
+      ERROR_LOG("train-file config item is not found.");
+      return false;
+    }
 
-        train_opt.model_name = train_opt.train_file + "." + train_opt.algorithm;
-        if (cfg.get("train", "model-name", strbuf)) {
-            train_opt.model_name = strbuf;
-        } else {
-            WARNING_LOG("model name is not configed, [%s] is set as default",
-                    train_opt.model_name.c_str());
-        }
+    if (cfg.get("train", "holdout-file", strbuf)) {
+      train_opt.holdout_file = strbuf;
+    } else {
+      ERROR_LOG("holdout-file config item is not found.");
+      return false;
+    }
 
-        if (cfg.get_integer("train", "max-iter", intbuf)) {
-            train_opt.max_iter = intbuf;
-        } else {
-            WARNING_LOG("max-iter is not configed, [10] is set as default.");
-        }
+    if (cfg.get("train", "algorithm", strbuf)) {
+      train_opt.algorithm = strbuf;
+    } else {
+      WARNING_LOG("algorithm is not configed, [PA] is set as default");
     }
 
-    __TEST__ = false;
+    train_opt.model_name = train_opt.train_file + "." + train_opt.algorithm;
+    if (cfg.get("train", "model-name", strbuf)) {
+      train_opt.model_name = strbuf;
+    } else {
+      WARNING_LOG("model name is not configed, [%s] is set as default",
+          train_opt.model_name.c_str());
+    }
 
-    test_opt.test_file = "";
-    test_opt.model_file = "";
-    test_opt.lexicon_file = "";
+    if (cfg.get_integer("train", "max-iter", intbuf)) {
+      train_opt.max_iter = intbuf;
+    } else {
+      WARNING_LOG("max-iter is not configed, [10] is set as default.");
+    }
+  }
 
-    if (cfg.has_section("test")) {
-        __TEST__ = true;
+  test_opt.test_file = "";
+  test_opt.model_file = "";
+  test_opt.lexicon_file = "";
 
-        if (cfg.get("test", "test-file", strbuf)) {
-            test_opt.test_file = strbuf;
-        } else {
-            ERROR_LOG("test-file config item is not set.");
-            return false;
-        }
+  if (cfg.has_section("test")) {
+    __TEST__ = true;
 
-        if (cfg.get("test", "model-file", strbuf)) {
-            test_opt.model_file = strbuf;
-        } else {
-            ERROR_LOG("model-file is not configed. ");
-            return false;
-        }
+    if (cfg.get("test", "test-file", strbuf)) {
+      test_opt.test_file = strbuf;
+    } else {
+      ERROR_LOG("test-file config item is not set.");
+      return false;
+    }
 
-        if (cfg.get("test", "lexicon-file", strbuf)) {
-            test_opt.lexicon_file = strbuf;
-        }
+    if (cfg.get("test", "model-file", strbuf)) {
+      test_opt.model_file = strbuf;
+    } else {
+      ERROR_LOG("model-file is not configed. ");
+      return false;
     }
 
-    __DUMP__ = false;
+    if (cfg.get("test", "lexicon-file", strbuf)) {
+      test_opt.lexicon_file = strbuf;
+    }
+  }
 
-    dump_opt.model_file = "";
-    if (cfg.has_section("dump")) {
-        __DUMP__ = true;
+  dump_opt.model_file = "";
+  if (cfg.has_section("dump")) {
+    __DUMP__ = true;
 
-        if (cfg.get("dump", "model-file", strbuf)) {
-            dump_opt.model_file = strbuf;
-        } else {
-            ERROR_LOG("model-file is not configed.");
-            return false;
-        }
+    if (cfg.get("dump", "model-file", strbuf)) {
+      dump_opt.model_file = strbuf;
+    } else {
+      ERROR_LOG("model-file is not configed.");
+      return false;
     }
+  }
 
-    return true;
+  return true;
 }
 
-bool NER::read_instance(const char * train_file) {
-    std::ifstream ifs(train_file);
+bool
+NER::read_instance(const char * train_file) {
+  std::ifstream ifs(train_file);
 
-    if (!ifs) {
-        return false;
-    }
+  if (!ifs) {
+    return false;
+  }
 
-    NERReader reader(ifs, true);
-    train_dat.clear();
+  NERReader reader(ifs, true);
+  train_dat.clear();
 
-    Instance * inst = NULL;
+  Instance * inst = NULL;
 
-    while ((inst = reader.next())) {
-        train_dat.push_back(inst);
-    }
+  while ((inst = reader.next())) {
+    train_dat.push_back(inst);
+  }
 
-    return true;
+  return true;
 }
 
 void NER::build_configuration(void) {
-    // tag set is some kind of hard coded into the source
-
-    std::stringstream S;
-    for (int i = 0; i < __num_pos_types__; ++ i) {
-        for (int j = 0; j < __num_ne_types__; ++ j) {
-            S.str(std::string());
-            S << __pos_types__[i] << "-" << __ne_types__[j];
-            model->labels.push(S.str());
-        }
+  // tag set is some kind of hard coded into the source
+
+  std::stringstream S;
+  for (int i = 0; i < __num_pos_types__; ++ i) {
+    for (int j = 0; j < __num_ne_types__; ++ j) {
+      S.str(std::string());
+      S << __pos_types__[i] << "-" << __ne_types__[j];
+      model->labels.push(S.str());
     }
-    model->labels.push("O");
+  }
+  model->labels.push("O");
 
-    for (int i = 0; i < train_dat.size(); ++ i) {
-        Instance * inst = train_dat[i];
-        int len = inst->size();
+  for (int i = 0; i < train_dat.size(); ++ i) {
+    Instance * inst = train_dat[i];
+    int len = inst->size();
 
-        inst->tagsidx.resize(len);
-        for (int j = 0; j < len; ++ j) {
-            // build labels dictionary
-            inst->tagsidx[j] = model->labels.index( inst->tags[j] );
-        }
+    inst->tagsidx.resize(len);
+    for (int j = 0; j < len; ++ j) {
+      // build labels dictionary
+      inst->tagsidx[j] = model->labels.index( inst->tags[j] );
     }
+  }
 }
 
 void NER::extract_features(Instance * inst, bool create) {
-    const int N = Extractor::num_templates();
-    const int L = model->num_labels();
-
-    vector< StringVec > cache;
-    vector< int > cache_again;
-
-    cache.resize(N);
-    int len = inst->size();
+  const int N = Extractor::num_templates();
+  const int L = model->num_labels();
 
-    // allocate the uni_features
-    inst->uni_features.resize(len, L);  inst->uni_features = 0;
-    inst->uni_scores.resize(len, L);    inst->uni_scores = NEG_INF;
-    inst->bi_scores.resize(L, L);       inst->bi_scores = NEG_INF;
+  vector< StringVec > cache;
+  vector< int > cache_again;
 
-    for (int pos = 0; pos < len; ++ pos) {
-        for (int n = 0; n < N; ++ n) {
-            cache[n].clear();
-        }
-        cache_again.clear();
+  cache.resize(N);
+  int len = inst->size();
 
-        Extractor::extract1o(inst, pos, cache);
+  // allocate the uni_features
+  inst->uni_features.resize(len, L);  inst->uni_features = 0;
+  inst->uni_scores.resize(len, L);    inst->uni_scores = NEG_INF;
+  inst->bi_scores.resize(L, L);       inst->bi_scores = NEG_INF;
 
-        for (int tid = 0; tid < cache.size(); ++ tid) {
-            for (int itx = 0; itx < cache[tid].size(); ++ itx) {
-                if (create) {
-                    model->space.retrieve(tid, cache[tid][itx], true);
-                }
+  for (int pos = 0; pos < len; ++ pos) {
+    for (int n = 0; n < N; ++ n) {
+      cache[n].clear();
+    }
+    cache_again.clear();
 
-                int idx = model->space.index(tid, cache[tid][itx]);
+    Extractor::extract1o(inst, pos, cache);
 
-                if (idx >= 0) {
-                    cache_again.push_back(idx);
-                }
-            }
+    for (int tid = 0; tid < cache.size(); ++ tid) {
+      for (int itx = 0; itx < cache[tid].size(); ++ itx) {
+        if (create) {
+          model->space.retrieve(tid, cache[tid][itx], true);
         }
 
-        int num_feat = cache_again.size();
-
-        if (num_feat > 0) {
-            int l = 0;
-            int * idx = new int[num_feat];
-            for (int j = 0; j < num_feat; ++ j) {
-                idx[j] = cache_again[j];
-            }
-
-            inst->uni_features[pos][l] = new FeatureVector;
-            inst->uni_features[pos][l]->n = num_feat;
-            inst->uni_features[pos][l]->val = 0;
-            inst->uni_features[pos][l]->loff = 0;
-            inst->uni_features[pos][l]->idx = idx;
-
-            for (l = 1; l < L; ++ l) {
-                inst->uni_features[pos][l] = new FeatureVector;
-                inst->uni_features[pos][l]->n = num_feat;
-                inst->uni_features[pos][l]->idx = idx;
-                inst->uni_features[pos][l]->val = 0;
-                inst->uni_features[pos][l]->loff = l;
-            }
-        }
-    }
-}
+        int idx = model->space.index(tid, cache[tid][itx]);
 
-void NER::build_feature_space(void) {
-    // build feature space, it a wrapper for
-    // featurespace.build_feature_space
-    int N = Extractor::num_templates();
-    int L = model->num_labels();
-    model->space.set_num_labels(L);
-
-    for (int i = 0; i < train_dat.size(); ++ i) {
-        extract_features(train_dat[i], true);
-        if ((i + 1) % train_opt.display_interval == 0) {
-            TRACE_LOG("[%d] instances is extracted.", (i+1));
+        if (idx >= 0) {
+          cache_again.push_back(idx);
         }
+      }
     }
-}
 
-void NER::build_entities(Instance * inst,
-        const std::vector<int> & tagsidx,
-        std::vector<std::string> & entities,
-        std::vector<std::string> & entities_tags,
-        int beg_tag0,
-        int beg_tag1,
-        int beg_tag2) {
-    entities.clear();
-    entities_tags.clear();
-
-    std::string entity = "";
-    std::string entity_tag = "";
-    int len = inst->size();
-    int tag = -1;
-    int tag_prefix = -1;
-    int tag_suffix = -1;
-
-    // should check the tagsidx size
-    entity = inst->raw_forms[0];
-
-    tag = inst->tagsidx[0];
-    tag_suffix = tag % __num_ne_types__;
-    entity_tag = (tag == 12 ? "O" : __ne_types__[tag_suffix]);
-    for (int i = 1; i < len; ++ i) {
-        tag = tagsidx[i];
-
-        tag_prefix = tag / __num_ne_types__;
-        tag_suffix = (tag % __num_ne_types__);
-
-        if (tag_prefix == beg_tag0 || tag_prefix == beg_tag1 || tag_prefix == beg_tag2) {
-            entities.push_back(entity);
-            entities_tags.push_back(entity_tag);
-
-            entity = inst->raw_forms[i];
-            entity_tag = (tag == 12 ? "O" : __ne_types__[tag_suffix]);
-        } else {
-            entity += inst->raw_forms[i];
-        }
+    int num_feat = cache_again.size();
+
+    if (num_feat > 0) {
+      int l = 0;
+      int * idx = new int[num_feat];
+      for (int j = 0; j < num_feat; ++ j) {
+        idx[j] = cache_again[j];
+      }
+
+      inst->uni_features[pos][l] = new FeatureVector;
+      inst->uni_features[pos][l]->n = num_feat;
+      inst->uni_features[pos][l]->val = 0;
+      inst->uni_features[pos][l]->loff = 0;
+      inst->uni_features[pos][l]->idx = idx;
+
+      for (l = 1; l < L; ++ l) {
+        inst->uni_features[pos][l] = new FeatureVector;
+        inst->uni_features[pos][l]->n = num_feat;
+        inst->uni_features[pos][l]->idx = idx;
+        inst->uni_features[pos][l]->val = 0;
+        inst->uni_features[pos][l]->loff = l;
+      }
     }
-    entities.push_back(entity);
-    entities_tags.push_back(entity_tag);
+  }
 }
 
-void NER::calculate_scores(Instance * inst, bool use_avg) {
-    int len = inst->size();
-    int L = model->num_labels();
-    for (int i = 0; i < len; ++ i) {
-        for (int l = 0; l < L; ++ l) {
-            FeatureVector * fv = inst->uni_features[i][l];
-            if (!fv) {
-                continue;
-            }
+void NER::build_feature_space(void) {
+  // build feature space, it a wrapper for
+  // featurespace.build_feature_space
+  Extractor::num_templates();
 
-            inst->uni_scores[i][l] = model->param.dot(inst->uni_features[i][l], use_avg);
-        }
-    }
+  int L = model->num_labels();
+  model->space.set_num_labels(L);
 
-    for (int pl = 0; pl < L; ++ pl) {
-        for (int l = 0; l < L; ++ l) {
-            int idx = model->space.index(pl, l);
-            inst->bi_scores[pl][l] = model->param.dot(idx, use_avg);
-        }
+  for (int i = 0; i < train_dat.size(); ++ i) {
+    extract_features(train_dat[i], true);
+    if ((i + 1) % train_opt.display_interval == 0) {
+      TRACE_LOG("[%d] instances is extracted.", (i+1));
     }
+  }
 }
 
-void NER::collect_features(Instance * inst, const std::vector<int> & tagsidx, math::SparseVec & vec) {
-    int len = inst->size();
+void
+NER::build_entities(Instance * inst,
+                    const std::vector<int> & tagsidx,
+                    std::vector<std::string> & entities,
+                    std::vector<std::string> & entities_tags,
+                    int beg_tag0,
+                    int beg_tag1,
+                    int beg_tag2) {
+  entities.clear();
+  entities_tags.clear();
 
-    vec.zero();
-    for (int i = 0; i < len; ++ i) {
-        int l = tagsidx[i];
-        const FeatureVector * fv = inst->uni_features[i][l];
-
-        if (!fv) {
-            continue;
-        }
+  int len = inst->size();
 
-        vec.add(fv->idx, fv->val, fv->n, fv->loff, 1.);
+  // should check the tagsidx size
+  std::string entity = inst->raw_forms[0];
 
-        if (i > 0) {
-            int prev_lid = tagsidx[i-1];
-            int idx = model->space.index(prev_lid, l);
-            vec.add(idx, 1.);
-        }
-    }
-}
+  int tag = inst->tagsidx[0];
+  int tag_prefix = -1;
+  int tag_suffix = tag % __num_ne_types__;
 
-Model * NER::truncate(void) {
-    Model * new_model = new Model;
-    // copy the label indexable map to the new model
-    for (int i = 0; i < model->labels.size(); ++ i) {
-        const char * key = model->labels.at(i);
-        new_model->labels.push(key);
-    }
+  std::string entity_tag = (tag == 12 ? "O" : __ne_types__[tag_suffix]);
+  for (int i = 1; i < len; ++ i) {
+    tag = tagsidx[i];
 
-    TRACE_LOG("building labels map is done");
-
-    int L = new_model->num_labels();
-    new_model->space.set_num_labels(L);
-
-    // iterate over the feature space and see if the parameter value equals to zero
-    for (FeatureSpaceIterator itx = model->space.begin(); 
-            itx != model->space.end(); 
-            ++ itx) {
-        const char * key = itx.key();
-        int tid = itx.tid();
-        int id = model->space.index(tid, key);
-
-        bool flag = false;
-        for (int l = 0; l < L; ++ l) {
-            double p = model->param.dot(id + l);
-            if (p != 0.) {
-                flag = true;
-            }
-        }
+    tag_prefix = tag / __num_ne_types__;
+    tag_suffix = (tag % __num_ne_types__);
 
-        if (!flag) {
-            continue;
-        }
+    if (tag_prefix == beg_tag0 || tag_prefix == beg_tag1 || tag_prefix == beg_tag2) {
+      entities.push_back(entity);
+      entities_tags.push_back(entity_tag);
 
-        new_model->space.retrieve(tid, key, true);
-    }
-    TRACE_LOG("Scanning old features space, building new feature space is done");
-
-    new_model->param.realloc(new_model->space.dim());
-    TRACE_LOG("Parameter dimension of new model is [%d]", new_model->space.dim());
-
-    for (FeatureSpaceIterator itx = new_model->space.begin();
-            itx != new_model->space.end();
-            ++ itx) {
-        const char * key = itx.key();
-        int tid = itx.tid();
-
-        int old_id = model->space.index(tid, key);
-        int new_id = new_model->space.index(tid, key);
-
-        for (int l = 0; l < L; ++ l) {
-            // pay attention to this place, use average should be set true
-            // some dirty code
-            new_model->param._W[new_id + l]         = model->param._W[old_id + l];
-            new_model->param._W_sum[new_id + l]     = model->param._W_sum[old_id + l];
-            new_model->param._W_time[new_id + l]    = model->param._W_time[old_id + l];
-        }
+      entity = inst->raw_forms[i];
+      entity_tag = (tag == 12 ? "O" : __ne_types__[tag_suffix]);
+    } else {
+      entity += inst->raw_forms[i];
     }
+  }
+  entities.push_back(entity);
+  entities_tags.push_back(entity_tag);
+}
 
-    for (int pl = 0; pl < L; ++ pl) {
-        for (int l = 0; l < L; ++ l) {
-            int old_id = model->space.index(pl, l);
-            int new_id = new_model->space.index(pl, l);
+void
+NER::calculate_scores(Instance * inst, bool use_avg) {
+  int len = inst->size();
+  int L = model->num_labels();
+  for (int i = 0; i < len; ++ i) {
+    for (int l = 0; l < L; ++ l) {
+      FeatureVector * fv = inst->uni_features[i][l];
+      if (!fv) {
+        continue;
+      }
 
-            new_model->param._W[new_id]         = model->param._W[old_id];
-            new_model->param._W_sum[new_id]     = model->param._W_sum[old_id];
-            new_model->param._W_time[new_id]    = model->param._W_time[old_id];
-        }
+      inst->uni_scores[i][l] = model->param.dot(inst->uni_features[i][l], use_avg);
     }
-    TRACE_LOG("Building new model is done");
+  }
 
-    for (SmartMap<int>::const_iterator itx = model->cluster_lexicon.begin();
-            itx != model->cluster_lexicon.end();
-            ++ itx) {
-        new_model->cluster_lexicon.set(itx.key(), (*itx.value()));
+  for (int pl = 0; pl < L; ++ pl) {
+    for (int l = 0; l < L; ++ l) {
+      int idx = model->space.index(pl, l);
+      inst->bi_scores[pl][l] = model->param.dot(idx, use_avg);
     }
-
-    return new_model;
+  }
 }
 
-void NER::train(void) {
-    const char * train_file = train_opt.train_file.c_str();
+void
+NER::collect_features(Instance * inst,
+                      const std::vector<int> & tagsidx,
+                      math::SparseVec & vec) {
+  int len = inst->size();
 
-    // read in training instance
-    if (!read_instance(train_file)) {
-        ERROR_LOG("Training file doesn't exist");
+  vec.zero();
+  for (int i = 0; i < len; ++ i) {
+    int l = tagsidx[i];
+    const FeatureVector * fv = inst->uni_features[i][l];
+
+    if (!fv) {
+      continue;
     }
 
-    TRACE_LOG("Read in [%d] instances.", train_dat.size());
+    vec.add(fv->idx, fv->val, fv->n, fv->loff, 1.);
 
-    model = new Model;
-    // build tag dictionary, map string tag to index
-    TRACE_LOG("Start build configuration");
-    build_configuration();
-    TRACE_LOG("Build configuration is done.");
-    TRACE_LOG("Number of labels: [%d]", model->labels.size());
+    if (i > 0) {
+      int prev_lid = tagsidx[i-1];
+      int idx = model->space.index(prev_lid, l);
+      vec.add(idx, 1.);
+    }
+  }
+}
 
-    // build feature space from the training instance
-    TRACE_LOG("Start building feature space.");
-    build_feature_space();
-    TRACE_LOG("Building feature space is done.");
-    TRACE_LOG("Number of features: [%d]", model->space.num_features());
+Model *
+NER::truncate(void) {
+  Model * new_model = new Model;
+  // copy the label indexable map to the new model
+  for (int i = 0; i < model->labels.size(); ++ i) {
+    const char * key = model->labels.at(i);
+    new_model->labels.push(key);
+  }
 
-    model->param.realloc(model->space.dim());
-    TRACE_LOG("Allocate [%d] dimensition parameter.", model->space.dim());
+  TRACE_LOG("building labels map is done");
 
-    NERWriter writer(std::cout);
+  int L = new_model->num_labels();
+  new_model->space.set_num_labels(L);
 
-    if (train_opt.algorithm == "mira") {
-        // use mira algorithm
-        /*kbest_decoder = new KBestDecoder(L);
+  // iterate over the feature space and see if the parameter value equals to zero
+  for (FeatureSpaceIterator itx = model->space.begin();
+      itx != model->space.end();
+      ++ itx) {
+    const char * key = itx.key();
+    int tid = itx.tid();
+    int id = model->space.index(tid, key);
 
-        for (int iter = 0; iter < train_opt.max_iter; ++ iter) {
-            for (int i = 0; i < train_dat.size(); ++ i) {
-                extract_features(train_dat[i]);
-                calculate_scores(train_dat[i]);
+    bool flag = false;
+    for (int l = 0; l < L; ++ l) {
+      double p = model->param.dot(id + l);
+      if (p != 0.) {
+        flag = true;
+      }
+    }
 
-                KBestDecoder::KBestDecodeResult result;
-                kbest_decoder->decode(train_dat[i], result);
-            }
-        }*/
-    } else {
-        // use pa or average perceptron algorithm
-        rulebase::RuleBase base(model->labels);
-        decoder = new Decoder(model->num_labels(), base);
-        TRACE_LOG("Allocated plain decoder");
-
-        for (int iter = 0; iter < train_opt.max_iter; ++ iter) {
-            TRACE_LOG("Training iteraition [%d]", (iter + 1));
-            for (int i = 0; i < train_dat.size(); ++ i) {
-                // extract_features(train_dat[i]);
-
-                Instance * inst = train_dat[i];
-                calculate_scores(inst, false);
-                decoder->decode(inst);
-
-                if (inst->features.dim() == 0) {
-                    collect_features(inst, inst->tagsidx, inst->features);
-                }
-                collect_features(inst, inst->predicted_tagsidx, inst->predicted_features);
-
-
-                if (train_opt.algorithm == "pa") {
-                    SparseVec update_features;
-                    update_features.zero();
-                    update_features.add(train_dat[i]->features, 1.);
-                    update_features.add(train_dat[i]->predicted_features, -1.);
-
-                    double error = train_dat[i]->num_errors();
-                    double score = model->param.dot(update_features, false);
-                    double norm = update_features.L2();
-
-                    double step = 0.;
-                    if (norm < EPS) {
-                       step = 0;
-                    } else {
-                        step = (error - score) / norm;
-                    }
-
-                    model->param.add(update_features,
-                            iter * train_dat.size() + i + 1,
-                            step);
-                } else if (train_opt.algorithm == "ap") {
-                    SparseVec update_features;
-                    update_features.zero();
-                    update_features.add(train_dat[i]->features, 1.);
-                    update_features.add(train_dat[i]->predicted_features, -1.);
-
-                    model->param.add(update_features,
-                            iter * train_dat.size() + i + 1,
-                            1.);
-                }
-
-                if ((i+1) % train_opt.display_interval == 0) {
-                    TRACE_LOG("[%d] instances is trained.", i+1);
-                }
-            }
-            model->param.flush( train_dat.size() * (iter + 1) );
-
-            Model * new_model = truncate();
-            swap(model, new_model);
-            evaluate();
-
-            std::string saved_model_file = (train_opt.model_name + "." + strutils::to_str(iter) + ".model");
-            std::ofstream ofs(saved_model_file.c_str(), std::ofstream::binary);
-
-            swap(model, new_model);
-            new_model->save(ofs);
-            delete new_model;
-
-            TRACE_LOG("Model for iteration [%d] is saved to [%s]",
-                    iter + 1,
-                    saved_model_file.c_str());
-        }
+    if (!flag) {
+      continue;
     }
-}
 
-void NER::evaluate(void) {
-    const char * holdout_file = train_opt.holdout_file.c_str();
+    new_model->space.retrieve(tid, key, true);
+  }
+  TRACE_LOG("Scanning old features space, building new feature space is done");
 
-    ifstream ifs(holdout_file);
+  new_model->param.realloc(new_model->space.dim());
+  TRACE_LOG("Parameter dimension of new model is [%d]", new_model->space.dim());
 
-    if (!ifs) {
-        ERROR_LOG("Failed to open holdout file.");
-        return;
+  for (FeatureSpaceIterator itx = new_model->space.begin();
+      itx != new_model->space.end();
+      ++ itx) {
+    const char * key = itx.key();
+    int tid = itx.tid();
+
+    int old_id = model->space.index(tid, key);
+    int new_id = new_model->space.index(tid, key);
+
+    for (int l = 0; l < L; ++ l) {
+      // pay attention to this place, use average should be set true
+      // some dirty code
+      new_model->param._W[new_id + l]     = model->param._W[old_id + l];
+      new_model->param._W_sum[new_id + l]   = model->param._W_sum[old_id + l];
+      new_model->param._W_time[new_id + l]  = model->param._W_time[old_id + l];
     }
+  }
 
-    NERReader reader(ifs, true);
-    NERWriter writer(std::cout);
-    Instance * inst = NULL;
+  for (int pl = 0; pl < L; ++ pl) {
+    for (int l = 0; l < L; ++ l) {
+      int old_id = model->space.index(pl, l);
+      int new_id = new_model->space.index(pl, l);
 
-    // some dirty hard code and trick
-    int beg_tag0 = (model->labels.index( "B-Nh" ) / __num_ne_types__);
-    int beg_tag1 = (model->labels.index( "S-Nh" ) / __num_ne_types__);
-    int beg_tag2 = (model->labels.index( "O" ) / __num_ne_types__);
+      new_model->param._W[new_id]     = model->param._W[old_id];
+      new_model->param._W_sum[new_id]   = model->param._W_sum[old_id];
+      new_model->param._W_time[new_id]  = model->param._W_time[old_id];
+    }
+  }
+  TRACE_LOG("Building new model is done");
 
+  for (SmartMap<int>::const_iterator itx = model->cluster_lexicon.begin();
+      itx != model->cluster_lexicon.end();
+      ++ itx) {
+    new_model->cluster_lexicon.set(itx.key(), (*itx.value()));
+  }
 
-    int num_recalled_entities = 0;
-    int num_predicted_entities = 0;
-    int num_gold_entities = 0;
+  return new_model;
+}
 
-    int L = model->num_labels();
+void
+NER::train(void) {
+  const char * train_file = train_opt.train_file.c_str();
+
+  // read in training instance
+  if (!read_instance(train_file)) {
+    ERROR_LOG("Training file doesn't exist");
+  }
+
+  TRACE_LOG("Read in [%d] instances.", train_dat.size());
+
+  model = new Model;
+  // build tag dictionary, map string tag to index
+  TRACE_LOG("Start build configuration");
+  build_configuration();
+  TRACE_LOG("Build configuration is done.");
+  TRACE_LOG("Number of labels: [%d]", model->labels.size());
+
+  // build feature space from the training instance
+  TRACE_LOG("Start building feature space.");
+  build_feature_space();
+  TRACE_LOG("Building feature space is done.");
+  TRACE_LOG("Number of features: [%d]", model->space.num_features());
+
+  model->param.realloc(model->space.dim());
+  TRACE_LOG("Allocate [%d] dimensition parameter.", model->space.dim());
+
+  NERWriter writer(std::cout);
+
+  if (train_opt.algorithm == "mira") {
+    // use mira algorithm
+    /*kbest_decoder = new KBestDecoder(L);
+
+    for (int iter = 0; iter < train_opt.max_iter; ++ iter) {
+      for (int i = 0; i < train_dat.size(); ++ i) {
+        extract_features(train_dat[i]);
+        calculate_scores(train_dat[i]);
+
+        KBestDecoder::KBestDecodeResult result;
+        kbest_decoder->decode(train_dat[i], result);
+      }
+    }*/
+  } else {
+    // use pa or average perceptron algorithm
+    rulebase::RuleBase base(model->labels);
+    decoder = new Decoder(model->num_labels(), base);
+    TRACE_LOG("Allocated plain decoder");
 
-    int c = 0;
-    while ((inst = reader.next())) {
-        int len = inst->size();
-        inst->tagsidx.resize(len);
-        for (int i = 0; i < len; ++ i) {
-            inst->tagsidx[i] = model->labels.index(inst->tags[i]);
-        }
+    for (int iter = 0; iter < train_opt.max_iter; ++ iter) {
+      TRACE_LOG("Training iteraition [%d]", (iter + 1));
+      for (int i = 0; i < train_dat.size(); ++ i) {
+        // extract_features(train_dat[i]);
 
-        extract_features(inst);
-        calculate_scores(inst, true);
+        Instance * inst = train_dat[i];
+        calculate_scores(inst, false);
         decoder->decode(inst);
 
-        // writer.debug(inst);
-        if (inst->entities.size() == 0) {
-            build_entities(inst, 
-                    inst->tagsidx, 
-                    inst->entities, 
-                    inst->entities_tags, 
-                    beg_tag0, 
-                    beg_tag1, 
-                    beg_tag2);
+        if (inst->features.dim() == 0) {
+          collect_features(inst, inst->tagsidx, inst->features);
         }
+        collect_features(inst, inst->predicted_tagsidx, inst->predicted_features);
+
+
+        if (train_opt.algorithm == "pa") {
+          SparseVec update_features;
+          update_features.zero();
+          update_features.add(train_dat[i]->features, 1.);
+          update_features.add(train_dat[i]->predicted_features, -1.);
+
+          double error = train_dat[i]->num_errors();
+          double score = model->param.dot(update_features, false);
+          double norm = update_features.L2();
+
+          double step = 0.;
+          if (norm < EPS) {
+             step = 0;
+          } else {
+            step = (error - score) / norm;
+          }
+
+          model->param.add(update_features,
+                           iter * train_dat.size() + i + 1,
+                           step);
+        } else if (train_opt.algorithm == "ap") {
+          SparseVec update_features;
+          update_features.zero();
+          update_features.add(train_dat[i]->features, 1.);
+          update_features.add(train_dat[i]->predicted_features, -1.);
+
+          model->param.add(update_features,
+                           iter * train_dat.size() + i + 1,
+                           1.);
+        }
+
+        if ((i+1) % train_opt.display_interval == 0) {
+          TRACE_LOG("[%d] instances is trained.", i+1);
+        }
+      }
+      model->param.flush( train_dat.size() * (iter + 1) );
+
+      Model * new_model = truncate();
+      swap(model, new_model);
+      evaluate();
 
-        build_entities(inst, 
-                inst->predicted_tagsidx, 
-                inst->predicted_entities,
-                inst->predicted_entities_tags, 
-                beg_tag0, 
-                beg_tag1,
-                beg_tag2);
+      std::string saved_model_file = (train_opt.model_name
+                                      + "."
+                                      + strutils::to_str(iter)
+                                      + ".model");
+      std::ofstream ofs(saved_model_file.c_str(), std::ofstream::binary);
 
-        num_recalled_entities += inst->num_recalled_entites();
-        num_predicted_entities += inst->num_predicted_entities();
-        num_gold_entities += inst->num_gold_entities();
+      swap(model, new_model);
+      new_model->save(ofs);
+      delete new_model;
 
-        delete inst;
+      TRACE_LOG("Model for iteration [%d] is saved to [%s]",
+          iter + 1,
+          saved_model_file.c_str());
     }
+  }
+}
+
+void NER::evaluate(void) {
+  const char * holdout_file = train_opt.holdout_file.c_str();
 
-    double p = (double)num_recalled_entities / num_predicted_entities;
-    double r = (double)num_recalled_entities / num_gold_entities;
-    double f = 2 * p * r / (p + r);
+  ifstream ifs(holdout_file);
 
-    TRACE_LOG("P: %lf ( %d / %d )", p, num_recalled_entities, num_predicted_entities);
-    TRACE_LOG("R: %lf ( %d / %d )", r, num_recalled_entities, num_gold_entities);
-    TRACE_LOG("F: %lf" , f); 
+  if (!ifs) {
+    ERROR_LOG("Failed to open holdout file.");
     return;
+  }
+
+  NERReader reader(ifs, true);
+  NERWriter writer(std::cout);
+  Instance * inst = NULL;
+
+  // some dirty hard code and trick
+  int beg_tag0 = (model->labels.index( "B-Nh" ) / __num_ne_types__);
+  int beg_tag1 = (model->labels.index( "S-Nh" ) / __num_ne_types__);
+  int beg_tag2 = (model->labels.index( "O" ) / __num_ne_types__);
+
+
+  int num_recalled_entities = 0;
+  int num_predicted_entities = 0;
+  int num_gold_entities = 0;
+
+  while ((inst = reader.next())) {
+    int len = inst->size();
+    inst->tagsidx.resize(len);
+    for (int i = 0; i < len; ++ i) {
+      inst->tagsidx[i] = model->labels.index(inst->tags[i]);
+    }
+
+    extract_features(inst);
+    calculate_scores(inst, true);
+    decoder->decode(inst);
+
+    // writer.debug(inst);
+    if (inst->entities.size() == 0) {
+      build_entities(inst,
+          inst->tagsidx,
+          inst->entities,
+          inst->entities_tags,
+          beg_tag0,
+          beg_tag1,
+          beg_tag2);
+    }
+
+    build_entities(inst,
+        inst->predicted_tagsidx,
+        inst->predicted_entities,
+        inst->predicted_entities_tags,
+        beg_tag0,
+        beg_tag1,
+        beg_tag2);
+
+    num_recalled_entities += inst->num_recalled_entites();
+    num_predicted_entities += inst->num_predicted_entities();
+    num_gold_entities += inst->num_gold_entities();
+
+    delete inst;
+  }
+
+  double p = (double)num_recalled_entities / num_predicted_entities;
+  double r = (double)num_recalled_entities / num_gold_entities;
+  double f = 2 * p * r / (p + r);
+
+  TRACE_LOG("P: %lf ( %d / %d )", p, num_recalled_entities, num_predicted_entities);
+  TRACE_LOG("R: %lf ( %d / %d )", r, num_recalled_entities, num_gold_entities);
+  TRACE_LOG("F: %lf" , f);
+  return;
 }
 
 void NER::test(void) {
-    // load model
-    const char * model_file = test_opt.model_file.c_str();
-    ifstream mfs(model_file, std::ifstream::binary);
+  // load model
+  const char * model_file = test_opt.model_file.c_str();
+  ifstream mfs(model_file, std::ifstream::binary);
 
-    if (!mfs) {
-        ERROR_LOG("Failed to load model");
-        return;
-    }
+  if (!mfs) {
+    ERROR_LOG("Failed to load model");
+    return;
+  }
 
-    model = new Model;
-    if (!model->load(mfs)) {
-        ERROR_LOG("Failed to load model");
-        return;
-    }
+  model = new Model;
+  if (!model->load(mfs)) {
+    ERROR_LOG("Failed to load model");
+    return;
+  }
 
-    TRACE_LOG("Number of labels                 [%d]", model->num_labels());
-    TRACE_LOG("Number of features               [%d]", model->space.num_features());
-    TRACE_LOG("Number of dimension              [%d]", model->space.dim());
+  TRACE_LOG("Number of labels         [%d]", model->num_labels());
+  TRACE_LOG("Number of features       [%d]", model->space.num_features());
+  TRACE_LOG("Number of dimension      [%d]", model->space.dim());
 
-    const char * test_file = test_opt.test_file.c_str();
+  const char * test_file = test_opt.test_file.c_str();
 
-    ifstream ifs(test_file);
+  ifstream ifs(test_file);
 
-    if (!ifs) {
-        ERROR_LOG("Failed to open holdout file.");
-        return;
-    }
+  if (!ifs) {
+    ERROR_LOG("Failed to open holdout file.");
+    return;
+  }
 
-    rulebase::RuleBase base(model->labels);
-    decoder = new Decoder(model->num_labels(), base);
-    NERReader reader(ifs);
-    NERWriter writer(cout);
-    Instance * inst = NULL;
+  rulebase::RuleBase base(model->labels);
+  decoder = new Decoder(model->num_labels(), base);
+  NERReader reader(ifs);
+  NERWriter writer(cout);
+  Instance * inst = NULL;
 
-    // int beg_tag0 = model->labels.index( __b__ );
-    // int beg_tag1 = model->labels.index( __s__ );
+  // int beg_tag0 = model->labels.index( __b__ );
+  // int beg_tag1 = model->labels.index( __s__ );
 
-    double before = get_time();
+  double before = get_time();
 
-    while ((inst = reader.next())) {
-        int len = inst->size();
-        inst->tagsidx.resize(len);
+  while ((inst = reader.next())) {
+    int len = inst->size();
+    inst->tagsidx.resize(len);
 
-        extract_features(inst);
-        calculate_scores(inst, true);
-        decoder->decode(inst);
+    extract_features(inst);
+    calculate_scores(inst, true);
+    decoder->decode(inst);
 
-        writer.write(inst);
-        delete inst;
-    }
+    writer.write(inst);
+    delete inst;
+  }
 
-    double after = get_time();
-    TRACE_LOG("Eclipse time %lf", after - before);
+  double after = get_time();
+  TRACE_LOG("Eclipse time %lf", after - before);
 
-    sleep(1000000);
-    return;
+  sleep(1000000);
+  return;
 }
 
 void NER::dump() {
-    // load model
-    const char * model_file = dump_opt.model_file.c_str();
-    ifstream mfs(model_file, std::ifstream::binary);
-
-    if (!mfs) {
-        ERROR_LOG("Failed to load model");
-        return;
-    }
+  // load model
+  const char * model_file = dump_opt.model_file.c_str();
+  ifstream mfs(model_file, std::ifstream::binary);
 
-    model = new Model;
-    if (!model->load(mfs)) {
-        ERROR_LOG("Failed to load model");
-        return;
-    }
-
-    int L = model->num_labels();
-    TRACE_LOG("Number of labels                 [%d]", model->num_labels());
-    TRACE_LOG("Number of features               [%d]", model->space.num_features());
-    TRACE_LOG("Number of dimension              [%d]", model->space.dim());
-
-    for (FeatureSpaceIterator itx = model->space.begin(); itx != model->space.end(); ++ itx) {
-        const char * key = itx.key();
-        int tid = itx.tid();
-        int id = model->space.index(tid, key);
+  if (!mfs) {
+    ERROR_LOG("Failed to load model");
+    return;
+  }
 
-        for (int l = 0; l < L; ++ l) {
-            std::cout << key << " ( " << id + l << " ) "
+  model = new Model;
+  if (!model->load(mfs)) {
+    ERROR_LOG("Failed to load model");
+    return;
+  }
+
+  int L = model->num_labels();
+  TRACE_LOG("Number of labels         [%d]", model->num_labels());
+  TRACE_LOG("Number of features       [%d]", model->space.num_features());
+  TRACE_LOG("Number of dimension      [%d]", model->space.dim());
+
+  for (FeatureSpaceIterator itx = model->space.begin();
+       itx != model->space.end();
+       ++ itx) {
+    const char * key = itx.key();
+    int tid = itx.tid();
+    int id = model->space.index(tid, key);
+
+    for (int l = 0; l < L; ++ l) {
+      std::cout << key << " ( " << id + l << " ) "
                 << " --> "
                 << model->param.dot(id + l)
                 << std::endl;
-        }
     }
+  }
 
-    for (int pl = 0; pl < L; ++ pl) {
-        for (int l = 0; l < L; ++ l) {
-            int id = model->space.index(pl, l);
-            std::cout << pl << " --> " << l << " " << model->param.dot(id) << std::endl;
-        }
+  for (int pl = 0; pl < L; ++ pl) {
+    for (int l = 0; l < L; ++ l) {
+      int id = model->space.index(pl, l);
+      std::cout << pl << " --> " << l << " " << model->param.dot(id) << std::endl;
     }
+  }
 }
 
-}       //  end for namespace segmentor
-}       //  end for namespace ltp
+}     //  end for namespace segmentor
+}     //  end for namespace ltp
diff --git a/src/ner/ner.h b/src/ner/ner.h
index 1ec60bc5e..4c13f4514 100644
--- a/src/ner/ner.h
+++ b/src/ner/ner.h
@@ -10,115 +10,115 @@ namespace ner {
 
 class NER {
 public:
-    NER();
-    NER(ltp::utility::ConfigParser & cfg);
-    ~NER();
+  NER();
+  NER(ltp::utility::ConfigParser & cfg);
+  ~NER();
 
-    void run();
+  void run();
 
 private:
-    /*
-     * parse the configuration, return true on success, otherwise false
-     *
-     *  @param[in]  cfg     the config class
-     *  @return     bool    return true on success, otherwise false
-     */
-    bool parse_cfg(ltp::utility::ConfigParser & cfg);
-
-    /*
-     * read instances from file and store them in train_dat
-     *
-     *  @param[in]  file_name   the filename
-     *  @return     bool        true on success, otherwise false
-     */
-    bool read_instance( const char * file_name );
-    void build_configuration(void);
-    void build_feature_space(void);
-
-    /*
-     * the training process
-     */
-    void train(void);
-
-    /*
-     * the evaluating process
-     */
-    void evaluate(void);
-
-    /*
-     * the testing process
-     */
-    void test(void);
-
-    /*
-     * the dumping model process
-     */
-    void dump(void);
-
-    /*
-     * do feature trauncation on the model. create a model duplation
-     * on the model and return their
-     *
-     *  @return Model   the duplication of the model
-     */
-    Model * truncate(void);
+  /*
+   * parse the configuration, return true on success, otherwise false
+   *
+   *  @param[in]  cfg   the config class
+   *  @return     bool  return true on success, otherwise false
+   */
+  bool parse_cfg(ltp::utility::ConfigParser & cfg);
+
+  /*
+   * read instances from file and store them in train_dat
+   *
+   *  @param[in]  file_name   the filename
+   *  @return     bool        true on success, otherwise false
+   */
+  bool read_instance( const char * file_name );
+  void build_configuration(void);
+  void build_feature_space(void);
+
+  /*
+   * the training process
+   */
+  void train(void);
+
+  /*
+   * the evaluating process
+   */
+  void evaluate(void);
+
+  /*
+   * the testing process
+   */
+  void test(void);
+
+  /*
+   * the dumping model process
+   */
+  void dump(void);
+
+  /*
+   * do feature trauncation on the model. create a model duplation
+   * on the model and return their
+   *
+   *  @return Model   the duplication of the model
+   */
+  Model * truncate(void);
 protected:
-    /*
-     * extract features from one instance,
-     *
-     */
-    void extract_features(Instance * inst, bool create = false);
-
-    /*
-     * build words from tags for certain instance
-     *
-     *  @param[in/out]  inst    the instance
-     *  @param[out]     words   the output words
-     *  @param[in]      tagsidx the index of tags
-     *  @param[in]      begtag0 first of the word begin tag
-     *  @param[in]      begtag1 second of the word begin tag
-     */
-    void build_entities(Instance * inst, 
-            const std::vector<int> & tagsidx,
-            std::vector<std::string> & entities,
-            std::vector<std::string> & entities_tags,
-            int beg_tag0,
-            int beg_tag1,
-            int beg_tag2);
-
-    /*
-     * cache all the score for the certain instance.
-     *
-     *  @param[in/out]  inst    the instance
-     *  @param[in]      use_avg use to specify use average parameter
-     */
-    void calculate_scores(Instance * inst, bool use_avg);
-
-    /*
-     * collect feature when given the tags index
-     *
-     *  @param[in]      inst    the instance
-     *  @param[in]      tagsidx the tags index
-     *  @param[out]     vec     the output sparse vector
-     */
-    void collect_features(Instance * inst, 
-            const std::vector<int> & tagsidx, 
-            ltp::math::SparseVec & vec);
+  /*
+   * extract features from one instance,
+   *
+   */
+  void extract_features(Instance * inst, bool create = false);
+
+  /*
+   * build words from tags for certain instance
+   *
+   *  @param[in/out]  inst    the instance
+   *  @param[out]     words   the output words
+   *  @param[in]      tagsidx the index of tags
+   *  @param[in]      begtag0 first of the word begin tag
+   *  @param[in]      begtag1 second of the word begin tag
+   */
+  void build_entities(Instance * inst,
+                      const std::vector<int> & tagsidx,
+                      std::vector<std::string> & entities,
+                      std::vector<std::string> & entities_tags,
+                      int beg_tag0,
+                      int beg_tag1,
+                      int beg_tag2);
+
+  /*
+   * cache all the score for the certain instance.
+   *
+   *  @param[in/out]  inst  the instance
+   *  @param[in]    use_avg use to specify use average parameter
+   */
+  void calculate_scores(Instance * inst, bool use_avg);
+
+  /*
+   * collect feature when given the tags index
+   *
+   *  @param[in]    inst  the instance
+   *  @param[in]    tagsidx the tags index
+   *  @param[out]   vec   the output sparse vector
+   */
+  void collect_features(Instance * inst,
+                        const std::vector<int> & tagsidx,
+                        ltp::math::SparseVec & vec);
 
 private:
-    bool    __TRAIN__;
-    bool    __TEST__;
-    bool    __DUMP__;
+  bool  __TRAIN__;
+  bool  __TEST__;
+  bool  __DUMP__;
 
 private:
-    std::vector< Instance * > train_dat;
+  std::vector< Instance * > train_dat;
 
 protected:
-    Model * model;
-    Decoder * decoder;
+  Model * model;
+  Decoder * decoder;
 };
 
-}       //  end for namespace segmentor
-}       //  end for namespace ltp
+}     //  end for namespace segmentor
+}     //  end for namespace ltp
 
 #endif  //  end for __LTP_NER_NER_H__
diff --git a/src/ner/ner_dll.cpp b/src/ner/ner_dll.cpp
index a77833c51..d04761e71 100644
--- a/src/ner/ner_dll.cpp
+++ b/src/ner/ner_dll.cpp
@@ -11,87 +11,87 @@
 
 class NERWrapper : public ltp::ner::NER {
 public:
-    NERWrapper() :
-        beg_tag0(-1),
-        beg_tag1(-1) {}
+  NERWrapper()
+    : beg_tag0(-1),
+      beg_tag1(-1) {}
 
-    ~NERWrapper() {}
+  ~NERWrapper() {}
 
-    bool load(const char * model_file) {
-        std::ifstream mfs(model_file, std::ifstream::binary);
+  bool load(const char * model_file) {
+    std::ifstream mfs(model_file, std::ifstream::binary);
 
-        if (!mfs) {
-            return false;
-        }
-
-        model = new ltp::ner::Model;
-        if (!model->load(mfs)) {
-            delete model;
-            return false;
-        }
-
-        // beg_tag0 = model->labels.index( );
-        // beg_tag1 = model->labels.index( );
+    if (!mfs) {
+      return false;
+    }
 
-        return true;
+    model = new ltp::ner::Model;
+    if (!model->load(mfs)) {
+      delete model;
+      return false;
     }
 
-    int recognize(const std::vector<std::string> & words,
-            const std::vector<std::string> & postags,
-            std::vector<std::string> & tags) {
-        ltp::ner::rulebase::RuleBase base(model->labels);
-        ltp::ner::Decoder deco(model->num_labels(), base);
+    // beg_tag0 = model->labels.index( );
+    // beg_tag1 = model->labels.index( );
 
-        ltp::ner::Instance * inst = new ltp::ner::Instance;
-        if (words.size() != postags.size()) {
-            return 0;
-        }
+    return true;
+  }
 
-        for (int i = 0; i < words.size(); ++ i) {
-            inst->forms.push_back(ltp::strutils::chartypes::sbc2dbc_x(words[i]));
-            inst->postags.push_back(postags[i]);
-        }
+  int recognize(const std::vector<std::string> & words,
+      const std::vector<std::string> & postags,
+      std::vector<std::string> & tags) {
+    ltp::ner::rulebase::RuleBase base(model->labels);
+    ltp::ner::Decoder deco(model->num_labels(), base);
 
-        ltp::ner::NER::extract_features(inst);
-        ltp::ner::NER::calculate_scores(inst, true);
-        deco.decode(inst);
+    ltp::ner::Instance * inst = new ltp::ner::Instance;
+    if (words.size() != postags.size()) {
+      return 0;
+    }
+
+    for (int i = 0; i < words.size(); ++ i) {
+      inst->forms.push_back(ltp::strutils::chartypes::sbc2dbc_x(words[i]));
+      inst->postags.push_back(postags[i]);
+    }
 
-        for (int i = 0; i < words.size(); ++ i) {
-            tags.push_back(model->labels.at(inst->predicted_tagsidx[i]));
-        }
+    ltp::ner::NER::extract_features(inst);
+    ltp::ner::NER::calculate_scores(inst, true);
+    deco.decode(inst);
 
-        delete inst;
-        return tags.size();
+    for (int i = 0; i < words.size(); ++ i) {
+      tags.push_back(model->labels.at(inst->predicted_tagsidx[i]));
     }
 
+    delete inst;
+    return tags.size();
+  }
+
 private:
-    int beg_tag0;
-    int beg_tag1;
+  int beg_tag0;
+  int beg_tag1;
 };
 
 void * ner_create_recognizer(const char * path) {
-    NERWrapper * wrapper = new NERWrapper();
+  NERWrapper * wrapper = new NERWrapper();
 
-    if (!wrapper->load(path)) {
-        return 0;
-    }
+  if (!wrapper->load(path)) {
+    return 0;
+  }
 
-    return reinterpret_cast<void *>(wrapper);
+  return reinterpret_cast<void *>(wrapper);
 }
 
 int ner_release_recognizer(void * ner) {
-    if (!ner) {
-        return -1;
-    }
-    delete reinterpret_cast<NERWrapper *>(ner);
-    return 0;
+  if (!ner) {
+    return -1;
+  }
+  delete reinterpret_cast<NERWrapper *>(ner);
+  return 0;
 }
 
 int ner_recognize(void * ner,
-        const std::vector<std::string> & words,
-        const std::vector<std::string> & postags,
-        std::vector<std::string> & tags) {
-    NERWrapper * wrapper = 0;
-    wrapper = reinterpret_cast<NERWrapper *>(ner);
-    return wrapper->recognize(words, postags, tags);
+    const std::vector<std::string> & words,
+    const std::vector<std::string> & postags,
+    std::vector<std::string> & tags) {
+  NERWrapper * wrapper = 0;
+  wrapper = reinterpret_cast<NERWrapper *>(ner);
+  return wrapper->recognize(words, postags, tags);
 }
diff --git a/src/ner/ner_dll.h b/src/ner/ner_dll.h
index a1c5f125f..cbc1c3aab 100644
--- a/src/ner/ner_dll.h
+++ b/src/ner/ner_dll.h
@@ -31,7 +31,7 @@ NER_DLL_API void * ner_create_recognizer(const char * path);
  *  @param[in]  segmentor   the segmentor
  *  @return     int         i don't know
  */
-NER_DLL_API int ner_release_recognizer(void * ner); 
+NER_DLL_API int ner_release_recognizer(void * ner);
 
 /*
  * run segment on the given segmentor
@@ -41,8 +41,8 @@ NER_DLL_API int ner_release_recognizer(void * ner);
  *  @return     int         the number of word tokens
  */
 NER_DLL_API int ner_recognize(void * ner,
-        const std::vector<std::string> & words,
-        const std::vector<std::string> & postags,
-        std::vector<std::string> & tags);
+                              const std::vector<std::string> & words,
+                              const std::vector<std::string> & postags,
+                              std::vector<std::string> & tags);
 
 #endif  //  end for __LTP_NER_DLL_H__
diff --git a/src/ner/nerio.h b/src/ner/nerio.h
index e99bd769e..35489cf27 100644
--- a/src/ner/nerio.h
+++ b/src/ner/nerio.h
@@ -15,115 +15,115 @@ using namespace ltp::strutils;
 
 class NERReader {
 public:
-    NERReader(istream & _ifs, bool _train = false, int _style = 4) : 
-        ifs(_ifs),
-        train(_train),
-        style(_style) {}
-
-    Instance * next() {
-        if (ifs.eof()) {
-            return 0;
-        }
-
-        Instance * inst = new Instance;
-        std::string  line;
-
-        std::getline(ifs, line);
-        strutils::chomp(line);
-
-        if (line.size() == 0) {
+  NERReader(istream & _ifs, bool _train = false, int _style = 4)
+    : ifs(_ifs),
+      train(_train),
+      style(_style) {}
+
+  Instance * next() {
+    if (ifs.eof()) {
+      return 0;
+    }
+
+    Instance * inst = new Instance;
+    std::string  line;
+
+    std::getline(ifs, line);
+    strutils::chomp(line);
+
+    if (line.size() == 0) {
+      delete inst;
+      return 0;
+    }
+
+    std::vector<std::string> words = split(line);
+    int found;
+
+    for (int i = 0; i < words.size(); ++ i) {
+      if (train) {
+        found = words[i].find_last_of('#');
+        if (found != std::string::npos) {
+          std::string tag = words[i].substr(found + 1);
+          inst->tags.push_back(tag);
+          words[i] = words[i].substr(0, found);
+
+          found = words[i].find_last_of('/');
+          if (found != std::string::npos) {
+            std::string postag = words[i].substr(found + 1);
+            inst->postags.push_back(postag);
+            words[i] = words[i].substr(0, found);
+
+            inst->raw_forms.push_back(words[i]);
+            inst->forms.push_back(strutils::chartypes::sbc2dbc_x(words[i]));
+          } else {
             delete inst;
             return 0;
+          }
+        } else {
+          delete inst;
+          return 0;
         }
-
-        std::vector<std::string> words = split(line);
-        int found;
-
-        for (int i = 0; i < words.size(); ++ i) {
-            if (train) {
-                found = words[i].find_last_of('#');
-                if (found != std::string::npos) {
-                    std::string tag = words[i].substr(found + 1);
-                    inst->tags.push_back(tag);
-                    words[i] = words[i].substr(0, found);
-
-                    found = words[i].find_last_of('/');
-                    if (found != std::string::npos) {
-                        std::string postag = words[i].substr(found + 1);
-                        inst->postags.push_back(postag);
-                        words[i] = words[i].substr(0, found);
-
-                        inst->raw_forms.push_back(words[i]);
-                        inst->forms.push_back(strutils::chartypes::sbc2dbc_x(words[i]));
-                    } else {
-                        delete inst;
-                        return 0;
-                    }
-                } else {
-                    delete inst;
-                    return 0;
-                }
-            } else {
-                found = words[i].find_last_of('/');
-                if (found != std::string::npos) {
-                    std::string postag = words[i].substr(found + 1);
-                    inst->postags.push_back(postag);
-                    words[i] = words[i].substr(0, found);
-
-                    inst->raw_forms.push_back(words[i]);
-                    inst->forms.push_back(strutils::chartypes::sbc2dbc_x(words[i]));
-                } else {
-                    delete inst;
-                    return 0;
-                }
-            }
+      } else {
+        found = words[i].find_last_of('/');
+        if (found != std::string::npos) {
+          std::string postag = words[i].substr(found + 1);
+          inst->postags.push_back(postag);
+          words[i] = words[i].substr(0, found);
+
+          inst->raw_forms.push_back(words[i]);
+          inst->forms.push_back(strutils::chartypes::sbc2dbc_x(words[i]));
+        } else {
+          delete inst;
+          return 0;
         }
+      }
+    }
 
-        return inst;
+    return inst;
    }
 private:
-    istream &   ifs;
-    int         style;
-    bool        train;
+  istream &   ifs;
+  int         style;
+  bool        train;
 };
 
 class NERWriter {
 public:
-    NERWriter(std::ostream & _ofs) : ofs(_ofs) {}
-
-    void write(const Instance * inst) {
-        int len = inst->size();
-        if (inst->predicted_tags.size() != len) {
-            return;
-        }
-
-        for (int i = 0; i < len; ++ i) {
-            ofs << inst->forms[i] 
-                << "/" << inst->postags[i]
-                << "#" << inst->predicted_tags[i];
-            if (i + 1 < len ) {
-                ofs << "\t";
-            } else {
-                ofs << std::endl;
-            }
-        }
+  NERWriter(std::ostream & _ofs) : ofs(_ofs) {}
+
+  void write(const Instance * inst) {
+    int len = inst->size();
+    if (inst->predicted_tags.size() != len) {
+      return;
+    }
+
+    for (int i = 0; i < len; ++ i) {
+      ofs << inst->forms[i] 
+        << "/" << inst->postags[i]
+        << "#" << inst->predicted_tags[i];
+      if (i + 1 < len ) {
+        ofs << "\t";
+      } else {
+        ofs << std::endl;
+      }
+    }
    }
 
-    void debug(const Instance * inst, bool show_feat = false) {
-        int len = inst->size();
+  void debug(const Instance * inst, bool show_feat = false) {
+    int len = inst->size();
 
-        for (int i = 0; i < len; ++ i) {
-            ofs << inst->forms[i] 
-                << "\t" << inst->postags[i]
-                << "\t" << inst->tagsidx[i]
-                << "\t" << inst->predicted_tagsidx[i]
-                << std::endl;
-        }
+    for (int i = 0; i < len; ++ i) {
+      ofs << inst->forms[i] 
+        << "\t" << inst->postags[i]
+        << "\t" << inst->tagsidx[i]
+        << "\t" << inst->predicted_tagsidx[i]
+        << std::endl;
+    }
    }
 private:
-    std::ostream & ofs;
+  std::ostream & ofs;
 };
 
-}           //  end for namespace ner
-}           //  end for namespace ltp
-#endif      //  end for __LTP_SEGMENTOR_WRITER_H__
+}       //  end for namespace ner
+}       //  end for namespace ltp
+#endif    //  end for __LTP_SEGMENTOR_WRITER_H__
diff --git a/src/ner/options.h b/src/ner/options.h
index e2a9606ac..652bf6773 100644
--- a/src/ner/options.h
+++ b/src/ner/options.h
@@ -7,26 +7,26 @@ namespace ltp {
 namespace ner {
 
 struct ModelOptions {
-    std::string     model_file;
+  std::string   model_file;
 };
 
 struct TrainOptions {
-    std::string     train_file;
-    std::string     holdout_file;
-    std::string     model_name;
-    std::string     algorithm;
-    int             max_iter;
-    int             display_interval;
+  std::string   train_file;
+  std::string   holdout_file;
+  std::string   model_name;
+  std::string   algorithm;
+  int           max_iter;
+  int           display_interval;
 };
 
 struct TestOptions {
-    std::string     test_file;
-    std::string     model_file;
-    std::string     lexicon_file;
+  std::string   test_file;
+  std::string   model_file;
+  std::string   lexicon_file;
 };
 
 struct DumpOptions {
-    std::string     model_file;
+  std::string   model_file;
 };
 
 extern ModelOptions model_opt;
@@ -34,7 +34,7 @@ extern TrainOptions train_opt;
 extern TestOptions  test_opt;
 extern DumpOptions  dump_opt;
 
-}           //  end for namespace ner
-}           //  end for namespace ltp
+}       //  end for namespace ner
+}       //  end for namespace ltp
 
-#endif      //  end for __LTP_NER_OPTIONS_H__
+#endif    //  end for __LTP_NER_OPTIONS_H__
diff --git a/src/ner/otner.cpp b/src/ner/otner.cpp
index 1a5c0f3c0..6b3763a25 100644
--- a/src/ner/otner.cpp
+++ b/src/ner/otner.cpp
@@ -7,27 +7,28 @@ using namespace ltp::utility;
 using namespace ltp::ner;
 
 void usage(void) {
-    std::cerr << "otcws - Training and testing suite for Chinese Word segmentation" << std::endl;
-    std::cerr << "Copyright (C) 2012-2013 HIT-SCIR" << std::endl;
-    std::cerr << std::endl;
-    std::cerr << "usage: ./otcws <config_file>" << std::endl;
-    std::cerr << std::endl;
+  std::cerr << "otcws - Training and testing suite for Named Entity Recognization"
+            << std::endl;
+  std::cerr << "Copyright (C) 2012-2014 HIT-SCIR" << std::endl;
+  std::cerr << std::endl;
+  std::cerr << "usage: ./otner <config_file>" << std::endl;
+  std::cerr << std::endl;
 }
 
 int main(int argc, const char * argv[]) {
-    if (argc < 2 || (argv[1][0] == '-' && argv[1][1] == 'h')) {
-        usage();
-        return -1;
-    }
+  if (argc < 2 || (argv[1][0] == '-' && argv[1][1] == 'h')) {
+    usage();
+    return -1;
+  }
 
-    ConfigParser cfg(argv[1]);
+  ConfigParser cfg(argv[1]);
 
-    if (!cfg) {
-        ERROR_LOG("Failed to parse config file.");
-        return -1;
-    }
+  if (!cfg) {
+    ERROR_LOG("Failed to parse config file.");
+    return -1;
+  }
 
-    NER engine(cfg);
-    engine.run();
-    return 0;
+  NER engine(cfg);
+  engine.run();
+  return 0;
 }
diff --git a/src/ner/parameter.h b/src/ner/parameter.h
index a3ec971b1..cfd469b0c 100644
--- a/src/ner/parameter.h
+++ b/src/ner/parameter.h
@@ -12,151 +12,151 @@ using namespace ltp::math;
 
 class Parameters {
 public:
-    int _dim;
-    double * _W;
-    double * _W_sum;
-    int *    _W_time;
-
-    Parameters() :
-        _dim(0),
-        _W(0),
-        _W_sum(0),
-        _W_time(0) {}
-
-    ~Parameters() {
-        dealloc();
+  int _dim;
+  double * _W;
+  double * _W_sum;
+  int *  _W_time;
+
+  Parameters() :
+    _dim(0),
+    _W(0),
+    _W_sum(0),
+    _W_time(0) {}
+
+  ~Parameters() {
+    dealloc();
+  }
+
+  void realloc(int dim) {
+    dealloc();
+    _dim = dim;
+
+    if (dim > 0) {
+      _W = new double[dim];
+      _W_sum = new double[dim];
+      _W_time = new int[dim];
     }
 
-    void realloc(int dim) {
-        dealloc();
-        _dim = dim;
-
-        if (dim > 0) {
-            _W = new double[dim];
-            _W_sum = new double[dim];
-            _W_time = new int[dim];
-        }
-
-        for (int i = 0; i < dim; ++ i) {
-            _W[i] = 0;
-            _W_sum[i] = 0;
-            _W_time[i] = 0;
-        }
+    for (int i = 0; i < dim; ++ i) {
+      _W[i] = 0;
+      _W_sum[i] = 0;
+      _W_time[i] = 0;
     }
-
-    void dealloc() {
-        if (_W && _W == _W_sum) {
-            delete [](_W);
-            _W = 0;
-            _W_sum = 0;
-        } else {
-            if (_W) {
-                delete [](_W);
-                _W = 0;
-            }
-            if (_W_sum) {
-                delete [](_W_sum);
-                _W_sum = 0;
-            }
-        }
-
-        if (_W_time) {
-            delete [](_W_time);
-            _W_time = 0;
-        }
+  }
+
+  void dealloc() {
+    if (_W && _W == _W_sum) {
+      delete [](_W);
+      _W = 0;
+      _W_sum = 0;
+    } else {
+      if (_W) {
+        delete [](_W);
+        _W = 0;
+      }
+      if (_W_sum) {
+        delete [](_W_sum);
+        _W_sum = 0;
+      }
     }
 
-    void add(int idx, int now, double scale = 1.) {
-        int elapsed = now - _W_time[idx];
-        double upd = scale;
-        double cur_val = _W[idx];
-
-        _W[idx]         = cur_val + upd;
-        _W_sum[idx]    += elapsed * cur_val + upd;
-        _W_time[idx]    = now;
+    if (_W_time) {
+      delete [](_W_time);
+      _W_time = 0;
     }
-
-    void add(const SparseVec & vec, int now, double scale = 1.) {
-        for (SparseVec::const_iterator itx = vec.begin();
-                itx != vec.end();
-                itx ++) {
-            int idx = itx->first;
-            int elapsed = now - _W_time[idx];
-            double upd = scale * itx->second;
-            double cur_val = _W[idx];
-
-            _W[idx]         = cur_val + upd;
-            _W_sum[idx]    += elapsed * cur_val + upd;
-            _W_time[idx]    = now;
-        }
+  }
+
+  void add(int idx, int now, double scale = 1.) {
+    int elapsed = now - _W_time[idx];
+    double upd = scale;
+    double cur_val = _W[idx];
+
+    _W[idx]     = cur_val + upd;
+    _W_sum[idx]  += elapsed * cur_val + upd;
+    _W_time[idx]  = now;
+  }
+
+  void add(const SparseVec & vec, int now, double scale = 1.) {
+    for (SparseVec::const_iterator itx = vec.begin();
+        itx != vec.end();
+        ++ itx) {
+      int idx = itx->first;
+      int elapsed = now - _W_time[idx];
+      double upd = scale * itx->second;
+      double cur_val = _W[idx];
+
+      _W[idx]     = cur_val + upd;
+      _W_sum[idx]  += elapsed * cur_val + upd;
+      _W_time[idx]  = now;
     }
-
-    double dot(const SparseVec & vec, bool use_avg = false) const {
-        const double * const p = (use_avg ? _W_sum : _W);
-        double ret = 0.;
-        for (SparseVec::const_iterator itx = vec.begin();
-                itx != vec.end();
-                ++ itx) {
-            ret += p[itx->first] * itx->second;
-        }
-        return ret;
+  }
+
+  double dot(const SparseVec & vec, bool use_avg = false) const {
+    const double * const p = (use_avg ? _W_sum : _W);
+    double ret = 0.;
+    for (SparseVec::const_iterator itx = vec.begin();
+        itx != vec.end();
+        ++ itx) {
+      ret += p[itx->first] * itx->second;
     }
-
-    double dot(const FeatureVector * vec, bool use_avg = false) const {
-        const double * const p = (use_avg ? _W_sum : _W);
-        double ret = 0.;
-        for (int i = 0; i < vec->n; ++ i) {
-            if (vec->val) {
-                ret += p[vec->idx[i] + vec->loff] * vec->val[i];
-            } else {
-                ret += p[vec->idx[i] + vec->loff];
-            }
-        }
-        return ret;
+    return ret;
+  }
+
+  double dot(const FeatureVector * vec, bool use_avg = false) const {
+    const double * const p = (use_avg ? _W_sum : _W);
+    double ret = 0.;
+    for (int i = 0; i < vec->n; ++ i) {
+      if (vec->val) {
+        ret += p[vec->idx[i] + vec->loff] * vec->val[i];
+      } else {
+        ret += p[vec->idx[i] + vec->loff];
+      }
     }
-
-    double dot(const int idx, bool use_avg = false) const {
-        const double * const p = (use_avg ? _W_sum : _W);
-        return p[idx];
+    return ret;
+  }
+
+  double dot(const int idx, bool use_avg = false) const {
+    const double * const p = (use_avg ? _W_sum : _W);
+    return p[idx];
+  }
+
+  void flush(int now) {
+    for(int i = 0; i < _dim; ++i) {
+      _W_sum[i] += (now - _W_time[i]) * _W[i];
+      _W_time[i] = now;
     }
-
-    void flush(int now) {
-        for(int i = 0; i < _dim; ++i) {
-            _W_sum[i] += (now - _W_time[i]) * _W[i];
-            _W_time[i] = now;
-        }
+  }
+
+  void dump(std::ostream & out, bool use_avg = true) {
+    const double * p = (use_avg ? _W_sum : _W);
+    char chunk[16] = {'p', 'a', 'r', 'a', 'm', 0};
+    out.write(chunk, 16);
+    out.write(reinterpret_cast<const char *>(&_dim), sizeof(int));
+    if (_dim > 0) {
+      out.write(reinterpret_cast<const char *>(p), sizeof(double) * _dim);
     }
+  }
 
-    void dump(std::ostream & out, bool use_avg = true) {
-        const double * p = (use_avg ? _W_sum : _W);
-        char chunk[16] = {'p', 'a', 'r', 'a', 'm', 0};
-        out.write(chunk, 16);
-        out.write(reinterpret_cast<const char *>(&_dim), sizeof(int));
-        if (_dim > 0) {
-            out.write(reinterpret_cast<const char *>(p), sizeof(double) * _dim);
-        }
+  bool load(std::istream & in) {
+    char chunk[16];
+    in.read(chunk, 16);
+    if (strcmp(chunk, "param")) {
+      return false;
     }
 
-    bool load(std::istream & in) {
-        char chunk[16];
-        in.read(chunk, 16);
-        if (strcmp(chunk, "param")) {
-            return false;
-        }
-
-        in.read(reinterpret_cast<char *>(&_dim), sizeof(int));
-        if (_dim > 0) {
-            _W = new double[_dim];
-            in.read(reinterpret_cast<char *>(_W), sizeof(double) * _dim);
-            _W_sum = _W;
-        }
-
-        return true;
+    in.read(reinterpret_cast<char *>(&_dim), sizeof(int));
+    if (_dim > 0) {
+      _W = new double[_dim];
+      in.read(reinterpret_cast<char *>(_W), sizeof(double) * _dim);
+      _W_sum = _W;
     }
+
+    return true;
+  }
 };
 
-}       //  end for namespace ner
-}       //  end for namespace ltp
+}     //  end for namespace ner
+}     //  end for namespace ltp
 
 #endif  //  end for __LTP_NER_PARAMETER_H__
 
diff --git a/src/ner/rulebase.h b/src/ner/rulebase.h
index d79447df1..115759070 100644
--- a/src/ner/rulebase.h
+++ b/src/ner/rulebase.h
@@ -17,86 +17,86 @@ namespace rulebase {
 
 class RuleBase {
 public:
-    RuleBase(utility::IndexableSmartMap & labels) {
-        // only 4 tag style is supported
+  RuleBase(utility::IndexableSmartMap & labels) {
+    // only 4 tag style is supported
 
-        std::stringstream S;
+    std::stringstream S;
 
-        __trans__ = 0;
-        // b
-        S.str(std::string()); S << __pos_types__[0] << "-" << __ne_types__[0];
-        __b_idx__ = prefix( labels.index(S.str()) ) ;
+    __trans__ = 0;
+    // b
+    S.str(std::string()); S << __pos_types__[0] << "-" << __ne_types__[0];
+    __b_idx__ = prefix( labels.index(S.str()) ) ;
 
-        S.str(std::string()); S << __pos_types__[1] << "-" << __ne_types__[0];
-        __i_idx__ = prefix( labels.index(S.str()) );
+    S.str(std::string()); S << __pos_types__[1] << "-" << __ne_types__[0];
+    __i_idx__ = prefix( labels.index(S.str()) );
 
-        S.str(std::string()); S << __pos_types__[2] << "-" << __ne_types__[0];
-        __e_idx__ = prefix( labels.index(S.str()) );
+    S.str(std::string()); S << __pos_types__[2] << "-" << __ne_types__[0];
+    __e_idx__ = prefix( labels.index(S.str()) );
 
-        S.str(std::string()); S << __pos_types__[3] << "-" << __ne_types__[0];
-        __s_idx__ = prefix( labels.index(S.str()) );
-        __o_idx__ = prefix( labels.index("O") );
+    S.str(std::string()); S << __pos_types__[3] << "-" << __ne_types__[0];
+    __s_idx__ = prefix( labels.index(S.str()) );
+    __o_idx__ = prefix( labels.index("O") );
 
-        if (__s_idx__>=0 && __b_idx__>=0 && __i_idx__>=0 && __e_idx__>=0  && __o_idx__>=0) {
-            __trans__ |= (1<<((__s_idx__<<3) + __s_idx__));
-            __trans__ |= (1<<((__s_idx__<<3) + __b_idx__));
-            __trans__ |= (1<<((__s_idx__<<3) + __o_idx__));
+    if (__s_idx__>=0 && __b_idx__>=0 && __i_idx__>=0 && __e_idx__>=0  && __o_idx__>=0) {
+      __trans__ |= (1<<((__s_idx__<<3) + __s_idx__));
+      __trans__ |= (1<<((__s_idx__<<3) + __b_idx__));
+      __trans__ |= (1<<((__s_idx__<<3) + __o_idx__));
 
-            __trans__ |= (1<<((__b_idx__<<3) + __i_idx__));
-            __trans__ |= (1<<((__b_idx__<<3) + __e_idx__));
+      __trans__ |= (1<<((__b_idx__<<3) + __i_idx__));
+      __trans__ |= (1<<((__b_idx__<<3) + __e_idx__));
 
-            __trans__ |= (1<<((__i_idx__<<3) + __i_idx__));
-            __trans__ |= (1<<((__i_idx__<<3) + __e_idx__));
+      __trans__ |= (1<<((__i_idx__<<3) + __i_idx__));
+      __trans__ |= (1<<((__i_idx__<<3) + __e_idx__));
 
-            __trans__ |= (1<<((__e_idx__<<3) + __s_idx__));
-            __trans__ |= (1<<((__e_idx__<<3) + __b_idx__));
-            __trans__ |= (1<<((__e_idx__<<3) + __o_idx__));
+      __trans__ |= (1<<((__e_idx__<<3) + __s_idx__));
+      __trans__ |= (1<<((__e_idx__<<3) + __b_idx__));
+      __trans__ |= (1<<((__e_idx__<<3) + __o_idx__));
 
-            __trans__ |= (1<<((__o_idx__<<3) + __s_idx__));
-            __trans__ |= (1<<((__o_idx__<<3) + __b_idx__));
-            __trans__ |= (1<<((__o_idx__<<3) + __o_idx__));
-        } else {
-            __trans__ = 0xffff;
-        }
+      __trans__ |= (1<<((__o_idx__<<3) + __s_idx__));
+      __trans__ |= (1<<((__o_idx__<<3) + __b_idx__));
+      __trans__ |= (1<<((__o_idx__<<3) + __o_idx__));
+    } else {
+      __trans__ = 0xffff;
     }
-
-    ~RuleBase() {
-    }
-
-    inline bool legal_trans(int prev, int curr) {
-        int prev_prefix = prefix(prev);
-        int prev_suffix = suffix(prev);
-        int curr_prefix = prefix(curr);
-        int curr_suffix = suffix(curr);
-
-        if (prev_prefix == __b_idx__ || prev_prefix == __i_idx__) {
-            return ((__trans__ & (1<<((prev_prefix<<3) + curr_prefix))) > 0
-                && (prev_suffix == curr_suffix));
-        } else {
-            return ((__trans__ & (1<<((prev_prefix<<3) + curr_prefix))) > 0);
-        }
+  }
+
+  ~RuleBase() {
+  }
+
+  inline bool legal_trans(int prev, int curr) {
+    int prev_prefix = prefix(prev);
+    int prev_suffix = suffix(prev);
+    int curr_prefix = prefix(curr);
+    int curr_suffix = suffix(curr);
+
+    if (prev_prefix == __b_idx__ || prev_prefix == __i_idx__) {
+      return ((__trans__ & (1<<((prev_prefix<<3) + curr_prefix))) > 0
+        && (prev_suffix == curr_suffix));
+    } else {
+      return ((__trans__ & (1<<((prev_prefix<<3) + curr_prefix))) > 0);
     }
+  }
 
 private:
-    unsigned __trans__;
+  unsigned __trans__;
 
-    int __s_idx__;
-    int __b_idx__;
-    int __i_idx__;
-    int __e_idx__;
-    int __o_idx__;
+  int __s_idx__;
+  int __b_idx__;
+  int __i_idx__;
+  int __e_idx__;
+  int __o_idx__;
 
-    inline int prefix(int tag) {
-        return (tag / __num_ne_types__);
-    }
+  inline int prefix(int tag) {
+    return (tag / __num_ne_types__);
+  }
 
-    inline int suffix(int tag) {
-        return (tag % __num_ne_types__);
-    }
+  inline int suffix(int tag) {
+    return (tag % __num_ne_types__);
+  }
 };
 
-}       //  end for rulebase
-}       //  end for namespace ner
-}       //  end for namespace ltp 
+}     //  end for rulebase
+}     //  end for namespace ner
+}     //  end for namespace ltp 
 
 #endif  //  end for __LTP_NER_RULE_BASE_H__
diff --git a/src/parser/collections.cpp b/src/parser/collections.cpp
index 84322efe0..c5c53b2be 100644
--- a/src/parser/collections.cpp
+++ b/src/parser/collections.cpp
@@ -4,83 +4,90 @@ namespace ltp {
 namespace parser {
 
 DictionaryCollections::DictionaryCollections(int num_dicts) :
-    idx(0) {
-    dicts.resize( num_dicts );
+  idx(0) {
+  dicts.resize( num_dicts );
 
-    for (int i = 0; i < num_dicts; ++ i) {
-        dicts[i] = new Dictionary( this );
-    }
+  for (int i = 0; i < num_dicts; ++ i) {
+    dicts[i] = new Dictionary( this );
+  }
 }
 
 DictionaryCollections::~DictionaryCollections() {
-    for (int i = 0; i < dicts.size(); ++ i) {
-        delete dicts[i];
-    }
+  for (int i = 0; i < dicts.size(); ++ i) {
+    delete dicts[i];
+  }
 }
 
-Dictionary * DictionaryCollections::getDictionary(int i) {
-    if (i < dicts.size()) {
-        return dicts[i];
-    }
+Dictionary *
+DictionaryCollections::getDictionary(int i) {
+  if (i < dicts.size()) {
+    return dicts[i];
+  }
 
-    return NULL;
-}
-int DictionaryCollections::retrieve(int tid, const char * key, bool create) {
-    return dicts[tid]->retrieve(key, create);
+  return NULL;
 }
 
-size_t DictionaryCollections::dim() const {
-    return idx;
+int
+DictionaryCollections::retrieve(int tid, const char * key, bool create) {
+  return dicts[tid]->retrieve(key, create);
 }
 
-int DictionaryCollections::size() {
-    return dicts.size();
+size_t
+DictionaryCollections::dim() const {
+  return idx;
 }
 
-void DictionaryCollections::dump(ostream & out) {
-    char chunk[32];
-    unsigned int sz = dicts.size();
-    strncpy(chunk, "collections", 16);
-
-    out.write(chunk, 16);
-    out.write(reinterpret_cast<const char *>(&idx), sizeof(int));
-    out.write(reinterpret_cast<const char *>(&sz), sizeof(unsigned int));
-    for (int i = 0; i < dicts.size(); ++ i) {
-        // strncpy(chunk, dicts[i]->dict_name.c_str(), 32);
-        // out.write(chunk, 32);
-
-        dicts[i]->database.dump(out);
-    }
+int
+DictionaryCollections::size() {
+  return dicts.size();
 }
 
-bool DictionaryCollections::load(istream & in) {
-    char chunk[32];
-    unsigned int sz;
+void
+DictionaryCollections::dump(ostream & out) {
+  char chunk[32];
+  unsigned int sz = dicts.size();
+  strncpy(chunk, "collections", 16);
+
+  out.write(chunk, 16);
+  out.write(reinterpret_cast<const char *>(&idx), sizeof(int));
+  out.write(reinterpret_cast<const char *>(&sz), sizeof(unsigned int));
+  for (int i = 0; i < dicts.size(); ++ i) {
+    // strncpy(chunk, dicts[i]->dict_name.c_str(), 32);
+    // out.write(chunk, 32);
+
+    dicts[i]->database.dump(out);
+  }
+}
 
-    in.read(chunk, 16);
-    if (strcmp(chunk, "collections")) {
-        return false;
-    }
+bool
+DictionaryCollections::load(istream & in) {
+  char chunk[32];
+  unsigned int sz;
 
-    in.read(reinterpret_cast<char *>(&idx), sizeof(int));
-    in.read(reinterpret_cast<char *>(&sz), sizeof(unsigned int));
+  in.read(chunk, 16);
+  if (strcmp(chunk, "collections")) {
+    return false;
+  }
 
-    if (sz != dicts.size()) {
-        return false;
-    }
+  in.read(reinterpret_cast<char *>(&idx), sizeof(int));
+  in.read(reinterpret_cast<char *>(&sz), sizeof(unsigned int));
 
-    for (unsigned i = 0; i < sz; ++ i) {
-        // in.read(chunk, 32);
+  if (sz != dicts.size()) {
+    return false;
+  }
 
-        // Dictionary * dict = new Dictionary(this);
-        if (!dicts[i]->database.load(in)) {
-            return false;
-        }
+  for (unsigned i = 0; i < sz; ++ i) {
+    // in.read(chunk, 32);
 
-        // dicts[i].push_back(dict);
+    // Dictionary * dict = new Dictionary(this);
+    if (!dicts[i]->database.load(in)) {
+      return false;
     }
 
-    return true;
+    // dicts[i].push_back(dict);
+  }
+
+  return true;
 }
 
 }   //  end for namespace parser
diff --git a/src/parser/collections.h b/src/parser/collections.h
index 609025d30..c5c579a33 100644
--- a/src/parser/collections.h
+++ b/src/parser/collections.h
@@ -1,5 +1,5 @@
-#ifndef __DICT_COLLECTIONS_H__
-#define __DICT_COLLECTIONS_H__
+#ifndef __LTP_PARSER_DICT_COLLECTIONS_H__
+#define __LTP_PARSER_DICT_COLLECTIONS_H__
 
 #include <iostream>
 #include <vector>
@@ -23,101 +23,101 @@ class Dictionary;
 // a index counter is shared within several dictionary.
 class DictionaryCollections {
 public:
-    DictionaryCollections(int num_dicts);
-    ~DictionaryCollections();
-
-    /*
-     * Dump the dictionary collections into output stream
-     *
-     *  @param[out]     out     the output stream
-     */
-    void dump(ostream & out);
-
-    /*
-     * Load the dictionary collections from input stream,
-     * return true if dictionary successfully loaded, otherwise
-     * false.
-     *
-     *  @param[in]      in      the input stream
-     *  @return         bool    true on success, otherwise false.
-     */
-    bool load(istream & in);
-
-    /*
-     * Get the size of dictionary collections
-     *
-     *  @return         size_t  the size of the dictionary
-     */
-    size_t dim() const;
-
-    /*
-     * Retrieve the certain key in one of the dictionaries in this
-     * collection. If create is specified, this key is created on
-     * the condition that it is not in the dictionary. Return the 
-     * index of the key, -1 on failure
-     *
-     *  @param[in]  tid     the index of the dictionary
-     *  @param[in]  key     the key
-     *  @param[in]  create  insert the key to dictionary if create
-     *                      if true.
-     *  @return     int     the index of the key, -1 on failure.
-     */
-    int retrieve(int tid, const char * key, bool create);
-
-    /*
-     * Get the ith Dictionary
-     *
-     *  @param[in]  i               the index of the dictionary
-     *  @return     Dictionary *    the dictionary
-     */
-    Dictionary * getDictionary(int i);
-
-    /*
-     * Get size of dicts
-     *
-     *  @return     int             the size of the dictionary
-     */
-    int size();
+  DictionaryCollections(int num_dicts);
+  ~DictionaryCollections();
+
+  /*
+   * Dump the dictionary collections into output stream
+   *
+   *  @param[out]   out   the output stream
+   */
+  void dump(ostream & out);
+
+  /*
+   * Load the dictionary collections from input stream,
+   * return true if dictionary successfully loaded, otherwise
+   * false.
+   *
+   *  @param[in]    in    the input stream
+   *  @return     bool  true on success, otherwise false.
+   */
+  bool load(istream & in);
+
+  /*
+   * Get the size of dictionary collections
+   *
+   *  @return     size_t  the size of the dictionary
+   */
+  size_t dim() const;
+
+  /*
+   * Retrieve the certain key in one of the dictionaries in this
+   * collection. If create is specified, this key is created on
+   * the condition that it is not in the dictionary. Return the 
+   * index of the key, -1 on failure
+   *
+   *  @param[in]  tid   the index of the dictionary
+   *  @param[in]  key   the key
+   *  @param[in]  create  insert the key to dictionary if create
+   *            if true.
+   *  @return   int   the index of the key, -1 on failure.
+   */
+  int retrieve(int tid, const char * key, bool create);
+
+  /*
+   * Get the ith Dictionary
+   *
+   *  @param[in]  i         the index of the dictionary
+   *  @return   Dictionary *  the dictionary
+   */
+  Dictionary * getDictionary(int i);
+
+  /*
+   * Get size of dicts
+   *
+   *  @return   int       the size of the dictionary
+   */
+  int size();
 
 public:
-    int idx;        /*< the shared index among dictionaries */
+  int idx;    /*< the shared index among dictionaries */
 
 private:
-    vector<Dictionary *> dicts;
+  vector<Dictionary *> dicts;
 };
 
 // the dictionary class
 // it's wrapper of class SmartMap<int>
 class Dictionary {
 public:
-    Dictionary(DictionaryCollections * coll): 
-        collections(coll) {}
-
-    //StringMap<int>          database;
-    SmartMap<int>           database;
-    DictionaryCollections * collections;
-
-    inline int retrieve(const char * key, bool create) {
-        int val;
-
-        if (database.get(key, val)) {
-            return val;
-        } else {
-            if (create) {
-                val = collections->idx;
-                database.set(key, val);
-                // database.unsafe_set(key, val);
-                ++ collections->idx;
-                return val;
-            }
-        }
-
-        return -1;
+  Dictionary(DictionaryCollections * coll): 
+    collections(coll) {}
+
+  //StringMap<int>      database;
+  SmartMap<int>       database;
+  DictionaryCollections * collections;
+
+  inline int retrieve(const char * key, bool create) {
+    int val;
+
+    if (database.get(key, val)) {
+      return val;
+    } else {
+      if (create) {
+        val = collections->idx;
+        database.set(key, val);
+        // database.unsafe_set(key, val);
+        ++ collections->idx;
+        return val;
+      }
     }
 
-    inline int size() {
-        return database.size();
-    }
+    return -1;
+  }
+
+  inline int size() {
+    return database.size();
+  }
 };
 
 // labelcollections is a bi-direction map.
@@ -126,6 +126,6 @@ class Dictionary {
 //  * string key -> int index
 //  * int index -> string key
 //
-}       //  end for namespace parser
-}       //  end for namespace ltp
-#endif  //  end for __FEATURE_COLLECTIONS_H__
+}     //  end for namespace parser
+}     //  end for namespace ltp
+#endif  //  end for __LTP_PARSER_DICT_COLLECTIONS_H__
diff --git a/src/parser/conllreader.h b/src/parser/conllreader.h
index 755b755e6..a8ac9ae61 100644
--- a/src/parser/conllreader.h
+++ b/src/parser/conllreader.h
@@ -1,5 +1,5 @@
-#ifndef __CONLL_READER_H__
-#define __CONLL_READER_H__
+#ifndef __LTP_PARSER_CONLL_READER_H__
+#define __LTP_PARSER_CONLL_READER_H__
 
 #include <iostream>
 #include <fstream>
@@ -20,80 +20,80 @@ using namespace ltp::strutils;
 
 class CoNLLReader {
 public:
-    /*
-     * Constructor for ConllReader
-     * Register a ifstream to the ConllReader
-     *
-     *  @param  f   the reference to the ifstream
-     */
-    CoNLLReader(ifstream& _f): f(_f) {}
-    ~CoNLLReader() {}
-
-    /*
-     * Get next instance from ifstream buffer
-     */
-    Instance * next() {
-        if (f.eof()) {
-            return NULL;
-        }
-
-        Instance * inst = new Instance;
-        string line;
-
-        inst->forms.push_back( ROOT_FORM );
-        inst->lemmas.push_back( ROOT_LEMMA );
-        inst->postags.push_back( ROOT_POSTAG );
-        inst->heads.push_back( -1 );
-
-        if (model_opt.labeled) {
-            inst->deprels.push_back( ROOT_DEPREL );
-        }
-        inst->chars.push_back( vector<string>() );
-
-        while (!f.eof()) {
-            getline(f, line);
-            chomp(line);
-
-            if (line.size() == 0) {
-                break;
-            }
-
-            vector<string> items = split(line);
-            if (items.size() != 10) {
-                WARNING_LOG("Unknown conll format file");
-            }
-
-            inst->forms.push_back( items[1] );      // items[1]: form
-            inst->lemmas.push_back( items[2] );     // items[2]: lemma
-            inst->postags.push_back( items[3] );    // items[4]: postag
-            inst->heads.push_back( to_int(items[6]) );
-
-            if (model_opt.labeled) {
-                inst->deprels.push_back( items[7] );
-            }
-
-            vector<string> chars;
-            codecs::decode(items[1], chars);
-            inst->chars.push_back( chars );
-        }
-
-        if (inst->forms.size() == 1) {
-            delete inst;
-            inst = NULL;
-        }
-        return inst;
+  /*
+   * Constructor for ConllReader
+   * Register a ifstream to the ConllReader
+   *
+   *  @param  f   the reference to the ifstream
+   */
+  CoNLLReader(ifstream& _f): f(_f) {}
+  ~CoNLLReader() {}
+
+  /*
+   * Get next instance from ifstream buffer
+   */
+  Instance * next() {
+    if (f.eof()) {
+      return NULL;
     }
 
-    /*
-     * Reader reach the end of the file
-     */
-    bool eof() {
-        return f.eof();
+    Instance * inst = new Instance;
+    string line;
+
+    inst->forms.push_back( ROOT_FORM );
+    inst->lemmas.push_back( ROOT_LEMMA );
+    inst->postags.push_back( ROOT_POSTAG );
+    inst->heads.push_back( -1 );
+
+    if (model_opt.labeled) {
+      inst->deprels.push_back( ROOT_DEPREL );
+    }
+    inst->chars.push_back( vector<string>() );
+
+    while (!f.eof()) {
+      getline(f, line);
+      chomp(line);
+
+      if (line.size() == 0) {
+        break;
+      }
+
+      vector<string> items = split(line);
+      if (items.size() != 10) {
+        WARNING_LOG("Unknown conll format file");
+      }
+
+      inst->forms.push_back( items[1] );    // items[1]: form
+      inst->lemmas.push_back( items[2] );   // items[2]: lemma
+      inst->postags.push_back( items[3] );  // items[4]: postag
+      inst->heads.push_back( to_int(items[6]) );
+
+      if (model_opt.labeled) {
+        inst->deprels.push_back( items[7] );
+      }
+
+      vector<string> chars;
+      codecs::decode(items[1], chars);
+      inst->chars.push_back( chars );
+    }
+
+    if (inst->forms.size() == 1) {
+      delete inst;
+      inst = NULL;
     }
+    return inst;
+  }
+
+  /*
+   * Reader reach the end of the file
+   */
+  bool eof() {
+    return f.eof();
+  }
 private:
-    ifstream& f;
+  ifstream& f;
 };  // end for ConllReader
 }   // end for parser
 }   // end for namespace ltp
 
-#endif  // end for __CONLL_READER_H__
+#endif  // end for __LTP_PARSER_CONLL_READER_H__
diff --git a/src/parser/conllwriter.h b/src/parser/conllwriter.h
index f3fc94fb8..0d4e91a4f 100644
--- a/src/parser/conllwriter.h
+++ b/src/parser/conllwriter.h
@@ -1,5 +1,5 @@
-#ifndef __CONLL_WRITER_H__
-#define __CONLL_WRITER_H__
+#ifndef __LTP_PARSER_CONLL_WRITER_H__
+#define __LTP_PARSER_CONLL_WRITER_H__
 
 #include <iostream>
 
@@ -13,47 +13,47 @@ using namespace ltp::strutils;
 
 class CoNLLWriter {
 public:
-    CoNLLWriter(std::ostream& _f): f(_f)  {}
-    ~CoNLLWriter() {}
-
-    void write(const Instance * inst) {
-        int len = inst->size();
-        bool predicted = (inst->predicted_heads.size() > 0 &&
-                inst->predicted_heads.size() == len);
-        bool predicted_label = (inst->predicted_deprels.size() > 0 &&
-                inst->predicted_deprels.size() == len);
-
-        for (int i = 1; i < inst->size(); ++ i) {
-            f << i 
-                << "\t"                     // 0 - index
-                << inst->forms[i] 
-                << "\t"                     // 1 - form
-                << inst->lemmas[i] 
-                << "\t"                     // 2 - lemma
-                << inst->postags[i] 
-                << "\t"                     // 3 - postag
-                << "_" 
-                << "\t"                     // 4 - unknown
-                << "_" 
-                << "\t"                     // 5 - unknown
-                << inst->heads[i] 
-                << "\t"                     // 6 - heads
-                << inst->deprels[i] 
-                << "\t"                     // 7 - deprels
-                << (predicted ? to_str(inst->predicted_heads[i]) : "_")
-                << "\t"
-                << (predicted_label ? inst->predicted_deprels[i] : "_")
-                << endl;
-        }
-
-        f << endl;
+  CoNLLWriter(std::ostream& _f): f(_f)  {}
+  ~CoNLLWriter() {}
+
+  void write(const Instance * inst) {
+    int len = inst->size();
+    bool predicted = (inst->predicted_heads.size() > 0
+                      && inst->predicted_heads.size() == len);
+    bool predicted_label = (inst->predicted_deprels.size() > 0
+                            && inst->predicted_deprels.size() == len);
+
+    for (int i = 1; i < inst->size(); ++ i) {
+      f << i
+        << "\t"           // 0 - index
+        << inst->forms[i]
+        << "\t"           // 1 - form
+        << inst->lemmas[i]
+        << "\t"           // 2 - lemma
+        << inst->postags[i]
+        << "\t"           // 3 - postag
+        << "_"
+        << "\t"           // 4 - unknown
+        << "_"
+        << "\t"           // 5 - unknown
+        << inst->heads[i]
+        << "\t"           // 6 - heads
+        << inst->deprels[i]
+        << "\t"           // 7 - deprels
+        << (predicted ? to_str(inst->predicted_heads[i]) : "_")
+        << "\t"
+        << (predicted_label ? inst->predicted_deprels[i] : "_")
+        << endl;
     }
+
+    f << endl;
+  }
 private:
-    std::ostream& f;
+  std::ostream& f;
 };  // end for ConnllWriter
 
 }   // end for parser
 }   // end for namespace ltp
 
 
-#endif  // end for __CONLL_WRITER_H__
+#endif  // end for __LTP_PARSER_CONLL_WRITER_H__
diff --git a/src/parser/decoder.h b/src/parser/decoder.h
index d47e421ae..4d065d379 100644
--- a/src/parser/decoder.h
+++ b/src/parser/decoder.h
@@ -1,5 +1,5 @@
-#ifndef __DECODER_H__
-#define __DECODER_H__
+#ifndef __LTP_PARSER_DECODER_H__
+#define __LTP_PARSER_DECODER_H__
 
 #include "instance.h"
 #include "settings.h"
@@ -12,166 +12,169 @@
 namespace ltp {
 namespace parser {
 
-// data struct for decode chart item. Provide several construction 
+// data struct for decode chart item. Provide several construction
 // methods and bind certain type.
 class LatticeItem {
 public:
-    const int _g;           /* grand */
-    const int _s;           /* from */
-    const int _t;           /*< the distance to */
-    const int _comp;        /*< specify if this span is complete */
-    const int _label_s_t;   /*< label type */
+  const int _g;           /* grand */
+  const int _s;           /* from */
+  const int _t;           /*< the distance to */
+  const int _comp;        /*< specify if this span is complete */
+  const int _label_s_t;   /*< label type */
 
-    const LatticeItem * const _left;
-    const LatticeItem * const _right;
+  const LatticeItem * const _left;
+  const LatticeItem * const _right;
 
-    const double _prob;
+  const double _prob;
 
 public:
-    LatticeItem(const int comp,
-            const int g,
-            const int s,
-            const int t,
-            const double prob,
-            const LatticeItem * const left,
-            const LatticeItem * const right) : 
-        _g(g),
-        _s(s),
-        _t(t),
-        _comp(comp),
-        _prob(prob),
-        _left(left),
-        _right(right),
-        _label_s_t(-1) { }
-
-    LatticeItem(const int comp,
-            const int s,
-            const int t,
-            const double prob,
-            const LatticeItem * const left,
-            const LatticeItem * const right,
-            const int label_s_t = -1) : 
-        _g(-1),
-        _s(s),
-        _t(t),
-        _comp(comp),
-        _prob(prob),
-        _left(left),
-        _right(right),
-        _label_s_t(label_s_t) { }
-
-    // for span like C(s,s)
-    LatticeItem(const int g,
-            const int s) :
-        _g(g),
-        _s(s),
-        _t(s),
-        _prob(0.0),
-        _comp(CMP),
-        _left(0),
-        _right(0),
-        _label_s_t(-1) { }
-
-    LatticeItem(const int s) :
-        _s(s),
-        _t(s),
-        _prob(0.0),
-        _comp(CMP),
-        _left(0),
-        _right(0),
-        _g(-1),
-        _label_s_t(-1) { }
-
-    ~LatticeItem() {}
+  LatticeItem(const int comp,
+      const int g,
+      const int s,
+      const int t,
+      const double prob,
+      const LatticeItem * const left,
+      const LatticeItem * const right) :
+    _g(g),
+    _s(s),
+    _t(t),
+    _comp(comp),
+    _prob(prob),
+    _left(left),
+    _right(right),
+    _label_s_t(-1) { }
+
+  LatticeItem(const int comp,
+      const int s,
+      const int t,
+      const double prob,
+      const LatticeItem * const left,
+      const LatticeItem * const right,
+      const int label_s_t = -1) :
+    _g(-1),
+    _s(s),
+    _t(t),
+    _comp(comp),
+    _prob(prob),
+    _left(left),
+    _right(right),
+    _label_s_t(label_s_t) { }
+
+  // for span like C(s,s)
+  LatticeItem(const int g,
+      const int s) :
+    _g(g),
+    _s(s),
+    _t(s),
+    _prob(0.0),
+    _comp(CMP),
+    _left(0),
+    _right(0),
+    _label_s_t(-1) { }
+
+  LatticeItem(const int s) :
+    _s(s),
+    _t(s),
+    _prob(0.0),
+    _comp(CMP),
+    _left(0),
+    _right(0),
+    _g(-1),
+    _label_s_t(-1) { }
+
+  ~LatticeItem() {}
 
 private:
-    // forbidden construction
-    LatticeItem(const LatticeItem & rhs) :
-        _s(0),
-        _t(0),
-        _prob(0.0),
-        _comp(-1),
-        _left(0),
-        _right(0),
-        _label_s_t(-1),
-        _g(-1) {
-        std::cerr << "LatticeItem::LatticeItem(const LatticeItem & rhs) is not allowed" << std::endl;
-        exit(-1);
-    }
-
-    LatticeItem & operator = (const LatticeItem & rhs) {
-        std::cerr << "LatticeItem::operator= (const LatticeItem & rhs) is not allowed" << std::endl;
-        exit(-1);
-    }
+  // forbidden construction
+  LatticeItem(const LatticeItem & rhs) :
+    _s(0),
+    _t(0),
+    _prob(0.0),
+    _comp(-1),
+    _left(0),
+    _right(0),
+    _label_s_t(-1),
+    _g(-1) {
+    std::cerr << "LatticeItem::LatticeItem(const LatticeItem & rhs) is not allowed"
+              << std::endl;
+    exit(-1);
+  }
+
+  LatticeItem & operator = (const LatticeItem & rhs) {
+    std::cerr << "LatticeItem::operator= (const LatticeItem & rhs) is not allowed"
+              << std::endl;
+    exit(-1);
+  }
 
 };
 
 class Decoder {
 public:
-    Decoder() {}
-    virtual ~Decoder() {}
-
-    /*
-     * Decode the instance, this method is a controller,
-     * execute:
-     *  - init lattice
-     *  - decode projective
-     *  - get result
-     *  - free lattice
-     * in sequence.
-     *
-     *  @param[in]  inst    the instance
-     */
-    void decode(Instance * inst) {
-        init_lattice(inst);
-        decode_projective(inst);
-        get_result(inst);
-        free_lattice();
-    }
-
-    virtual void init_lattice(const Instance * inst) = 0;
-    virtual void decode_projective(const Instance * inst) = 0;
-    virtual void get_result(Instance * inst) = 0;
-    virtual void free_lattice() = 0;
+  Decoder() {}
+  virtual ~Decoder() {}
+
+  /*
+   * Decode the instance, this method is a controller,
+   * execute:
+   *  - init lattice
+   *  - decode projective
+   *  - get result
+   *  - free lattice
+   * in sequence.
+   *
+   *  @param[in]  inst  the instance
+   */
+  void decode(Instance * inst) {
+    init_lattice(inst);
+    decode_projective(inst);
+    get_result(inst);
+    free_lattice();
+  }
+
+  virtual void init_lattice(const Instance * inst) = 0;
+  virtual void decode_projective(const Instance * inst) = 0;
+  virtual void get_result(Instance * inst) = 0;
+  virtual void free_lattice() = 0;
 
 protected:
-    void lattice_insert(const LatticeItem * &position, const LatticeItem * const item) {
-        if (position == NULL) {
-            position = item;
-        } else if (position->_prob < item->_prob - EPS) {
-            delete position;
-            position = item;
-        } else {
-            delete item;
-        }
+  void lattice_insert(const LatticeItem * &position, const LatticeItem * const item) {
+    if (position == NULL) {
+      position = item;
+    } else if (position->_prob < item->_prob - EPS) {
+      delete position;
+      position = item;
+    } else {
+      delete item;
     }
+  }
 
-    void __BUILD_TREE(Instance * inst, const LatticeItem * item) {
-        if (!item) {
-            return;
-        }
-
-        __BUILD_TREE(inst, item->_left);
+  void __BUILD_TREE(Instance * inst, const LatticeItem * item) {
+    if (!item) {
+      return;
+    }
 
-        if (INCMP == item->_comp) {
-            inst->predicted_heads[item->_t] = item->_s;
+    __BUILD_TREE(inst, item->_left);
 
-            if (model_opt.labeled) {
-                inst->predicted_deprelsidx[item->_t] = item->_label_s_t;
-            }
-        } else if (CMP == item->_comp) {
-            // do nothing;
-        } else if (SIBSP == item->_comp) {
-            //  do nothing
-        } else {
-        }
+    if (INCMP == item->_comp) {
+      inst->predicted_heads[item->_t] = item->_s;
 
-        __BUILD_TREE(inst, item->_right);
+      if (model_opt.labeled) {
+        inst->predicted_deprelsidx[item->_t] = item->_label_s_t;
+      }
+    } else if (CMP == item->_comp) {
+      // do nothing;
+    } else if (SIBSP == item->_comp) {
+      // do nothing
+    } else {
+      // do nothing
     }
 
+    __BUILD_TREE(inst, item->_right);
+  }
+
 };  //  end for class decoder
 
 }   //  end for namespace parser
 }   //  end for namespace ltp
 
-#endif  // end for __DECODER_H__
+#endif  // end for __LTP_PARSER_DECODER_H__
diff --git a/src/parser/decoder1o.cpp b/src/parser/decoder1o.cpp
index 441351249..73474eabe 100644
--- a/src/parser/decoder1o.cpp
+++ b/src/parser/decoder1o.cpp
@@ -4,172 +4,172 @@ namespace ltp {
 namespace parser {
 
 void Decoder1O::init_lattice(const Instance * inst) {
-    int len = inst->size();
-    _lattice_cmp.resize(len, len);
-    _lattice_incmp.resize(len, len, L);
+  int len = inst->size();
+  _lattice_cmp.resize(len, len);
+  _lattice_incmp.resize(len, len, L);
 
-    _lattice_cmp = NULL;
-    _lattice_incmp = NULL;
+  _lattice_cmp = NULL;
+  _lattice_incmp = NULL;
 
-    for (int i = 0; i < len; ++ i) {
-        _lattice_cmp[i][i] = new LatticeItem(i);
-    }
+  for (int i = 0; i < len; ++ i) {
+    _lattice_cmp[i][i] = new LatticeItem(i);
+  }
 }
 
 
 void Decoder1O::decode_projective(const Instance * inst) {
-    int len = inst->size();
-
-    // instance_verify(inst);
-    for (int width = 1; width < len; ++ width) {
-        for (int s = 0; s + width < len; ++ s) {
-            int t = s + width;
-            _lattice_cmp[s][t] = NULL;
-            _lattice_cmp[t][s] = NULL;
-            for (int l = 0; l < L; ++ l) {
-                _lattice_incmp[s][t][l] = NULL;
-                _lattice_incmp[t][s][l] = NULL;
+  int len = inst->size();
+
+  // instance_verify(inst);
+  for (int width = 1; width < len; ++ width) {
+    for (int s = 0; s + width < len; ++ s) {
+      int t = s + width;
+      _lattice_cmp[s][t] = NULL;
+      _lattice_cmp[t][s] = NULL;
+      for (int l = 0; l < L; ++ l) {
+        _lattice_incmp[s][t][l] = NULL;
+        _lattice_incmp[t][s][l] = NULL;
+      }
+
+      for (int r = s; r < t; ++ r) { 
+        const LatticeItem * const left = _lattice_cmp[s][r];
+        if (!left) {
+          continue;
+        }
+
+        const LatticeItem * const right = _lattice_cmp[t][r+1];
+        if (!right) {
+          continue;
+        }
+
+        for (int l = 0; l < L; ++ l) {
+
+          {   // I(s,t) = C(s,r) + C(t,r+1)
+            double prob = (left->_prob + right->_prob);
+
+            if (feat_opt.use_unlabeled_dependency) {
+              prob += inst->depu_scores[s][t];
             }
 
-            for (int r = s; r < t; ++ r) { 
-                const LatticeItem * const left = _lattice_cmp[s][r];
-                if (!left) {
-                    continue;
-                }
-
-                const LatticeItem * const right = _lattice_cmp[t][r+1];
-                if (!right) {
-                    continue;
-                }
-
-                for (int l = 0; l < L; ++ l) {
-
-                    {   // I(s,t) = C(s,r) + C(t,r+1)
-                        double prob = (left->_prob + right->_prob);
-
-                        if (feat_opt.use_unlabeled_dependency) {
-                            prob += inst->depu_scores[s][t];
-                        }
-
-                        if (feat_opt.use_labeled_dependency) {
-                            prob += inst->depl_scores[s][t][l];
-                        }
-
-                        const LatticeItem * const item = new LatticeItem(INCMP,
-                                s,
-                                t,
-                                prob,
-                                left,
-                                right,
-                                l);
-
-                        lattice_insert(_lattice_incmp[s][t][l], item);
-                    }
-
-                    if (s != 0) {   // I(t,s)
-                        double prob = (left->_prob + right->_prob);
-
-                        if (feat_opt.use_unlabeled_dependency) {
-                            prob += inst->depu_scores[t][s];
-                        }
-
-                        if (feat_opt.use_labeled_dependency) {
-                            prob += inst->depl_scores[t][s][l];
-                        }
-
-                        const LatticeItem * const item = new LatticeItem(INCMP,
-                                t,
-                                s,
-                                prob,
-                                left,
-                                right,
-                                l);
-
-                        // cerr << "INCMP " << t << "-" << s << "-" << l << endl;
-                        lattice_insert(_lattice_incmp[t][s][l], item);
-                    }   //  end for if (s != 0)
-                }   //  end for for (int l = 0; l < _L; ++ l)
-            }   //  end for for (int r = s; r < t; ++ r)
-
-            for (int r = s; r <= t; ++ r) {
-                if (r != s) {   //  C(s,t) = I(s,r) + C(r,t)
-                    const LatticeItem * const right = _lattice_cmp[r][t];
-                    if (!right) {
-                        continue;
-                    }
-
-                    for (int l = 0; l < L; ++ l) {
-                        const LatticeItem * const left = _lattice_incmp[s][r][l];
-                        if (!left) {
-                            continue;
-                        }
-
-                        const double prob = left->_prob + right->_prob;
-                        const LatticeItem * const item = new LatticeItem(CMP,
-                                s,
-                                t,
-                                prob,
-                                left,
-                                right);
-
-                        // cerr << "CMP " << s << "-" << t << endl;
-                        lattice_insert(_lattice_cmp[s][t], item);
-                    }
-                }   //  end for if (r != s)
-
-                if (r != t && s != 0) { // C(t,s) = I(t,r) + C(r,s)
-                    const LatticeItem * const left = _lattice_cmp[r][s];
-                    if (!left) {
-                        continue;
-                    }
-
-                    for (int l = 0; l < L; ++ l) {
-                        const LatticeItem * const right = _lattice_incmp[t][r][l];
-                        if (!right) {
-                            continue;
-                        }
-
-                        const double prob = left->_prob + right->_prob;
-                        const LatticeItem * const item = new LatticeItem(CMP,
-                                t,
-                                s,
-                                prob,
-                                left,
-                                right);
-
-                        // cerr << "CMP " << t << "-" << s << endl;
-                        lattice_insert(_lattice_cmp[t][s], item);
-                    }   //  end for for (int l = 0; l < L; ++ l) 
-                }   //  end for if (r != t && s != 0)
+            if (feat_opt.use_labeled_dependency) {
+              prob += inst->depl_scores[s][t][l];
             }
-        }
+
+            const LatticeItem * const item = new LatticeItem(INCMP,
+                                                             s,
+                                                             t,
+                                                             prob,
+                                                             left,
+                                                             right,
+                                                             l);
+
+            lattice_insert(_lattice_incmp[s][t][l], item);
+          }
+
+          if (s != 0) {   // I(t,s)
+            double prob = (left->_prob + right->_prob);
+
+            if (feat_opt.use_unlabeled_dependency) {
+              prob += inst->depu_scores[t][s];
+            }
+
+            if (feat_opt.use_labeled_dependency) {
+              prob += inst->depl_scores[t][s][l];
+            }
+
+            const LatticeItem * const item = new LatticeItem(INCMP,
+                                                             t,
+                                                             s,
+                                                             prob,
+                                                             left,
+                                                             right,
+                                                             l);
+
+            // cerr << "INCMP " << t << "-" << s << "-" << l << endl;
+            lattice_insert(_lattice_incmp[t][s][l], item);
+          }   //  end for if (s != 0)
+        }   //  end for for (int l = 0; l < _L; ++ l)
+      }   //  end for for (int r = s; r < t; ++ r)
+
+      for (int r = s; r <= t; ++ r) {
+        if (r != s) {   //  C(s,t) = I(s,r) + C(r,t)
+          const LatticeItem * const right = _lattice_cmp[r][t];
+          if (!right) {
+            continue;
+          }
+
+          for (int l = 0; l < L; ++ l) {
+            const LatticeItem * const left = _lattice_incmp[s][r][l];
+            if (!left) {
+              continue;
+            }
+
+            const double prob = left->_prob + right->_prob;
+            const LatticeItem * const item = new LatticeItem(CMP,
+                                                             s,
+                                                             t,
+                                                             prob,
+                                                             left,
+                                                             right);
+
+            // cerr << "CMP " << s << "-" << t << endl;
+            lattice_insert(_lattice_cmp[s][t], item);
+          }
+        }   //  end for if (r != s)
+
+        if (r != t && s != 0) { // C(t,s) = I(t,r) + C(r,s)
+          const LatticeItem * const left = _lattice_cmp[r][s];
+          if (!left) {
+            continue;
+          }
+
+          for (int l = 0; l < L; ++ l) {
+            const LatticeItem * const right = _lattice_incmp[t][r][l];
+            if (!right) {
+              continue;
+            }
+
+            const double prob = left->_prob + right->_prob;
+            const LatticeItem * const item = new LatticeItem(CMP,
+                                                             t,
+                                                             s,
+                                                             prob,
+                                                             left,
+                                                             right);
+
+            // cerr << "CMP " << t << "-" << s << endl;
+            lattice_insert(_lattice_cmp[t][s], item);
+          }   //  end for for (int l = 0; l < L; ++ l) 
+        }   //  end for if (r != t && s != 0)
+      }
     }
+  }
 }
 
 void Decoder1O::get_result(Instance * inst) {
-    int len = inst->size();
-    inst->predicted_heads.resize(len, -1);
-    if (model_opt.labeled) {
-        inst->predicted_deprelsidx.resize(len, -1);
-    }
-
-    const LatticeItem * best_item = _lattice_cmp[0][len - 1];
-    __BUILD_TREE(inst, best_item);
+  int len = inst->size();
+  inst->predicted_heads.resize(len, -1);
+  if (model_opt.labeled) {
+    inst->predicted_deprelsidx.resize(len, -1);
+  }
+
+  const LatticeItem * best_item = _lattice_cmp[0][len - 1];
+  __BUILD_TREE(inst, best_item);
 }
 
 void Decoder1O::free_lattice() {
-    int len = _lattice_cmp.nrows();
-    for (int i = 0; i < len; ++ i) {
-        for (int j = 0; j < len; ++ j) {
-            for (int l = 0; l < L; ++ l) {
-                if (_lattice_incmp[i][j][l]) {
-                    delete _lattice_incmp[i][j][l];
-                }
-            }
-
-            delete _lattice_cmp[i][j];
+  int len = _lattice_cmp.nrows();
+  for (int i = 0; i < len; ++ i) {
+    for (int j = 0; j < len; ++ j) {
+      for (int l = 0; l < L; ++ l) {
+        if (_lattice_incmp[i][j][l]) {
+          delete _lattice_incmp[i][j][l];
         }
+      }
+
+      delete _lattice_cmp[i][j];
     }
+  }
 }
 
 }   //  end for namespace parser
diff --git a/src/parser/decoder1o.h b/src/parser/decoder1o.h
index e46431937..4d6b10942 100644
--- a/src/parser/decoder1o.h
+++ b/src/parser/decoder1o.h
@@ -1,5 +1,5 @@
-#ifndef __DECODER_1_O_H__
-#define __DECODER_1_O_H__
+#ifndef __LTP_PARSER_DECODER_1_O_H__
+#define __LTP_PARSER_DECODER_1_O_H__
 
 #include "instance.h"
 #include "decoder.h"
@@ -15,21 +15,21 @@ using namespace ltp::math;
 
 class Decoder1O : public Decoder {
 public:
-    Decoder1O(int _L = 1) : L(_L) {}
+  Decoder1O(int _L = 1) : L(_L) {}
 
 protected:
-    void init_lattice(const Instance * inst); 
-    void decode_projective(const Instance * inst);
-    void get_result(Instance * inst);
-    void free_lattice();
+  void init_lattice(const Instance * inst); 
+  void decode_projective(const Instance * inst);
+  void get_result(Instance * inst);
+  void free_lattice();
 protected:
-    int L;
+  int L;
 
-    Mat< const LatticeItem * >    _lattice_cmp;   //  complete span
-    Mat3< const LatticeItem * >   _lattice_incmp; //  incomplete span
-};      //  end for class Decoder1O
+  Mat< const LatticeItem * >  _lattice_cmp;   //  complete span
+  Mat3< const LatticeItem * >   _lattice_incmp; //  incomplete span
+};    //  end for class Decoder1O
 
-}       //  end for namespace parser
-}       //  end for namespace ltp
+}     //  end for namespace parser
+}     //  end for namespace ltp
 
-#endif  //  end for __DECODER_1_O_H__
+#endif  //  end for __LTP_PARSER_DECODER_1_O_H__
diff --git a/src/parser/decoder2o.cpp b/src/parser/decoder2o.cpp
index 10ae9a48c..dd3a295cc 100644
--- a/src/parser/decoder2o.cpp
+++ b/src/parser/decoder2o.cpp
@@ -9,296 +9,296 @@ namespace parser {
 // ================================================================ //
 
 void Decoder2O::init_lattice(const Instance * inst) {
-    int len = inst->size();
-    _lattice_cmp.resize(len, len);
-    _lattice_sib.resize(len, len);
-    _lattice_incmp.resize(len, len);
-
-    for (int i = 0; i < len; ++ i) {
-        for (int j = 0; j < len; ++ j) {
-            _lattice_cmp[i][j] = 0;
-            _lattice_sib[i][j] = 0;
-            _lattice_incmp[i][j] = 0;
-        }
-    }
-    for (int i = 0; i < len; ++ i) {
-        _lattice_cmp[i][i] = new LatticeItem(i);
+  int len = inst->size();
+  _lattice_cmp.resize(len, len);
+  _lattice_sib.resize(len, len);
+  _lattice_incmp.resize(len, len);
+
+  for (int i = 0; i < len; ++ i) {
+    for (int j = 0; j < len; ++ j) {
+      _lattice_cmp[i][j] = 0;
+      _lattice_sib[i][j] = 0;
+      _lattice_incmp[i][j] = 0;
     }
+  }
+  for (int i = 0; i < len; ++ i) {
+    _lattice_cmp[i][i] = new LatticeItem(i);
+  }
 }
 
 void Decoder2O::decode_projective(const Instance * inst) {
-    int len = inst->size();
-    for (int width = 1; width < len; ++ width) {
-        for (int s = 0; s + width < len; ++ s) {
-            int t = s + width;
-
-            for (int l = 0; l < L; ++ l) {
-                double shared_score = 0.;
-
-                if (feat_opt.use_unlabeled_dependency) {
-                    shared_score += inst->depu_scores[s][t];
-                }
-
-                if (feat_opt.use_labeled_dependency) {
-                    shared_score += inst->depl_scores[s][t][l];
-                }
-
-                {   // I(s,t) = C(s,s) + C(t,s+1)
-                    const LatticeItem * const left  = _lattice_cmp[s][s];
-                    const LatticeItem * const right = _lattice_cmp[t][s + 1];
-
-                    if (!left || !right) {
-                        continue;
-                    }
-
-                    double score = left->_prob + right->_prob + shared_score;
-                    if (feat_opt.use_unlabeled_sibling) {
-                        score += inst->sibu_scores[s][t][s];
-                    }
-
-                    if (feat_opt.use_labeled_sibling) {
-                        score += inst->sibl_scores[s][t][s][l];
-                    }
-
-                    const LatticeItem * const item = new LatticeItem(INCMP,
-                            s,
-                            t,
-                            score,
-                            left,
-                            right,
-                            l);
-
-                    lattice_insert(_lattice_incmp[s][t], item);
-                }   //  end for I(s,t) = C(s,s) + C(t,s+1)
-
-                {   // I(s,t) = I(s,r) + S(r,t)
-                    for (int r = s + 1; r < t; ++ r) {
-                        const LatticeItem * const left = _lattice_incmp[s][r];
-                        const LatticeItem * const right = _lattice_sib[r][t];
-
-                        if (!left || !right) {
-                            continue;
-                        }
-
-                        double score = left->_prob + right->_prob + shared_score;
-
-                        if (feat_opt.use_unlabeled_sibling) {
-                            score += inst->sibu_scores[s][t][r];
-                        }
-
-                        if (feat_opt.use_labeled_sibling) {
-                            score += inst->sibl_scores[s][t][r][l];
-                        }
-
-                        const LatticeItem * const item = new LatticeItem(INCMP,
-                                s,
-                                t,
-                                score,
-                                left,
-                                right,
-                                l);
-
-                        lattice_insert(_lattice_incmp[s][t], item);
-                    }
-                }   //  end for I(s,t) = I(s,r) + S(r,t)
-
-            }   // end for for (l = 0; l < L; ++ l)
- 
-            if (s != 0) {   //  I(t,s) = C(s, t-1) + C(t, t)
-                for (int l = 0; l < L; ++ l) {
-                    double shared_score = 0.;
- 
-                    if (feat_opt.use_unlabeled_dependency) {
-                        shared_score += inst->depu_scores[t][s];
-                    }
-
-                    if (feat_opt.use_labeled_dependency) {
-                        shared_score += inst->depl_scores[t][s][l];
-                    }
-
-                    {   //  I(t,s) = C(s,t-1) + C(t,t)
-                        const LatticeItem * const left = _lattice_cmp[s][t-1];
-                        const LatticeItem * const right = _lattice_cmp[t][t];
-
-                        if (!left || !right) {
-                            continue;
-                        }
-
-                        double score =  left->_prob + right->_prob + shared_score;
-
-                        if (feat_opt.use_unlabeled_sibling) {
-                            score += inst->sibu_scores[t][s][t];
-                        }
-
-                        if (feat_opt.use_labeled_sibling) {
-                            score += inst->sibl_scores[t][s][t][l];
-                        }
-
-                        const LatticeItem * const item = new LatticeItem(INCMP,
-                                t,
-                                s,
-                                score,
-                                left,
-                                right,
-                                l);
-
-                        lattice_insert(_lattice_incmp[t][s], item);
-                    }   //  end for I(t, s) = C(s,t-1) + C(t,t)
-
-                    {   //  I(t,s) = S(s,r) + I(t,r)
-                        for (int r = s + 1; r < t; ++ r) {
-                            const LatticeItem * const left = _lattice_sib[s][r];
-                            const LatticeItem * const right = _lattice_incmp[t][r];
-
-                            if (!left || !right) {
-                                continue;
-                            }
-
-                            double score = left->_prob + right->_prob + shared_score;
-
-                            if (feat_opt.use_unlabeled_sibling) {
-                                score += inst->sibu_scores[t][s][r];
-                            }
-
-                            if (feat_opt.use_labeled_sibling) {
-                                score += inst->sibl_scores[t][s][r][l];
-                            }
-
-                            const LatticeItem * const item = new LatticeItem(INCMP,
-                                    t,
-                                    s,
-                                    score,
-                                    left,
-                                    right,
-                                    l);
-
-                            lattice_insert(_lattice_incmp[t][s], item);
-                        }
-                    }   //  end for I(t,s) = S(s,r) + I(t,r)
-
-                }
-            }   //  end for if (s != 0)
- 
-            {   // S(s,t) = C(s,r) + C(t,r+1)
-                for (int r = s; r < t; ++ r) {
-                    const LatticeItem * const left = _lattice_cmp[s][r];
-                    const LatticeItem * const right = _lattice_cmp[t][r+1];
-
-                    if (!left || !right) {
-                        continue;
-                    }
-
-                    double score = left->_prob + right->_prob;
-
-                    const LatticeItem * const item = new LatticeItem(SIBSP,
-                            s,
-                            t,
-                            score,
-                            left,
-                            right);
-
-                    lattice_insert(_lattice_sib[s][t], item);
-                }
-            }   // end for S(s,t) = C(s,t) + C(t,r+1)
-
-            {   //  C(s,t) = I(s,r) + C(r,t)
-                for (int r = s + 1; r <= t; ++ r) {
-                    const LatticeItem * const left = _lattice_incmp[s][r];
-                    const LatticeItem * const right = _lattice_cmp[r][t];
-
-                    if (!left || !right) {
-                        continue;
-                    }
-
-                    double score = left->_prob + right->_prob;
-
-                    if (feat_opt.use_last_sibling) {
-                        if (feat_opt.use_unlabeled_sibling) {
-                            score += inst->sibu_scores[s][r][r];
-                        }
-
-                        if (feat_opt.use_labeled_sibling) {
-                            int l = left->_label_s_t;
-                            score += inst->sibl_scores[s][r][r][l];
-                        }
-                    }
-
-                    const LatticeItem * const item = new LatticeItem(CMP,
-                            s,
-                            t,
-                            score,
-                            left,
-                            right);
-
-                    lattice_insert(_lattice_cmp[s][t], item);
-
-                }
+  int len = inst->size();
+  for (int width = 1; width < len; ++ width) {
+    for (int s = 0; s + width < len; ++ s) {
+      int t = s + width;
+
+      for (int l = 0; l < L; ++ l) {
+        double shared_score = 0.;
+
+        if (feat_opt.use_unlabeled_dependency) {
+          shared_score += inst->depu_scores[s][t];
+        }
+
+        if (feat_opt.use_labeled_dependency) {
+          shared_score += inst->depl_scores[s][t][l];
+        }
+
+        {   // I(s,t) = C(s,s) + C(t,s+1)
+          const LatticeItem * const left  = _lattice_cmp[s][s];
+          const LatticeItem * const right = _lattice_cmp[t][s + 1];
+
+          if (!left || !right) {
+            continue;
+          }
+
+          double score = left->_prob + right->_prob + shared_score;
+          if (feat_opt.use_unlabeled_sibling) {
+            score += inst->sibu_scores[s][t][s];
+          }
+
+          if (feat_opt.use_labeled_sibling) {
+            score += inst->sibl_scores[s][t][s][l];
+          }
+
+          const LatticeItem * const item = new LatticeItem(INCMP,
+                                                           s,
+                                                           t,
+                                                           score,
+                                                           left,
+                                                           right,
+                                                           l);
+
+          lattice_insert(_lattice_incmp[s][t], item);
+        }   //  end for I(s,t) = C(s,s) + C(t,s+1)
+
+        {   // I(s,t) = I(s,r) + S(r,t)
+          for (int r = s + 1; r < t; ++ r) {
+            const LatticeItem * const left = _lattice_incmp[s][r];
+            const LatticeItem * const right = _lattice_sib[r][t];
+
+            if (!left || !right) {
+              continue;
+            }
+
+            double score = left->_prob + right->_prob + shared_score;
+
+            if (feat_opt.use_unlabeled_sibling) {
+              score += inst->sibu_scores[s][t][r];
+            }
+
+            if (feat_opt.use_labeled_sibling) {
+              score += inst->sibl_scores[s][t][r][l];
+            }
+
+            const LatticeItem * const item = new LatticeItem(INCMP,
+                                                             s,
+                                                             t,
+                                                             score,
+                                                             left,
+                                                             right,
+                                                             l);
+
+            lattice_insert(_lattice_incmp[s][t], item);
+          }
+        }   //  end for I(s,t) = I(s,r) + S(r,t)
+
+      }   // end for for (l = 0; l < L; ++ l)
+
+      if (s != 0) {   //  I(t,s) = C(s, t-1) + C(t, t)
+        for (int l = 0; l < L; ++ l) {
+          double shared_score = 0.;
+
+          if (feat_opt.use_unlabeled_dependency) {
+            shared_score += inst->depu_scores[t][s];
+          }
+
+          if (feat_opt.use_labeled_dependency) {
+            shared_score += inst->depl_scores[t][s][l];
+          }
+
+          {   //  I(t,s) = C(s,t-1) + C(t,t)
+            const LatticeItem * const left = _lattice_cmp[s][t-1];
+            const LatticeItem * const right = _lattice_cmp[t][t];
+
+            if (!left || !right) {
+              continue;
+            }
+
+            double score =  left->_prob + right->_prob + shared_score;
+
+            if (feat_opt.use_unlabeled_sibling) {
+              score += inst->sibu_scores[t][s][t];
             }
 
-            if (s != 0) {
-                for (int r = s; r < t; ++ r) {
-                    const LatticeItem * const left = _lattice_cmp[r][s];
-                    const LatticeItem * const right = _lattice_incmp[t][r];
-
-                    if (!left || !right) {
-                        continue;
-                    }
-
-                    double score = left->_prob + right->_prob;
-
-                    if (feat_opt.use_last_sibling) {
-                        if (feat_opt.use_unlabeled_sibling) {
-                            score += inst->sibu_scores[t][r][r];
-                        }
-
-                        if (feat_opt.use_labeled_sibling) {
-                            int l = right->_label_s_t;
-                            score += inst->sibl_scores[t][r][r][l];
-                        }
-                    }
-
-                    const LatticeItem * const item = new LatticeItem(CMP,
-                            t,
-                            s,
-                            score,
-                            left,
-                            right);
-
-                    lattice_insert(_lattice_cmp[t][s], item);
-                }
+            if (feat_opt.use_labeled_sibling) {
+              score += inst->sibl_scores[t][s][t][l];
             }
+
+            const LatticeItem * const item = new LatticeItem(INCMP,
+                                                             t,
+                                                             s,
+                                                             score,
+                                                             left,
+                                                             right,
+                                                             l);
+
+            lattice_insert(_lattice_incmp[t][s], item);
+          }   //  end for I(t, s) = C(s,t-1) + C(t,t)
+
+          {   //  I(t,s) = S(s,r) + I(t,r)
+            for (int r = s + 1; r < t; ++ r) {
+              const LatticeItem * const left = _lattice_sib[s][r];
+              const LatticeItem * const right = _lattice_incmp[t][r];
+
+              if (!left || !right) {
+                continue;
+              }
+
+              double score = left->_prob + right->_prob + shared_score;
+
+              if (feat_opt.use_unlabeled_sibling) {
+                score += inst->sibu_scores[t][s][r];
+              }
+
+              if (feat_opt.use_labeled_sibling) {
+                score += inst->sibl_scores[t][s][r][l];
+              }
+
+              const LatticeItem * const item = new LatticeItem(INCMP,
+                                                               t,
+                                                               s,
+                                                               score,
+                                                               left,
+                                                               right,
+                                                               l);
+
+              lattice_insert(_lattice_incmp[t][s], item);
+            }
+          }   //  end for I(t,s) = S(s,r) + I(t,r)
+
         }
-    }
-}
+      }   //  end for if (s != 0)
 
-void Decoder2O::get_result(Instance * inst) {
-    int len = inst->size();
-    inst->predicted_heads.resize(len, -1);
-    if (model_opt.labeled) {
-        inst->predicted_deprelsidx.resize(len, -1);
-    }
+      {   // S(s,t) = C(s,r) + C(t,r+1)
+        for (int r = s; r < t; ++ r) {
+          const LatticeItem * const left = _lattice_cmp[s][r];
+          const LatticeItem * const right = _lattice_cmp[t][r+1];
 
-    const LatticeItem * best_item = _lattice_cmp[0][len - 1];
-    __BUILD_TREE(inst, best_item);
-}
+          if (!left || !right) {
+            continue;
+          }
 
-void Decoder2O::free_lattice() {
-    int len = _lattice_cmp.nrows();
-    for (int i = 0; i < len; ++ i) {
-        for (int j = 0; j < len; ++ j) {
-            if (_lattice_incmp[i][j]) {
-                delete _lattice_incmp[i][j];
+          double score = left->_prob + right->_prob;
+
+          const LatticeItem * const item = new LatticeItem(SIBSP,
+              s,
+              t,
+              score,
+              left,
+              right);
+
+          lattice_insert(_lattice_sib[s][t], item);
+        }
+      }   // end for S(s,t) = C(s,t) + C(t,r+1)
+
+      {   //  C(s,t) = I(s,r) + C(r,t)
+        for (int r = s + 1; r <= t; ++ r) {
+          const LatticeItem * const left = _lattice_incmp[s][r];
+          const LatticeItem * const right = _lattice_cmp[r][t];
+
+          if (!left || !right) {
+            continue;
+          }
+
+          double score = left->_prob + right->_prob;
+
+          if (feat_opt.use_last_sibling) {
+            if (feat_opt.use_unlabeled_sibling) {
+              score += inst->sibu_scores[s][r][r];
             }
 
-            if (_lattice_cmp[i][j]) {
-                delete _lattice_cmp[i][j];
+            if (feat_opt.use_labeled_sibling) {
+              int l = left->_label_s_t;
+              score += inst->sibl_scores[s][r][r][l];
+            }
+          }
+
+          const LatticeItem * const item = new LatticeItem(CMP,
+                                                           s,
+                                                           t,
+                                                           score,
+                                                           left,
+                                                           right);
+
+          lattice_insert(_lattice_cmp[s][t], item);
+
+        }
+      }
+
+      if (s != 0) {
+        for (int r = s; r < t; ++ r) {
+          const LatticeItem * const left = _lattice_cmp[r][s];
+          const LatticeItem * const right = _lattice_incmp[t][r];
+
+          if (!left || !right) {
+            continue;
+          }
+
+          double score = left->_prob + right->_prob;
+
+          if (feat_opt.use_last_sibling) {
+            if (feat_opt.use_unlabeled_sibling) {
+              score += inst->sibu_scores[t][r][r];
             }
 
-            if (_lattice_sib[i][j]) {
-                delete _lattice_sib[i][j];
+            if (feat_opt.use_labeled_sibling) {
+              int l = right->_label_s_t;
+              score += inst->sibl_scores[t][r][r][l];
             }
+          }
+
+          const LatticeItem * const item = new LatticeItem(CMP,
+                                                           t,
+                                                           s,
+                                                           score,
+                                                           left,
+                                                           right);
+
+          lattice_insert(_lattice_cmp[t][s], item);
         }
+      }
+    }
+  }
+}
+
+void Decoder2O::get_result(Instance * inst) {
+  int len = inst->size();
+  inst->predicted_heads.resize(len, -1);
+  if (model_opt.labeled) {
+    inst->predicted_deprelsidx.resize(len, -1);
+  }
+
+  const LatticeItem * best_item = _lattice_cmp[0][len - 1];
+  __BUILD_TREE(inst, best_item);
+}
+
+void Decoder2O::free_lattice() {
+  int len = _lattice_cmp.nrows();
+  for (int i = 0; i < len; ++ i) {
+    for (int j = 0; j < len; ++ j) {
+      if (_lattice_incmp[i][j]) {
+        delete _lattice_incmp[i][j];
+      }
+
+      if (_lattice_cmp[i][j]) {
+        delete _lattice_cmp[i][j];
+      }
+
+      if (_lattice_sib[i][j]) {
+        delete _lattice_sib[i][j];
+      }
     }
+  }
 }
 
 
@@ -306,335 +306,335 @@ void Decoder2O::free_lattice() {
 // 2nd-order Decoder using dependency, sibling and grand features   //
 // ================================================================ //
 void Decoder2OCarreras::init_lattice(const Instance * inst) {
-    int len = inst->size();
-    _lattice_cmp.resize(len, len, len);
-    _lattice_incmp.resize(len, len, L);
+  int len = inst->size();
+  _lattice_cmp.resize(len, len, len);
+  _lattice_incmp.resize(len, len, L);
 
-    _lattice_cmp = NULL;
-    _lattice_incmp = NULL;
+  _lattice_cmp = NULL;
+  _lattice_incmp = NULL;
 
-    for (int i = 0; i < len; ++ i) {
-        _lattice_cmp[i][i][i] = new LatticeItem(i);
-    }
+  for (int i = 0; i < len; ++ i) {
+    _lattice_cmp[i][i][i] = new LatticeItem(i);
+  }
 }
 
 void Decoder2OCarreras::decode_projective(const Instance * inst) {
-    int len = inst->size();
-
-    for (int width = 1; width < len; ++ width) {
-        for (int s = 0; s + width < len; ++ s) {
-            int t = s + width;
-
-            // I(s, t) = C(s, r) + C(t, r + 1)
-            for (int l = 0; l < L; ++ l) {
-                for (int r = s; r < t; ++ r) {
-                    const LatticeItem * best_left_item = 0;
-                    double best_left_score = DOUBLE_NEG_INF;
-
-                    for (int cs = s; cs <= r; ++ cs) {
-                        if (cs == s && s != r) {
-                            continue;
-                        }
-
-                        const LatticeItem * item = _lattice_cmp[s][r][cs];
-
-                        if (!item) {
-                            continue;
-                        }
-
-                        double score = item->_prob;
-
-                        if (feat_opt.use_unlabeled_sibling) {
-                            score += inst->sibu_scores[s][t][cs];
-                        }
-
-                        if (feat_opt.use_labeled_sibling) {
-                            score += inst->sibl_scores[s][t][cs][l];
-                        }
-
-                        if (score > best_left_score) {
-                            best_left_item = item;
-                            best_left_score = score;
-                        }
-                    }
-
-                    const LatticeItem * best_right_item = 0;
-                    double best_right_score = DOUBLE_NEG_INF;
-
-                    for (int ct = r + 1; ct <= t; ++ ct) {
-                        if (ct == t &&  r + 1 != t) {
-                            continue;
-                        }
+  int len = inst->size();
+
+  for (int width = 1; width < len; ++ width) {
+    for (int s = 0; s + width < len; ++ s) {
+      int t = s + width;
+
+      // I(s, t) = C(s, r) + C(t, r + 1)
+      for (int l = 0; l < L; ++ l) {
+        for (int r = s; r < t; ++ r) {
+          const LatticeItem * best_left_item = 0;
+          double best_left_score = DOUBLE_NEG_INF;
+
+          for (int cs = s; cs <= r; ++ cs) {
+            if (cs == s && s != r) {
+              continue;
+            }
+
+            const LatticeItem * item = _lattice_cmp[s][r][cs];
+
+            if (!item) {
+              continue;
+            }
 
-                        const LatticeItem * item = _lattice_cmp[t][r + 1][ct];
-
-                        if (!item) {
-                            continue;
-                        }
-
-                        double score = item->_prob;
+            double score = item->_prob;
 
-                        if (feat_opt.use_unlabeled_grand && 
-                                (feat_opt.use_no_grand || ct != t)) {
-                            score += inst->grdu_scores[s][t][ct == t ? s : ct];
-                        }
-
-                        if (feat_opt.use_labeled_grand &&
-                                (feat_opt.use_no_grand || ct != t)) {
-                            score += inst->grdl_scores[s][t][ct == t ? s : ct][l];
-                        }
-
-                        if (score > best_right_score) {
-                            best_right_item = item;
-                            best_right_score = score;
-                        }
-                    }
-
-                    if (best_left_item && best_right_item) {
-                        double score = best_left_score + best_right_score;
-
-                        if (feat_opt.use_unlabeled_dependency) {
-                            score += inst->depu_scores[s][t];
-                        }
-
-                        if (feat_opt.use_labeled_dependency) {
-                            score += inst->depl_scores[s][t][l];
-                        }
-
-                        const LatticeItem * const item = new LatticeItem(INCMP,
-                                s,
-                                t,
-                                score,
-                                best_left_item,
-                                best_right_item,
-                                l);
-
-                        lattice_insert(_lattice_incmp[s][t][l], item);
-                    }   //  end for if !left || !right
-                }
-            }   //  end for for l = 0; l < L; ++ l
-
-            if (s != 0) {
-                // I(t, s) = C(s, r) + C(t, r + 1)
-                for (int l = 0; l < L; ++ l) {
-                    for (int r = s; r < t; ++ r) {
-                        const LatticeItem * best_left_item = 0;
-                        double best_left_score = DOUBLE_NEG_INF;
-
-                        for (int cs = s; cs <= r; ++ cs) {
-                            if (cs == s && s != r) {
-                                continue;
-                            }
-
-                            const LatticeItem * item = _lattice_cmp[s][r][cs];
-
-                            if (!item) {
-                                continue;
-                            }
-
-                            double score = item->_prob;
-
-                            if (feat_opt.use_unlabeled_grand && 
-                                    (feat_opt.use_no_grand || cs != s)) {
-                                score += inst->grdu_scores[t][s][cs];
-                            }
-
-                            if (feat_opt.use_labeled_grand &&
-                                    (feat_opt.use_no_grand || cs != s)) {
-                                score += inst->grdl_scores[t][s][cs][l];
-                            }
-
-                            if (score > best_left_score) {
-                                best_left_item = item;
-                                best_left_score = score;
-                            }
-                        }
-
-                        const LatticeItem * best_right_item = 0;
-                        double best_right_score = DOUBLE_NEG_INF;
-
-                        for (int ct = r + 1; ct <= t; ++ ct) {
-                            if (ct == t && r + 1 != t) {
-                                continue;
-                            }
-
-                            const LatticeItem * item = _lattice_cmp[t][r + 1][ct];
-
-                            if (!item) {
-                                continue;
-                            }
-
-                            double score = item->_prob;
-
-                            if (feat_opt.use_unlabeled_sibling) {
-                                score += inst->sibu_scores[t][s][ct];
-                            }
-
-                            if (feat_opt.use_labeled_sibling) {
-                                score += inst->sibl_scores[t][s][ct][l];
-                            }
-
-                            if (score > best_right_score) {
-                                best_right_item = item;
-                                best_right_score = score;
-                            }
-                        }
-
-                        if (best_left_item && best_right_item) {
-                            double score = best_left_score + best_right_score;
-
-                            if (feat_opt.use_unlabeled_dependency) {
-                                score += inst->depu_scores[t][s];
-                            }
-
-                            if (feat_opt.use_labeled_dependency) {
-                                score += inst->depl_scores[t][s][l];
-                            }
-
-                            const LatticeItem * const item = new LatticeItem( INCMP,
-                                    t,
-                                    s,
-                                    score,
-                                    best_left_item,
-                                    best_right_item,
-                                    l);
-
-                            lattice_insert(_lattice_incmp[t][s][l], item);
-                        }
-                    }
-                }
-            }   //  end for if s != 0
-
-            for (int m = s; m <= t; ++ m) {
-                if (m != s) {   // C(s, t, m) = I(s, m, l) + C(m, t, cm);
-                    for (int l = 0; l < L; ++ l) {
-                        const LatticeItem * const left = _lattice_incmp[s][m][l];
-
-                        if (!left) {
-                            continue;
-                        }
-
-                        for (int cm = m; cm <= t; ++ cm) {
-                            if (cm == m && cm != t) {
-                                continue;
-                            }
-
-                            const LatticeItem * const right = _lattice_cmp[m][t][cm];
-
-                            if (!right) {
-                                continue;
-                            }
-
-                            double score = left->_prob + right->_prob;
-
-                            if (feat_opt.use_unlabeled_grand &&
-                                    (feat_opt.use_no_grand || cm != m)) {
-                                score += inst->grdu_scores[s][m][cm];
-                            }
-
-                            if (feat_opt.use_labeled_grand &&
-                                    (feat_opt.use_no_grand || cm != m)) {
-                                score += inst->grdl_scores[s][m][cm][l];
-                            }
-
-                            const LatticeItem * const item = new LatticeItem(CMP,
-                                    s,
-                                    t,
-                                    score,
-                                    left,
-                                    right);
-
-                            lattice_insert(_lattice_cmp[s][t][m], item);
-                        }   //  end for (int cm = m; cm <= t; ++ cm)
-                    }       //  enf for (int l = 0; l < L; ++ l)
-                }           //  end for if (m != s)
-
-                if (m != t && s != 0) { // C(t, s, m) = C(m, s, cm) + I(t, m, l)
-                    for (int l = 0; l < L; ++ l) {
-                        const LatticeItem * const right = _lattice_incmp[t][m][l];
-
-                        if (!right) {
-                            continue;
-                        }
-
-                        for (int cm = s; cm <= m; ++ cm) {
-                            if (cm == m && cm != s) {
-                                continue;
-                            }
-
-                            const LatticeItem * const left = _lattice_cmp[m][s][cm];
-
-                            if (!left) {
-                                continue;
-                            }
-
-                            double score = left->_prob + right->_prob;
-
-                            if (feat_opt.use_unlabeled_grand && 
-                                    (feat_opt.use_no_grand || cm != m)) {
-                                score += inst->grdu_scores[t][m][cm == m ? t : cm];
-                            }
-
-                            if (feat_opt.use_labeled_grand &&
-                                    (feat_opt.use_no_grand || cm != m)) {
-                                score += inst->grdl_scores[t][m][cm == m ? t : cm][l];
-                            }
-
-                            const LatticeItem * const item = new LatticeItem(CMP,
-                                    t,
-                                    s,
-                                    score, 
-                                    left,
-                                    right);
-
-                            lattice_insert(_lattice_cmp[t][s][m], item);
-                        }   //  end for (int cm = s; cm <= m; ++ cm)
-                    }
-                }
+            if (feat_opt.use_unlabeled_sibling) {
+              score += inst->sibu_scores[s][t][cs];
             }
+
+            if (feat_opt.use_labeled_sibling) {
+              score += inst->sibl_scores[s][t][cs][l];
+            }
+
+            if (score > best_left_score) {
+              best_left_item = item;
+              best_left_score = score;
+            }
+          }
+
+          const LatticeItem * best_right_item = 0;
+          double best_right_score = DOUBLE_NEG_INF;
+
+          for (int ct = r + 1; ct <= t; ++ ct) {
+            if (ct == t &&  r + 1 != t) {
+              continue;
+            }
+
+            const LatticeItem * item = _lattice_cmp[t][r + 1][ct];
+
+            if (!item) {
+              continue;
+            }
+
+            double score = item->_prob;
+
+            if (feat_opt.use_unlabeled_grand &&
+                (feat_opt.use_no_grand || ct != t)) {
+              score += inst->grdu_scores[s][t][ct == t ? s : ct];
+            }
+
+            if (feat_opt.use_labeled_grand &&
+                (feat_opt.use_no_grand || ct != t)) {
+              score += inst->grdl_scores[s][t][ct == t ? s : ct][l];
+            }
+
+            if (score > best_right_score) {
+              best_right_item = item;
+              best_right_score = score;
+            }
+          }
+
+          if (best_left_item && best_right_item) {
+            double score = best_left_score + best_right_score;
+
+            if (feat_opt.use_unlabeled_dependency) {
+              score += inst->depu_scores[s][t];
+            }
+
+            if (feat_opt.use_labeled_dependency) {
+              score += inst->depl_scores[s][t][l];
+            }
+
+            const LatticeItem * const item = new LatticeItem(INCMP,
+                                                             s,
+                                                             t,
+                                                             score,
+                                                             best_left_item,
+                                                             best_right_item,
+                                                             l);
+
+            lattice_insert(_lattice_incmp[s][t][l], item);
+          }   //  end for if !left || !right
         }
+      }   //  end for for l = 0; l < L; ++ l
+
+      if (s != 0) {
+        // I(t, s) = C(s, r) + C(t, r + 1)
+        for (int l = 0; l < L; ++ l) {
+          for (int r = s; r < t; ++ r) {
+            const LatticeItem * best_left_item = 0;
+            double best_left_score = DOUBLE_NEG_INF;
+
+            for (int cs = s; cs <= r; ++ cs) {
+              if (cs == s && s != r) {
+                continue;
+              }
+
+              const LatticeItem * item = _lattice_cmp[s][r][cs];
+
+              if (!item) {
+                continue;
+              }
+
+              double score = item->_prob;
+
+              if (feat_opt.use_unlabeled_grand &&
+                  (feat_opt.use_no_grand || cs != s)) {
+                score += inst->grdu_scores[t][s][cs];
+              }
+
+              if (feat_opt.use_labeled_grand &&
+                  (feat_opt.use_no_grand || cs != s)) {
+                score += inst->grdl_scores[t][s][cs][l];
+              }
+
+              if (score > best_left_score) {
+                best_left_item = item;
+                best_left_score = score;
+              }
+            }
+
+            const LatticeItem * best_right_item = 0;
+            double best_right_score = DOUBLE_NEG_INF;
+
+            for (int ct = r + 1; ct <= t; ++ ct) {
+              if (ct == t && r + 1 != t) {
+                continue;
+              }
+
+              const LatticeItem * item = _lattice_cmp[t][r + 1][ct];
+
+              if (!item) {
+                continue;
+              }
+
+              double score = item->_prob;
+
+              if (feat_opt.use_unlabeled_sibling) {
+                score += inst->sibu_scores[t][s][ct];
+              }
+
+              if (feat_opt.use_labeled_sibling) {
+                score += inst->sibl_scores[t][s][ct][l];
+              }
+
+              if (score > best_right_score) {
+                best_right_item = item;
+                best_right_score = score;
+              }
+            }
+
+            if (best_left_item && best_right_item) {
+              double score = best_left_score + best_right_score;
+
+              if (feat_opt.use_unlabeled_dependency) {
+                score += inst->depu_scores[t][s];
+              }
+
+              if (feat_opt.use_labeled_dependency) {
+                score += inst->depl_scores[t][s][l];
+              }
+
+              const LatticeItem * const item = new LatticeItem(INCMP,
+                                                               t,
+                                                               s,
+                                                               score,
+                                                               best_left_item,
+                                                               best_right_item,
+                                                               l);
+
+              lattice_insert(_lattice_incmp[t][s][l], item);
+            }
+          }
+        }
+      }   //  end for if s != 0
+
+      for (int m = s; m <= t; ++ m) {
+        if (m != s) {   // C(s, t, m) = I(s, m, l) + C(m, t, cm);
+          for (int l = 0; l < L; ++ l) {
+            const LatticeItem * const left = _lattice_incmp[s][m][l];
+
+            if (!left) {
+              continue;
+            }
+
+            for (int cm = m; cm <= t; ++ cm) {
+              if (cm == m && cm != t) {
+                continue;
+              }
+
+              const LatticeItem * const right = _lattice_cmp[m][t][cm];
+
+              if (!right) {
+                continue;
+              }
+
+              double score = left->_prob + right->_prob;
+
+              if (feat_opt.use_unlabeled_grand &&
+                  (feat_opt.use_no_grand || cm != m)) {
+                score += inst->grdu_scores[s][m][cm];
+              }
+
+              if (feat_opt.use_labeled_grand &&
+                  (feat_opt.use_no_grand || cm != m)) {
+                score += inst->grdl_scores[s][m][cm][l];
+              }
+
+              const LatticeItem * const item = new LatticeItem(CMP,
+                                                               s,
+                                                               t,
+                                                               score,
+                                                               left,
+                                                               right);
+
+              lattice_insert(_lattice_cmp[s][t][m], item);
+            }   //  end for (int cm = m; cm <= t; ++ cm)
+          }     //  enf for (int l = 0; l < L; ++ l)
+        }       //  end for if (m != s)
+
+        if (m != t && s != 0) { // C(t, s, m) = C(m, s, cm) + I(t, m, l)
+          for (int l = 0; l < L; ++ l) {
+            const LatticeItem * const right = _lattice_incmp[t][m][l];
+
+            if (!right) {
+              continue;
+            }
+
+            for (int cm = s; cm <= m; ++ cm) {
+              if (cm == m && cm != s) {
+                continue;
+              }
+
+              const LatticeItem * const left = _lattice_cmp[m][s][cm];
+
+              if (!left) {
+                continue;
+              }
+
+              double score = left->_prob + right->_prob;
+
+              if (feat_opt.use_unlabeled_grand &&
+                  (feat_opt.use_no_grand || cm != m)) {
+                score += inst->grdu_scores[t][m][cm == m ? t : cm];
+              }
+
+              if (feat_opt.use_labeled_grand &&
+                  (feat_opt.use_no_grand || cm != m)) {
+                score += inst->grdl_scores[t][m][cm == m ? t : cm][l];
+              }
+
+              const LatticeItem * const item = new LatticeItem(CMP,
+                                                               t,
+                                                               s,
+                                                               score,
+                                                               left,
+                                                               right);
+
+              lattice_insert(_lattice_cmp[t][s][m], item);
+            }   //  end for (int cm = s; cm <= m; ++ cm)
+          }
+        }
+      }
     }
+  }
 }
 
 void Decoder2OCarreras::get_result(Instance * inst) {
-    int len = inst->size();
-    inst->predicted_heads.resize(len, -1);
-    if (model_opt.labeled) {
-        inst->predicted_deprelsidx.resize(len, -1);
+  int len = inst->size();
+  inst->predicted_heads.resize(len, -1);
+  if (model_opt.labeled) {
+    inst->predicted_deprelsidx.resize(len, -1);
+  }
+
+  const LatticeItem * best_item = NULL;
+  for (int c = 1; c < len; ++ c) {
+    const LatticeItem * item = _lattice_cmp[0][len - 1][c];
+    if (!item) {
+      continue;
     }
 
-    const LatticeItem * best_item = NULL;
-    for (int c = 1; c < len; ++ c) {
-        const LatticeItem * item = _lattice_cmp[0][len - 1][c];
-        if (!item) {
-            continue;
-        }
-
-        if (NULL == best_item || best_item->_prob < item->_prob) {
-            best_item = item;
-        }
+    if (NULL == best_item || best_item->_prob < item->_prob) {
+      best_item = item;
     }
+  }
 
-    __BUILD_TREE(inst, best_item);
+  __BUILD_TREE(inst, best_item);
 }
 
 void Decoder2OCarreras::free_lattice() {
-    int len = _lattice_cmp.dim1();
-    for (int i = 0; i < len; ++ i) {
-        for (int j = 0; j < len; ++ j) {
-            for (int l = 0; l < L; ++ l) {
-                if (_lattice_incmp[i][j][l]) {
-                    delete _lattice_incmp[i][j][l];
-                }
-            }
+  int len = _lattice_cmp.dim1();
+  for (int i = 0; i < len; ++ i) {
+    for (int j = 0; j < len; ++ j) {
+      for (int l = 0; l < L; ++ l) {
+        if (_lattice_incmp[i][j][l]) {
+          delete _lattice_incmp[i][j][l];
+        }
+      }
 
-            for (int k = 0; k < len; ++ k) {
-                if (_lattice_cmp[i][j][k]) {
-                    delete _lattice_cmp[i][j][k];
-                }
-            }
+      for (int k = 0; k < len; ++ k) {
+        if (_lattice_cmp[i][j][k]) {
+          delete _lattice_cmp[i][j][k];
         }
+      }
     }
+  }
 }
 
 }   //  end for namespace parser
diff --git a/src/parser/decoder2o.h b/src/parser/decoder2o.h
index fcd62227d..788bb3111 100644
--- a/src/parser/decoder2o.h
+++ b/src/parser/decoder2o.h
@@ -1,5 +1,5 @@
-#ifndef __DECODER_2_O_H__
-#define __DECODER_2_O_H__
+#ifndef __LTP_PARSER_DECODER_2_O_H__
+#define __LTP_PARSER_DECODER_2_O_H__
 
 #include "decoder.h"
 
@@ -9,39 +9,39 @@ namespace parser {
 // 2nd-order decoder with dependency features and sibling features
 class Decoder2O : public Decoder {
 public:
-    Decoder2O(int _L = 1) : L(_L) {}
+  Decoder2O(int _L = 1) : L(_L) {}
 
 public:
-    void init_lattice(const Instance * inst);
-    void decode_projective(const Instance * inst);
-    void get_result(Instance * inst);
-    void free_lattice();
+  void init_lattice(const Instance * inst);
+  void decode_projective(const Instance * inst);
+  void get_result(Instance * inst);
+  void free_lattice();
 private:
-    int L;
-    Mat< const LatticeItem * > _lattice_cmp;
-    Mat< const LatticeItem * > _lattice_incmp;
-    Mat< const LatticeItem * > _lattice_sib;
+  int L;
+  Mat< const LatticeItem * > _lattice_cmp;
+  Mat< const LatticeItem * > _lattice_incmp;
+  Mat< const LatticeItem * > _lattice_sib;
 
 };
 
 // 2nd-order decoder with dependency, sibling and grand features
 class Decoder2OCarreras : public Decoder {
 public:
-    Decoder2OCarreras(int _L = 1) : L(_L) {}
+  Decoder2OCarreras(int _L = 1) : L(_L) {}
 
 public:
-    void init_lattice(const Instance * inst);
-    void decode_projective(const Instance * inst);
-    void get_result(Instance *  inst);
-    void free_lattice();
+  void init_lattice(const Instance * inst);
+  void decode_projective(const Instance * inst);
+  void get_result(Instance *  inst);
+  void free_lattice();
 private:
-    int L;
-    Mat3< const LatticeItem * > _lattice_cmp;
-    Mat3< const LatticeItem * > _lattice_incmp;
+  int L;
+  Mat3< const LatticeItem * > _lattice_cmp;
+  Mat3< const LatticeItem * > _lattice_incmp;
 
 };
 
 }   //  end for namespace parser
 }   //  end for namespace ltp
 
-#endif  //  end for __DECODER_2_O__
+#endif  //  end for __LTP_PARSER_DECODER_2_O_H__
diff --git a/src/parser/extractor.cpp b/src/parser/extractor.cpp
index 00bf56ad8..553e818dd 100644
--- a/src/parser/extractor.cpp
+++ b/src/parser/extractor.cpp
@@ -2,19 +2,19 @@
 #include "options.h"
 #include "settings.h"
 
-#define LEN(x)      (x.size())
-#define LAST(x)     ((x)[(x).size()-1])
-#define FIRST(x)    ((x)[0])
+#define LEN(x)    (x.size())
+#define LAST(x)   ((x)[(x).size()-1])
+#define FIRST(x)  ((x)[0])
 
 #define PUSH(x) do {\
-    cache.push_back((x)); \
+  cache.push_back((x)); \
 }while(0);
 
 #define PUSH_DIST(x) do { \
-    if (feat_opt.use_distance_in_features) { \
-        (x).append(dist); \
-        PUSH(x);    \
-    } \
+  if (feat_opt.use_distance_in_features) { \
+    (x).append(dist); \
+    PUSH(x);  \
+  } \
 } while (0);
 
 namespace ltp {
@@ -22,33 +22,33 @@ namespace parser {
 
 // function of GET direction
 void Extractor::__GET_DIRECTION(int head_id, int child_id, string& direction) {
-    if (head_id == 0) {
-        direction = "L#R";
-    } else {
-        direction = (head_id > child_id ? "L" : "R");
-    }
+  if (head_id == 0) {
+    direction = "L#R";
+  } else {
+    direction = (head_id > child_id ? "L" : "R");
+  }
 }
 
 void Extractor::__GET_DISTANCE_1_2_36_7(int head_id, int child_id, string& distance) {
-    int dist = (head_id > child_id ? head_id - child_id : child_id - head_id) ;
-
-    if (dist < 3) {
-        ostringstream S; S << dist; 
-        distance = S.str();
-    } else if (dist < 7) {
-        distance = "<7";
-    } else {
-        distance = ">6";
-    }
+  int dist = (head_id > child_id ? head_id - child_id : child_id - head_id) ;
+
+  if (dist < 3) {
+    ostringstream S; S << dist; 
+    distance = S.str();
+  } else if (dist < 7) {
+    distance = "<7";
+  } else {
+    distance = ">6";
+  }
 }
 
 const string POSUExtractor::prefix = "PU-";
 
 // ================================================================ //
-// Dependency Features Extractor                                    //
-//  feature templates is listed in `extractor.h`                    //
+// Dependency Features Extractor                  //
+//  feature templates is listed in `extractor.h`          //
 //  the DEPExtractor is a singleton, which only be construct once   //
-//  during the life of the program.                                 //
+//  during the life of the program.                 //
 // ================================================================ //
 
 // Initialize the static member
@@ -58,302 +58,302 @@ vector<Template *> DEPExtractor::templates;
 // Constructor for DEPExtractor, initialize templates for dependency
 // features. It's some kind of tedious coding work.
 DEPExtractor::DEPExtractor() {
-    templates.reserve(100);
-
-    // basic dependency unigram feature group
-    if (feat_opt.use_dependency_unigram) {
-        templates.push_back(new Template("1={f-hid}-{p-hid}-{dir}"));
-        templates.push_back(new Template("2={f-hid}-{dir}"));
-        templates.push_back(new Template("3={p-hid}-{dir}"));
-        templates.push_back(new Template("4={f-cid}-{p-cid}-{dir}"));
-        templates.push_back(new Template("5={f-cid}-{dir}"));
-        templates.push_back(new Template("6={p-cid}-{dir}"));
-
-        if (feat_opt.use_distance_in_features) {
-            templates.push_back(new Template("1={f-hid}-{p-hid}-{dir}-{dist}"));
-            templates.push_back(new Template("2={f-hid}-{dir}-{dist}"));
-            templates.push_back(new Template("3={p-hid}-{dir}-{dist}"));
-            templates.push_back(new Template("4={f-cid}-{p-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("5={f-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("6={p-cid}-{dir}-{dist}"));
-        }
-
-    }   //  end for if use dependency unigram
-
-    if (feat_opt.use_dependency_unigram && feat_opt.use_lemma) {
-        templates.push_back(new Template("77={l-hid}-{p-hid}-{dir}"));
-        templates.push_back(new Template("78={l-hid}-{dir}"));
-        templates.push_back(new Template("80={l-cid}-{p-cid}-{dir}"));
-        templates.push_back(new Template("81={l-cid}-{dir}"));
-
-        if (feat_opt.use_distance_in_features) {
-            templates.push_back(new Template("77={l-hid}-{p-hid}-{dir}-{dist}"));
-            templates.push_back(new Template("78={l-hid}-{dir}-{dist}"));
-            // templates.push_back(new Template("80={l-cid}-{p-cid}-{dir}"));
-            // templates.push_back(new Template("81={l-cid}-{dir}"));
-        }   // end for if use distance in dependency features
-    }   //  end for if use lemma
-
-    if (feat_opt.use_dependency_unigram && feat_opt.use_coarse_postag) {
-        templates.push_back(new Template("1C={f-hid}-{cp-hid}-{dir}"));
-        templates.push_back(new Template("3C={cp-hid}-{dir}"));
-        templates.push_back(new Template("4C={f-cid}-{cp-cid}-{dir}"));
-        templates.push_back(new Template("6C={cp-cid}-{dir}"));
-
-        if (feat_opt.use_distance_in_features) {
-            templates.push_back(new Template("1C={f-hid}-{cp-hid}-{dir}-{dist}"));
-            templates.push_back(new Template("3C={cp-hid}-{dir}-{dist}"));
-            templates.push_back(new Template("4C={f-cid}-{cp-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("6C={cp-cid}-{dir}-{dist}"));
-        }
-    }   //  end for use unigram and use coarse
-
-    if (feat_opt.use_dependency_bigram) {
-        templates.push_back(new Template("7={f-hid}-{p-hid}-{f-cid}-{p-cid}-{dir}"));
-        templates.push_back(new Template("8={p-hid}-{f-cid}-{p-cid}-{dir}"));
-        templates.push_back(new Template("9={f-hid}-{f-cid}-{p-cid}-{dir}"));
-        templates.push_back(new Template("10={f-hid}-{p-hid}-{p-cid}-{dir}"));
-        templates.push_back(new Template("11={f-hid}-{p-hid}-{f-cid}-{dir}"));
-        templates.push_back(new Template("12={f-hid}-{f-cid}-{dir}"));
-        templates.push_back(new Template("13={p-hid}-{p-cid}-{dir}"));
-        templates.push_back(new Template("12?={f-hid}-{p-cid}-{dir}"));
-        templates.push_back(new Template("13?={p-hid}-{f-cid}-{dir}"));
-
-        if (feat_opt.use_distance_in_features) {
-            // templates.push_back(new Template("7={f-hid}-{p-hid}-{f-cid}-{p-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("8={p-hid}-{f-cid}-{p-cid}-{dir}-{dist}"));
-            // templates.push_back(new Template("9={f-hid}-{f-cid}-{p-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("10={f-hid}-{p-hid}-{p-cid}-{dir}-{dist}"));
-            // templates.push_back(new Template("11={f-hid}-{p-hid}-{f-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("12={f-hid}-{f-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("13={p-hid}-{p-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("12?={f-hid}-{p-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("13?={p-hid}-{f-cid}-{dir}-{dist}"));
-        }
-    }   //  end for if use dependency bigram
-
-    if (feat_opt.use_dependency_bigram && feat_opt.use_lemma) {
-        templates.push_back(new Template("83={l-hid}-{p-hid}-{l-cid}-{p-cid}-{dir}"));
-        templates.push_back(new Template("84={p-hid}-{l-cid}-{p-cid}-{dir}"));
-        templates.push_back(new Template("85={l-hid}-{p-hid}-{p-cid}-{dir}"));
-        templates.push_back(new Template("86={l-hid}-{p-hid}-{p-cid}-{dir}"));
-        templates.push_back(new Template("87={l-hid}-{p-hid}-{l-cid}-{dir}"));
-
-        if (feat_opt.use_distance_in_features) {
-            // templates.push_back(new Template("83={l-hid}-{p-hid}-{l-cid}-{p-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("84={p-hid}-{l-cid}-{p-cid}-{dir}-{dist}"));
-            // templates.push_back(new Template("85={l-hid}-{p-hid}-{p-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("86={l-hid}-{p-hid}-{p-cid}-{dir}-{dist}"));
-            // templates.push_back(new Template("87={l-hid}-{p-hid}-{l-cid}-{dir}-{dist}"));
-       }
-    }   //  end for is use dependency bigram and use lemma
-
-    if (feat_opt.use_dependency_bigram && feat_opt.use_coarse_postag) {
-        templates.push_back(new Template("7C={f-hid}-{cp-hid}-{f-cid}-{cp-cid}-{dir}"));
-        templates.push_back(new Template("8C={cp-hid}-{f-cid}-{cp-cid}-{dir}"));
-        templates.push_back(new Template("9C={f-hid}-{f-cid}-{cp-cid}-{dir}"));
-        templates.push_back(new Template("10C={f-hid}-{cp-hid}-{cp-cid}-{dir}"));
-        templates.push_back(new Template("11C={f-hid}-{cp-hid}-{f-cid}-{dir}"));
-        //templates.push_back(new Template("12C={f-hid}-{f-cid}-{dir}"));
-        templates.push_back(new Template("13C={p-hid}-{cp-cid}-{dir}"));
-        templates.push_back(new Template("12?C={f-hid}-c{p-cid}-{dir}"));
-        templates.push_back(new Template("13?C={cp-hid}-{f-cid}-{dir}"));
-        if (feat_opt.use_distance_in_features) {
-            templates.push_back(new Template("7C={f-hid}-{cp-hid}-{f-cid}-{cp-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("8C={cp-hid}-{f-cid}-{cp-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("9C={f-hid}-{f-cid}-{cp-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("10C={f-hid}-{cp-hid}-{cp-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("11C={f-hid}-{cp-hid}-{f-cid}-{dir}-{dist}"));
-            //templates.push_back(new Template("12C={f-hid}-{f-cid}-{dir}"));
-            templates.push_back(new Template("13C={p-hid}-{cp-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("12?C={f-hid}-c{p-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("13?C={cp-hid}-{f-cid}-{dir}-{dist}"));
-        }
+  templates.reserve(100);
+
+  // basic dependency unigram feature group
+  if (feat_opt.use_dependency_unigram) {
+    templates.push_back(new Template("1={f-hid}-{p-hid}-{dir}"));
+    templates.push_back(new Template("2={f-hid}-{dir}"));
+    templates.push_back(new Template("3={p-hid}-{dir}"));
+    templates.push_back(new Template("4={f-cid}-{p-cid}-{dir}"));
+    templates.push_back(new Template("5={f-cid}-{dir}"));
+    templates.push_back(new Template("6={p-cid}-{dir}"));
+
+    if (feat_opt.use_distance_in_features) {
+      templates.push_back(new Template("1={f-hid}-{p-hid}-{dir}-{dist}"));
+      templates.push_back(new Template("2={f-hid}-{dir}-{dist}"));
+      templates.push_back(new Template("3={p-hid}-{dir}-{dist}"));
+      templates.push_back(new Template("4={f-cid}-{p-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("5={f-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("6={p-cid}-{dir}-{dist}"));
     }
 
-    if (feat_opt.use_dependency_surrounding) {
-        templates.push_back(new Template("14={p-hid}-{p-hid+1}-{p-cid}-{dir}"));
-        templates.push_back(new Template("15={p-hid}-{p-cid-1}-{p-cid}-{dir}"));
-        templates.push_back(new Template("16={p-hid}-{p-cid}-{p-cid+1}-{dir}"));
-        templates.push_back(new Template("17={p-hid}-{p-hid+1}-{p-cid-1}-{p-cid}-{dir}"));
-        templates.push_back(new Template("18={p-hid-1}-{p-hid+1}-{p-cid-1}-{p-cid}-{dir}"));
-        templates.push_back(new Template("19={p-hid}-{p-hid+1}-{p-cid}-{p-cid+1}-{dir}"));
-        templates.push_back(new Template("20={p-hid-1}-{p-hid}-{p-cid-1}-{p-cid}-{dir}"));
-        templates.push_back(new Template("?20={p-hid-1}-{p-hid}-{p-hid+1}-{p-cid}-{dir}"));
-        templates.push_back(new Template("?19={p-hid}-{p-cid-1}-{p-cid}-{p-cid+1}-{dir}"));
-
-        if (feat_opt.use_distance_in_features) {
-            templates.push_back(new Template("14={p-hid}-{p-hid+1}-{p-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("15={p-hid}-{p-cid-1}-{p-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("16={p-hid}-{p-cid}-{p-cid+1}-{dir}-{dist}"));
-            templates.push_back(new Template("17={p-hid}-{p-hid+1}-{p-cid-1}-{p-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("18={p-hid-1}-{p-hid+1}-{p-cid-1}-{p-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("19={p-hid}-{p-hid+1}-{p-cid}-{p-cid+1}-{dir}-{dist}"));
-            templates.push_back(new Template("20={p-hid-1}-{p-hid}-{p-cid-1}-{p-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("?20={p-hid-1}-{p-hid}-{p-hid+1}-{p-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("?19={p-hid}-{p-cid-1}-{p-cid}-{p-cid+1}-{dir}-{dist}"));
-        }
+  }   //  end for if use dependency unigram
+
+  if (feat_opt.use_dependency_unigram && feat_opt.use_lemma) {
+    templates.push_back(new Template("77={l-hid}-{p-hid}-{dir}"));
+    templates.push_back(new Template("78={l-hid}-{dir}"));
+    templates.push_back(new Template("80={l-cid}-{p-cid}-{dir}"));
+    templates.push_back(new Template("81={l-cid}-{dir}"));
+
+    if (feat_opt.use_distance_in_features) {
+      templates.push_back(new Template("77={l-hid}-{p-hid}-{dir}-{dist}"));
+      templates.push_back(new Template("78={l-hid}-{dir}-{dist}"));
+      // templates.push_back(new Template("80={l-cid}-{p-cid}-{dir}"));
+      // templates.push_back(new Template("81={l-cid}-{dir}"));
+    }   // end for if use distance in dependency features
+  }   //  end for if use lemma
+
+  if (feat_opt.use_dependency_unigram && feat_opt.use_coarse_postag) {
+    templates.push_back(new Template("1C={f-hid}-{cp-hid}-{dir}"));
+    templates.push_back(new Template("3C={cp-hid}-{dir}"));
+    templates.push_back(new Template("4C={f-cid}-{cp-cid}-{dir}"));
+    templates.push_back(new Template("6C={cp-cid}-{dir}"));
+
+    if (feat_opt.use_distance_in_features) {
+      templates.push_back(new Template("1C={f-hid}-{cp-hid}-{dir}-{dist}"));
+      templates.push_back(new Template("3C={cp-hid}-{dir}-{dist}"));
+      templates.push_back(new Template("4C={f-cid}-{cp-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("6C={cp-cid}-{dir}-{dist}"));
+    }
+  }   //  end for use unigram and use coarse
+
+  if (feat_opt.use_dependency_bigram) {
+    templates.push_back(new Template("7={f-hid}-{p-hid}-{f-cid}-{p-cid}-{dir}"));
+    templates.push_back(new Template("8={p-hid}-{f-cid}-{p-cid}-{dir}"));
+    templates.push_back(new Template("9={f-hid}-{f-cid}-{p-cid}-{dir}"));
+    templates.push_back(new Template("10={f-hid}-{p-hid}-{p-cid}-{dir}"));
+    templates.push_back(new Template("11={f-hid}-{p-hid}-{f-cid}-{dir}"));
+    templates.push_back(new Template("12={f-hid}-{f-cid}-{dir}"));
+    templates.push_back(new Template("13={p-hid}-{p-cid}-{dir}"));
+    templates.push_back(new Template("12?={f-hid}-{p-cid}-{dir}"));
+    templates.push_back(new Template("13?={p-hid}-{f-cid}-{dir}"));
+
+    if (feat_opt.use_distance_in_features) {
+      // templates.push_back(new Template("7={f-hid}-{p-hid}-{f-cid}-{p-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("8={p-hid}-{f-cid}-{p-cid}-{dir}-{dist}"));
+      // templates.push_back(new Template("9={f-hid}-{f-cid}-{p-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("10={f-hid}-{p-hid}-{p-cid}-{dir}-{dist}"));
+      // templates.push_back(new Template("11={f-hid}-{p-hid}-{f-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("12={f-hid}-{f-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("13={p-hid}-{p-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("12?={f-hid}-{p-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("13?={p-hid}-{f-cid}-{dir}-{dist}"));
+    }
+  }   //  end for if use dependency bigram
+
+  if (feat_opt.use_dependency_bigram && feat_opt.use_lemma) {
+    templates.push_back(new Template("83={l-hid}-{p-hid}-{l-cid}-{p-cid}-{dir}"));
+    templates.push_back(new Template("84={p-hid}-{l-cid}-{p-cid}-{dir}"));
+    templates.push_back(new Template("85={l-hid}-{p-hid}-{p-cid}-{dir}"));
+    templates.push_back(new Template("86={l-hid}-{p-hid}-{p-cid}-{dir}"));
+    templates.push_back(new Template("87={l-hid}-{p-hid}-{l-cid}-{dir}"));
+
+    if (feat_opt.use_distance_in_features) {
+      // templates.push_back(new Template("83={l-hid}-{p-hid}-{l-cid}-{p-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("84={p-hid}-{l-cid}-{p-cid}-{dir}-{dist}"));
+      // templates.push_back(new Template("85={l-hid}-{p-hid}-{p-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("86={l-hid}-{p-hid}-{p-cid}-{dir}-{dist}"));
+      // templates.push_back(new Template("87={l-hid}-{p-hid}-{l-cid}-{dir}-{dist}"));
+     }
+  }   //  end for is use dependency bigram and use lemma
+
+  if (feat_opt.use_dependency_bigram && feat_opt.use_coarse_postag) {
+    templates.push_back(new Template("7C={f-hid}-{cp-hid}-{f-cid}-{cp-cid}-{dir}"));
+    templates.push_back(new Template("8C={cp-hid}-{f-cid}-{cp-cid}-{dir}"));
+    templates.push_back(new Template("9C={f-hid}-{f-cid}-{cp-cid}-{dir}"));
+    templates.push_back(new Template("10C={f-hid}-{cp-hid}-{cp-cid}-{dir}"));
+    templates.push_back(new Template("11C={f-hid}-{cp-hid}-{f-cid}-{dir}"));
+    //templates.push_back(new Template("12C={f-hid}-{f-cid}-{dir}"));
+    templates.push_back(new Template("13C={p-hid}-{cp-cid}-{dir}"));
+    templates.push_back(new Template("12?C={f-hid}-c{p-cid}-{dir}"));
+    templates.push_back(new Template("13?C={cp-hid}-{f-cid}-{dir}"));
+    if (feat_opt.use_distance_in_features) {
+      templates.push_back(new Template("7C={f-hid}-{cp-hid}-{f-cid}-{cp-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("8C={cp-hid}-{f-cid}-{cp-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("9C={f-hid}-{f-cid}-{cp-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("10C={f-hid}-{cp-hid}-{cp-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("11C={f-hid}-{cp-hid}-{f-cid}-{dir}-{dist}"));
+      //templates.push_back(new Template("12C={f-hid}-{f-cid}-{dir}"));
+      templates.push_back(new Template("13C={p-hid}-{cp-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("12?C={f-hid}-c{p-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("13?C={cp-hid}-{f-cid}-{dir}-{dist}"));
     }
+  }
+
+  if (feat_opt.use_dependency_surrounding) {
+    templates.push_back(new Template("14={p-hid}-{p-hid+1}-{p-cid}-{dir}"));
+    templates.push_back(new Template("15={p-hid}-{p-cid-1}-{p-cid}-{dir}"));
+    templates.push_back(new Template("16={p-hid}-{p-cid}-{p-cid+1}-{dir}"));
+    templates.push_back(new Template("17={p-hid}-{p-hid+1}-{p-cid-1}-{p-cid}-{dir}"));
+    templates.push_back(new Template("18={p-hid-1}-{p-hid+1}-{p-cid-1}-{p-cid}-{dir}"));
+    templates.push_back(new Template("19={p-hid}-{p-hid+1}-{p-cid}-{p-cid+1}-{dir}"));
+    templates.push_back(new Template("20={p-hid-1}-{p-hid}-{p-cid-1}-{p-cid}-{dir}"));
+    templates.push_back(new Template("?20={p-hid-1}-{p-hid}-{p-hid+1}-{p-cid}-{dir}"));
+    templates.push_back(new Template("?19={p-hid}-{p-cid-1}-{p-cid}-{p-cid+1}-{dir}"));
+
+    if (feat_opt.use_distance_in_features) {
+      templates.push_back(new Template("14={p-hid}-{p-hid+1}-{p-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("15={p-hid}-{p-cid-1}-{p-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("16={p-hid}-{p-cid}-{p-cid+1}-{dir}-{dist}"));
+      templates.push_back(new Template("17={p-hid}-{p-hid+1}-{p-cid-1}-{p-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("18={p-hid-1}-{p-hid+1}-{p-cid-1}-{p-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("19={p-hid}-{p-hid+1}-{p-cid}-{p-cid+1}-{dir}-{dist}"));
+      templates.push_back(new Template("20={p-hid-1}-{p-hid}-{p-cid-1}-{p-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("?20={p-hid-1}-{p-hid}-{p-hid+1}-{p-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("?19={p-hid}-{p-cid-1}-{p-cid}-{p-cid+1}-{dir}-{dist}"));
+    }
+  }
+
+  if (feat_opt.use_dependency_surrounding && feat_opt.use_coarse_postag) {
+    templates.push_back(new Template("14C={cp-hid}-{cp-hid+1}-{cp-cid}-{dir}"));
+    templates.push_back(new Template("15C={cp-hid}-{cp-cid-1}-{cp-cid}-{dir}"));
+    templates.push_back(new Template("16C={cp-hid}-{cp-cid}-{cp-cid+1}-{dir}"));
+    templates.push_back(new Template("17C={cp-hid}-{cp-hid+1}-{cp-cid-1}-{cp-cid}-{dir}"));
+    templates.push_back(new Template("18C={cp-hid-1}-{cp-hid+1}-{cp-cid-1}-{cp-cid}-{dir}"));
+    templates.push_back(new Template("19C={cp-hid}-{cp-hid+1}-{cp-cid}-{cp-cid+1}-{dir}"));
+    templates.push_back(new Template("20C={cp-hid-1}-{cp-hid}-{cp-hid+1}-{cp-cid}-{dir}"));
+    templates.push_back(new Template("?20C={cp-hid-1}-{cp-hid}-{cp-hid+1}-{cp-cid}-{dir}"));
+    templates.push_back(new Template("?19C={cp-hid}-{cp-cid-1}-{cp-cid}-{cp-cid+1}-{dir}"));
+
+    if (feat_opt.use_distance_in_features) {
+      templates.push_back(new Template("14C={cp-hid}-{cp-hid+1}-{cp-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("15C={cp-hid}-{cp-cid-1}-{cp-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("16C={cp-hid}-{cp-cid}-{cp-cid+1}-{dir}-{dist}"));
+      templates.push_back(new Template("17C={cp-hid}-{cp-hid+1}-{cp-cid-1}-{cp-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("18C={cp-hid-1}-{cp-hid+1}-{cp-cid-1}-{cp-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("19C={cp-hid}-{cp-hid+1}-{cp-cid}-{cp-cid+1}-{dir}-{dist}"));
+      templates.push_back(new Template("20C={cp-hid-1}-{cp-hid}-{cp-hid+1}-{cp-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("?20={cp-hid-1}-{cp-hid}-{cp-hid+1}-{cp-cid}-{dir}-{dist}"));
+      templates.push_back(new Template("?19={cp-hid}-{cp-cid-1}-{cp-cid}-{cp-cid+1}-{dir}-{dist}"));
+    }
+  }
+
+  if (feat_opt.use_dependency_between) {
+    templates.push_back(new Template("39={p-sid}-verb={verbcnt}-{p-lid}-{dir}"));
+    templates.push_back(new Template("39={p-sid}-conj={conjcnt}-{p-lid}-{dir}"));
+    templates.push_back(new Template("39={p-sid}-punc={punccnt}-{p-lid}-{dir}"));
 
-    if (feat_opt.use_dependency_surrounding && feat_opt.use_coarse_postag) {
-        templates.push_back(new Template("14C={cp-hid}-{cp-hid+1}-{cp-cid}-{dir}"));
-        templates.push_back(new Template("15C={cp-hid}-{cp-cid-1}-{cp-cid}-{dir}"));
-        templates.push_back(new Template("16C={cp-hid}-{cp-cid}-{cp-cid+1}-{dir}"));
-        templates.push_back(new Template("17C={cp-hid}-{cp-hid+1}-{cp-cid-1}-{cp-cid}-{dir}"));
-        templates.push_back(new Template("18C={cp-hid-1}-{cp-hid+1}-{cp-cid-1}-{cp-cid}-{dir}"));
-        templates.push_back(new Template("19C={cp-hid}-{cp-hid+1}-{cp-cid}-{cp-cid+1}-{dir}"));
-        templates.push_back(new Template("20C={cp-hid-1}-{cp-hid}-{cp-hid+1}-{cp-cid}-{dir}"));
-        templates.push_back(new Template("?20C={cp-hid-1}-{cp-hid}-{cp-hid+1}-{cp-cid}-{dir}"));
-        templates.push_back(new Template("?19C={cp-hid}-{cp-cid-1}-{cp-cid}-{cp-cid+1}-{dir}"));
-
-        if (feat_opt.use_distance_in_features) {
-            templates.push_back(new Template("14C={cp-hid}-{cp-hid+1}-{cp-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("15C={cp-hid}-{cp-cid-1}-{cp-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("16C={cp-hid}-{cp-cid}-{cp-cid+1}-{dir}-{dist}"));
-            templates.push_back(new Template("17C={cp-hid}-{cp-hid+1}-{cp-cid-1}-{cp-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("18C={cp-hid-1}-{cp-hid+1}-{cp-cid-1}-{cp-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("19C={cp-hid}-{cp-hid+1}-{cp-cid}-{cp-cid+1}-{dir}-{dist}"));
-            templates.push_back(new Template("20C={cp-hid-1}-{cp-hid}-{cp-hid+1}-{cp-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("?20={cp-hid-1}-{cp-hid}-{cp-hid+1}-{cp-cid}-{dir}-{dist}"));
-            templates.push_back(new Template("?19={cp-hid}-{cp-cid-1}-{cp-cid}-{cp-cid+1}-{dir}-{dist}"));
-        }
+    if (feat_opt.use_distance_in_features) {
+      templates.push_back(new Template("39={p-sid}-verb={verbcnt}-{p-lid}-{dir}-{dist}"));
+      templates.push_back(new Template("39={p-sid}-conj={conjcnt}-{p-lid}-{dir}-{dist}"));
+      templates.push_back(new Template("39={p-sid}-punc={punccnt}-{p-lid}-{dir}-{dist}"));
     }
 
-    if (feat_opt.use_dependency_between) {
-        templates.push_back(new Template("39={p-sid}-verb={verbcnt}-{p-lid}-{dir}"));
-        templates.push_back(new Template("39={p-sid}-conj={conjcnt}-{p-lid}-{dir}"));
-        templates.push_back(new Template("39={p-sid}-punc={punccnt}-{p-lid}-{dir}"));
-
-        if (feat_opt.use_distance_in_features) {
-            templates.push_back(new Template("39={p-sid}-verb={verbcnt}-{p-lid}-{dir}-{dist}"));
-            templates.push_back(new Template("39={p-sid}-conj={conjcnt}-{p-lid}-{dir}-{dist}"));
-            templates.push_back(new Template("39={p-sid}-punc={punccnt}-{p-lid}-{dir}-{dist}"));
-        }
-
-        // a dirty trick here, template 39 will generate several feature from on single
-        // template, place this two template at last.
-        templates.push_back(new Template("39={p-sid}-{p-bid}-{p-lid}-{dir}"));
-        if (feat_opt.use_distance_in_features) {
-            templates.push_back(new Template("39={p-sid}-{p-bid}-{p-lid}-{dir}-{dist}"));
-        }
+    // a dirty trick here, template 39 will generate several feature from on single
+    // template, place this two template at last.
+    templates.push_back(new Template("39={p-sid}-{p-bid}-{p-lid}-{dir}"));
+    if (feat_opt.use_distance_in_features) {
+      templates.push_back(new Template("39={p-sid}-{p-bid}-{p-lid}-{dir}-{dist}"));
     }
+  }
 }
 
 DEPExtractor::~DEPExtractor() {
-    for (int i = 0; i < templates.size(); ++ i) {
-        delete templates[i];
-    }
+  for (int i = 0; i < templates.size(); ++ i) {
+    delete templates[i];
+  }
 }
 
 // accessment function, which return the singleton class
 DEPExtractor * DEPExtractor::extractor() {
-    if (0 == instance_) {
-        instance_ = new DEPExtractor;
-    }
+  if (0 == instance_) {
+    instance_ = new DEPExtractor;
+  }
 
-    return instance_;
+  return instance_;
 }
 
 // get number of templates
 int DEPExtractor::num_templates() {
-    if (0 == instance_) {
-        instance_ = new DEPExtractor;
-    }
+  if (0 == instance_) {
+    instance_ = new DEPExtractor;
+  }
 
-    return templates.size();
+  return templates.size();
 }
 
 int DEPExtractor::extract2o(Instance * inst, int hid, int cid, vector< StringVec > & cache) {
-    int len = inst->size();
-
-    // if the postag count is not calculate, calculate the postag.
-    if (inst->verb_cnt.size() == 0) {
-        inst->verb_cnt.resize(len, 0);
-        inst->conj_cnt.resize(len, 0);
-        inst->punc_cnt.resize(len, 0);
-
-        for (int h = 1; h < len; ++ h) {
-            inst->verb_cnt[h] = inst->verb_cnt[h - 1];
-            inst->conj_cnt[h] = inst->conj_cnt[h - 1];
-            inst->punc_cnt[h] = inst->punc_cnt[h - 1];
-
-            const string & tag = inst->postags[h];
-
-            if(tag == "v" || tag == "V") {
-                ++ inst->verb_cnt[h];
-            } else if(tag == "wp" || tag == "WP" || tag == "Punc" || tag == "PU" || tag == "," || tag == ":") {
-                ++ inst->punc_cnt[h];
-            } else if( tag == "Conj" || tag == "CC" || tag == "cc" || tag == "c") {
-                ++ inst->conj_cnt[h];
-            }
-        }
+  int len = inst->size();
+
+  // if the postag count is not calculate, calculate the postag.
+  if (inst->verb_cnt.size() == 0) {
+    inst->verb_cnt.resize(len, 0);
+    inst->conj_cnt.resize(len, 0);
+    inst->punc_cnt.resize(len, 0);
+
+    for (int h = 1; h < len; ++ h) {
+      inst->verb_cnt[h] = inst->verb_cnt[h - 1];
+      inst->conj_cnt[h] = inst->conj_cnt[h - 1];
+      inst->punc_cnt[h] = inst->punc_cnt[h - 1];
+
+      const string & tag = inst->postags[h];
+
+      if(tag == "v" || tag == "V") {
+        ++ inst->verb_cnt[h];
+      } else if(tag == "wp" || tag == "WP" || tag == "Punc" || tag == "PU" || tag == "," || tag == ":") {
+        ++ inst->punc_cnt[h];
+      } else if( tag == "Conj" || tag == "CC" || tag == "cc" || tag == "c") {
+        ++ inst->conj_cnt[h];
+      }
     }
-
-    string dir, dist, feat;
-
-    __GET_DIRECTION(hid, cid, dir);
-    __GET_DISTANCE_1_2_36_7(hid, cid, dist);
-
-    Template::Data data;
-
-    bool is_root = (hid == 0);
-
-    data.set( "f-hid",   inst->forms[hid] );
-    data.set( "f-cid",   inst->forms[cid] );
-    data.set( "p-hid",   inst->postags[hid] );
-    data.set( "p-cid",   inst->postags[cid] );
-    data.set( "p-hid-1", ((hid <= 1) ? NONE_POSTAG : inst->postags[hid - 1]) );
-    data.set( "p-hid+1", ((is_root || hid+1 >= len) ? NONE_POSTAG : inst->postags[hid + 1]) );
-    data.set( "p-cid-1", ((cid <= 1) ? NONE_POSTAG : inst->postags[cid - 1]) );
-    data.set( "p-cid+1", ((cid + 1 >= len) ? NONE_POSTAG : inst->postags[cid +1]) );
-    data.set( "dir",     dir );
-    data.set( "dist",    dist );
-
-    int large = (hid > cid ? hid : cid);
-    int small = (hid < cid ? hid : cid);
-    data.set( "p-sid", inst->postags[small] );
-    data.set( "p-lid", inst->postags[large] );
-
-    int cnt;
-    cnt = inst->verb_cnt[large-1] - inst->verb_cnt[small]; cnt = (cnt > 3 ? 3 : cnt);
-    data.set( "verbcnt", to_str(cnt) );
-    cnt = inst->conj_cnt[large-1] - inst->conj_cnt[small]; cnt = (cnt > 3 ? 3 : cnt);
-    data.set( "conjcnt", to_str(cnt) );
-    cnt = inst->punc_cnt[large-1] - inst->punc_cnt[small]; cnt = (cnt > 3 ? 3 : cnt);
-    data.set( "punccnt", to_str(cnt) );
-
-    feat.reserve(1024);
-
-    int N = templates.size();
-    int NN = (feat_opt.use_dependency_between ? 
-            (feat_opt.use_distance_in_features ? N - 2 : N - 1) : N);
-
-    for (int i = (is_root ? 3 : 0); i < NN; ++ i) {
+  }
+
+  string dir, dist, feat;
+
+  __GET_DIRECTION(hid, cid, dir);
+  __GET_DISTANCE_1_2_36_7(hid, cid, dist);
+
+  Template::Data data;
+
+  bool is_root = (hid == 0);
+
+  data.set( "f-hid",   inst->forms[hid] );
+  data.set( "f-cid",   inst->forms[cid] );
+  data.set( "p-hid",   inst->postags[hid] );
+  data.set( "p-cid",   inst->postags[cid] );
+  data.set( "p-hid-1", ((hid <= 1) ? NONE_POSTAG : inst->postags[hid - 1]) );
+  data.set( "p-hid+1", ((is_root || hid+1 >= len) ? NONE_POSTAG : inst->postags[hid + 1]) );
+  data.set( "p-cid-1", ((cid <= 1) ? NONE_POSTAG : inst->postags[cid - 1]) );
+  data.set( "p-cid+1", ((cid + 1 >= len) ? NONE_POSTAG : inst->postags[cid +1]) );
+  data.set( "dir",   dir );
+  data.set( "dist",  dist );
+
+  int large = (hid > cid ? hid : cid);
+  int small = (hid < cid ? hid : cid);
+  data.set( "p-sid", inst->postags[small] );
+  data.set( "p-lid", inst->postags[large] );
+
+  int cnt;
+  cnt = inst->verb_cnt[large-1] - inst->verb_cnt[small]; cnt = (cnt > 3 ? 3 : cnt);
+  data.set( "verbcnt", to_str(cnt) );
+  cnt = inst->conj_cnt[large-1] - inst->conj_cnt[small]; cnt = (cnt > 3 ? 3 : cnt);
+  data.set( "conjcnt", to_str(cnt) );
+  cnt = inst->punc_cnt[large-1] - inst->punc_cnt[small]; cnt = (cnt > 3 ? 3 : cnt);
+  data.set( "punccnt", to_str(cnt) );
+
+  feat.reserve(1024);
+
+  int N = templates.size();
+  int NN = (feat_opt.use_dependency_between ? 
+      (feat_opt.use_distance_in_features ? N - 2 : N - 1) : N);
+
+  for (int i = (is_root ? 3 : 0); i < NN; ++ i) {
+    templates[i]->render(data, feat);
+    cache[i].push_back(feat);
+  }
+
+  StringMap<int> pos_seen;
+  for (int r = small + 1; r < large; ++ r) {
+    if ( pos_seen.get(inst->postags[r].c_str()) == NULL ) {
+      data.set( "p-bid", inst->postags[r] );
+      for (int i = NN; i < N; ++ i) {
         templates[i]->render(data, feat);
         cache[i].push_back(feat);
-    }
+      }
 
-    StringMap<int> pos_seen;
-    for (int r = small + 1; r < large; ++ r) {
-        if ( pos_seen.get(inst->postags[r].c_str()) == NULL ) {
-            data.set( "p-bid", inst->postags[r] );
-            for (int i = NN; i < N; ++ i) {
-                templates[i]->render(data, feat);
-                cache[i].push_back(feat);
-            }
-
-            pos_seen.set( inst->postags[r].c_str(), 1);
-        }
+      pos_seen.set( inst->postags[r].c_str(), 1);
     }
+  }
 
-    return 0;
+  return 0;
 }
 
 // ================================================================ //
-// Sibling Features Extractor                                       //
-//  feature templates is listed in `extractor.h`                    //
+// Sibling Features Extractor                     //
+//  feature templates is listed in `extractor.h`          //
 //  the SIBExtractor is a singleton, which only be construct once   //
-//  during the life of the program.                                 //
+//  during the life of the program.                 //
 // ================================================================ //
 
 // Initialize the static member, 
@@ -363,160 +363,160 @@ vector<Template *> SIBExtractor::templates;
 // the constructor function.
 // guarantee that it's a singleton.
 SIBExtractor * SIBExtractor::extractor() {
-    if (0 == instance_) {
-        instance_ = new SIBExtractor;
-    }
+  if (0 == instance_) {
+    instance_ = new SIBExtractor;
+  }
 
-    return instance_;
+  return instance_;
 }
 
 SIBExtractor::SIBExtractor() {
-    templates.reserve(100);
-
-    if (feat_opt.use_sibling_basic) {
-        templates.push_back(new Template("30={p-hid}-{p-sid}-{p-cid}-{dir}"));
-        templates.push_back(new Template("31?={f-hid}-{p-sid}-{p-cid}-{dir}"));
-        templates.push_back(new Template("32?={p-hid}-{f-sid}-{p-cid}-{dir}"));
-        templates.push_back(new Template("33?={p-hid}-{p-sid}-{f-cid}-{dir}"));
-        templates.push_back(new Template("32={p-cid}-{p-sid}-{dir}"));
-        templates.push_back(new Template("36={f-cid}-{f-sid}-{dir}"));
-        templates.push_back(new Template("37={f-cid}-{p-sid}-{dir}"));
-        templates.push_back(new Template("38={p-cid}-{f-sid}-{dir}"));
-    }
-
-    if (feat_opt.use_sibling_basic && feat_opt.use_distance_in_features) {
-        templates.push_back(new Template("30={p-hid}-{p-sid}-{p-cid}-{dir}-{dist}"));
-        templates.push_back(new Template("31?={f-hid}-{p-sid}-{p-cid}-{dir}-{dist}"));
-        templates.push_back(new Template("32?={p-hid}-{f-sid}-{p-cid}-{dir}-{dist}"));
-        templates.push_back(new Template("33?={p-hid}-{p-sid}-{f-cid}-{dir}-{dist}"));
-        templates.push_back(new Template("32={p-cid}-{p-sid}-{dir}-{dist}"));
-        templates.push_back(new Template("36={f-cid}-{f-sid}-{dir}-{dist}"));
-        templates.push_back(new Template("37={f-cid}-{p-sid}-{dir}-{dist}"));
-        templates.push_back(new Template("38={p-cid}-{f-sid}-{dir}-{dist}"));
-    }
-
-    if (feat_opt.use_sibling_basic && model_opt.labeled) {
-        templates.push_back(new Template("31={p-hid}-{p-sid}-{dir}"));
-        templates.push_back(new Template("33={f-hid}-{f-sid}-{dir}"));
-        templates.push_back(new Template("34={p-hid}-{f-sid}-{dir}"));
-        templates.push_back(new Template("35={f-hid}-{p-sid}-{dir}"));
-    }
-
-    // if (feat_opt.use_sibling_basic && model_opt.labeled && feat_opt.use_distance_in_features) {
-    if (feat_opt.use_sibling_basic) {
-        templates.push_back(new Template("31={p-hid}-{p-sid}-{dir}-{dist}"));
-        templates.push_back(new Template("33={f-hid}-{f-sid}-{dir}-{dist}"));
-        templates.push_back(new Template("34={p-hid}-{f-sid}-{dir}-{dist}"));
-        templates.push_back(new Template("35={f-hid}-{p-sid}-{dir}-{dist}"));
-    }
-
-    if (feat_opt.use_sibling_linear) {
-        templates.push_back(new Template("66={p-cid}-{p-sid}-{p-sid+1}-{dir}"));
-        templates.push_back(new Template("67={p-cid}-{p-sid-1}-{p-sid}-{dir}"));
-        templates.push_back(new Template("68={p-cid}-{p-cid+1}-{p-sid}-{dir}"));
-        templates.push_back(new Template("69={p-cid-1}-{p-cid}-{p-sid}-{dir}"));
-        templates.push_back(new Template("70={p-cid-1}-{p-cid}-{p-sid}-{p-sid+1}-{dir}"));
-        templates.push_back(new Template("71={p-cid-1}-{p-cid}-{p-sid-1}-{p-sid}-{dir}"));
-        templates.push_back(new Template("72={p-cid}-{p-cid+1}-{p-sid}-{p-sid+1}-{dir}"));
-        templates.push_back(new Template("73={p-cid}-{p-cid+1}-{p-sid-1}-{p-sid}-{dir}"));
-    }
-
-    /*if (feat_opt.use_sibling_linear && feat_opt.use_distance_in_features) {
-        templates.push_back(new Template("66={p-cid}-{p-sid}-{p-sid+1}-{dir}-{dist}"));
-        templates.push_back(new Template("67={p-cid}-{p-sid-1}-{p-sid}-{dir}-{dist}"));
-        templates.push_back(new Template("68={p-cid}-{p-cid+1}-{p-sid}-{dir}-{dist}"));
-        templates.push_back(new Template("69={p-cid-1}-{p-cid}-{p-sid}-{dir}-{dist}"));
-        templates.push_back(new Template("70={p-cid-1}-{p-cid}-{p-sid}-{p-sid+1}-{dir}-{dist}"));
-        templates.push_back(new Template("71={p-cid-1}-{p-cid}-{p-sid-1}-{p-sid}-{dir}-{dist}"));
-        templates.push_back(new Template("72={p-cid}-{p-cid+1}-{p-sid}-{p-sid+1}-{dir}-{dist}"));
-        templates.push_back(new Template("73={p-cid}-{p-cid+1}-{p-sid-1}-{p-sid}-{dir}-{dist}"));
-    }*/
-
-
-    if (feat_opt.use_sibling_linear && model_opt.labeled) {
-        templates.push_back(new Template("58={p-hid}-{p-sid}-{p-sid+1}-{dir}"));
-        templates.push_back(new Template("59={p-hid}-{p-sid-1}-{p-sid}-{dir}"));
-        templates.push_back(new Template("60={p-hid}-{p-hid+1}-{p-sid}-{dir}"));
-        templates.push_back(new Template("61={p-hid-1}-{p-hid}-{p-sid}-{dir}"));
-        templates.push_back(new Template("62={p-hid-1}-{p-hid}-{p-sid}-{p-sid+1}-{dir}"));
-        templates.push_back(new Template("63={p-hid-1}-{p-hid}-{p-sid-1}-{p-sid}-{dir}"));
-        templates.push_back(new Template("64={p-hid}-{p-hid+1}-{p-sid}-{p-sid+1}-{dir}"));
-        templates.push_back(new Template("65={p-hid}-{p-hid+1}-{p-sid-1}-{p-sid}-{dir}"));
-    }   //  end for use sibling linear
-
-    /*if (feat_opt.use_sibling_linear && model_opt.labeled && feat_opt.use_distance_in_features) {
-        templates.push_back(new Template("58={p-hid}-{p-sid}-{p-sid+1}-{dir}-{dist}"));
-        templates.push_back(new Template("59={p-hid}-{p-sid-1}-{p-sid}-{dir}-{dist}"));
-        templates.push_back(new Template("60={p-hid}-{p-hid+1}-{p-sid}-{dir}-{dist}"));
-        templates.push_back(new Template("61={p-hid-1}-{p-hid}-{p-sid}-{dir}-{dist}"));
-        templates.push_back(new Template("62={p-hid-1}-{p-hid}-{p-sid}-{p-sid+1}-{dir}-{dist}"));
-        templates.push_back(new Template("63={p-hid-1}-{p-hid}-{p-sid-1}-{p-sid}-{dir}-{dist}"));
-        templates.push_back(new Template("64={p-hid}-{p-hid+1}-{p-sid}-{p-sid+1}-{dir}-{dist}"));
-        templates.push_back(new Template("65={p-hid}-{p-hid+1}-{p-sid-1}-{p-sid}-{dir}-{dist}"));
-    }*/   //  end for use sibling linear
+  templates.reserve(100);
+
+  if (feat_opt.use_sibling_basic) {
+    templates.push_back(new Template("30={p-hid}-{p-sid}-{p-cid}-{dir}"));
+    templates.push_back(new Template("31?={f-hid}-{p-sid}-{p-cid}-{dir}"));
+    templates.push_back(new Template("32?={p-hid}-{f-sid}-{p-cid}-{dir}"));
+    templates.push_back(new Template("33?={p-hid}-{p-sid}-{f-cid}-{dir}"));
+    templates.push_back(new Template("32={p-cid}-{p-sid}-{dir}"));
+    templates.push_back(new Template("36={f-cid}-{f-sid}-{dir}"));
+    templates.push_back(new Template("37={f-cid}-{p-sid}-{dir}"));
+    templates.push_back(new Template("38={p-cid}-{f-sid}-{dir}"));
+  }
+
+  if (feat_opt.use_sibling_basic && feat_opt.use_distance_in_features) {
+    templates.push_back(new Template("30={p-hid}-{p-sid}-{p-cid}-{dir}-{dist}"));
+    templates.push_back(new Template("31?={f-hid}-{p-sid}-{p-cid}-{dir}-{dist}"));
+    templates.push_back(new Template("32?={p-hid}-{f-sid}-{p-cid}-{dir}-{dist}"));
+    templates.push_back(new Template("33?={p-hid}-{p-sid}-{f-cid}-{dir}-{dist}"));
+    templates.push_back(new Template("32={p-cid}-{p-sid}-{dir}-{dist}"));
+    templates.push_back(new Template("36={f-cid}-{f-sid}-{dir}-{dist}"));
+    templates.push_back(new Template("37={f-cid}-{p-sid}-{dir}-{dist}"));
+    templates.push_back(new Template("38={p-cid}-{f-sid}-{dir}-{dist}"));
+  }
+
+  if (feat_opt.use_sibling_basic && model_opt.labeled) {
+    templates.push_back(new Template("31={p-hid}-{p-sid}-{dir}"));
+    templates.push_back(new Template("33={f-hid}-{f-sid}-{dir}"));
+    templates.push_back(new Template("34={p-hid}-{f-sid}-{dir}"));
+    templates.push_back(new Template("35={f-hid}-{p-sid}-{dir}"));
+  }
+
+  // if (feat_opt.use_sibling_basic && model_opt.labeled && feat_opt.use_distance_in_features) {
+  if (feat_opt.use_sibling_basic) {
+    templates.push_back(new Template("31={p-hid}-{p-sid}-{dir}-{dist}"));
+    templates.push_back(new Template("33={f-hid}-{f-sid}-{dir}-{dist}"));
+    templates.push_back(new Template("34={p-hid}-{f-sid}-{dir}-{dist}"));
+    templates.push_back(new Template("35={f-hid}-{p-sid}-{dir}-{dist}"));
+  }
+
+  if (feat_opt.use_sibling_linear) {
+    templates.push_back(new Template("66={p-cid}-{p-sid}-{p-sid+1}-{dir}"));
+    templates.push_back(new Template("67={p-cid}-{p-sid-1}-{p-sid}-{dir}"));
+    templates.push_back(new Template("68={p-cid}-{p-cid+1}-{p-sid}-{dir}"));
+    templates.push_back(new Template("69={p-cid-1}-{p-cid}-{p-sid}-{dir}"));
+    templates.push_back(new Template("70={p-cid-1}-{p-cid}-{p-sid}-{p-sid+1}-{dir}"));
+    templates.push_back(new Template("71={p-cid-1}-{p-cid}-{p-sid-1}-{p-sid}-{dir}"));
+    templates.push_back(new Template("72={p-cid}-{p-cid+1}-{p-sid}-{p-sid+1}-{dir}"));
+    templates.push_back(new Template("73={p-cid}-{p-cid+1}-{p-sid-1}-{p-sid}-{dir}"));
+  }
+
+  /*if (feat_opt.use_sibling_linear && feat_opt.use_distance_in_features) {
+    templates.push_back(new Template("66={p-cid}-{p-sid}-{p-sid+1}-{dir}-{dist}"));
+    templates.push_back(new Template("67={p-cid}-{p-sid-1}-{p-sid}-{dir}-{dist}"));
+    templates.push_back(new Template("68={p-cid}-{p-cid+1}-{p-sid}-{dir}-{dist}"));
+    templates.push_back(new Template("69={p-cid-1}-{p-cid}-{p-sid}-{dir}-{dist}"));
+    templates.push_back(new Template("70={p-cid-1}-{p-cid}-{p-sid}-{p-sid+1}-{dir}-{dist}"));
+    templates.push_back(new Template("71={p-cid-1}-{p-cid}-{p-sid-1}-{p-sid}-{dir}-{dist}"));
+    templates.push_back(new Template("72={p-cid}-{p-cid+1}-{p-sid}-{p-sid+1}-{dir}-{dist}"));
+    templates.push_back(new Template("73={p-cid}-{p-cid+1}-{p-sid-1}-{p-sid}-{dir}-{dist}"));
+  }*/
+
+
+  if (feat_opt.use_sibling_linear && model_opt.labeled) {
+    templates.push_back(new Template("58={p-hid}-{p-sid}-{p-sid+1}-{dir}"));
+    templates.push_back(new Template("59={p-hid}-{p-sid-1}-{p-sid}-{dir}"));
+    templates.push_back(new Template("60={p-hid}-{p-hid+1}-{p-sid}-{dir}"));
+    templates.push_back(new Template("61={p-hid-1}-{p-hid}-{p-sid}-{dir}"));
+    templates.push_back(new Template("62={p-hid-1}-{p-hid}-{p-sid}-{p-sid+1}-{dir}"));
+    templates.push_back(new Template("63={p-hid-1}-{p-hid}-{p-sid-1}-{p-sid}-{dir}"));
+    templates.push_back(new Template("64={p-hid}-{p-hid+1}-{p-sid}-{p-sid+1}-{dir}"));
+    templates.push_back(new Template("65={p-hid}-{p-hid+1}-{p-sid-1}-{p-sid}-{dir}"));
+  }   //  end for use sibling linear
+
+  /*if (feat_opt.use_sibling_linear && model_opt.labeled && feat_opt.use_distance_in_features) {
+    templates.push_back(new Template("58={p-hid}-{p-sid}-{p-sid+1}-{dir}-{dist}"));
+    templates.push_back(new Template("59={p-hid}-{p-sid-1}-{p-sid}-{dir}-{dist}"));
+    templates.push_back(new Template("60={p-hid}-{p-hid+1}-{p-sid}-{dir}-{dist}"));
+    templates.push_back(new Template("61={p-hid-1}-{p-hid}-{p-sid}-{dir}-{dist}"));
+    templates.push_back(new Template("62={p-hid-1}-{p-hid}-{p-sid}-{p-sid+1}-{dir}-{dist}"));
+    templates.push_back(new Template("63={p-hid-1}-{p-hid}-{p-sid-1}-{p-sid}-{dir}-{dist}"));
+    templates.push_back(new Template("64={p-hid}-{p-hid+1}-{p-sid}-{p-sid+1}-{dir}-{dist}"));
+    templates.push_back(new Template("65={p-hid}-{p-hid+1}-{p-sid-1}-{p-sid}-{dir}-{dist}"));
+  }*/   //  end for use sibling linear
 }
 
 SIBExtractor::~SIBExtractor() {
-    for (int i = 0; i < templates.size(); ++ i) {
-        delete templates[i];
-    }
+  for (int i = 0; i < templates.size(); ++ i) {
+    delete templates[i];
+  }
 }
 
 int SIBExtractor::num_templates() {
-    if (0 == instance_) {
-        instance_ = new SIBExtractor;
-    }
+  if (0 == instance_) {
+    instance_ = new SIBExtractor;
+  }
 
-    return templates.size();
+  return templates.size();
 }
 
 int SIBExtractor::extract3o(Instance * inst, int hid, int cid, int sid, vector< StringVec > & cache) {
-    int len = inst->size();
-    bool first_child = (hid == sid);
-    bool last_child = (cid == sid);
+  int len = inst->size();
+  bool first_child = (hid == sid);
+  bool last_child = (cid == sid);
 
-    string dir, dist, feat;
+  string dir, dist, feat;
 
-    __GET_DIRECTION(hid, cid, dir);
-    __GET_DISTANCE_1_2_36_7(hid, cid, dist);
+  __GET_DIRECTION(hid, cid, dir);
+  __GET_DISTANCE_1_2_36_7(hid, cid, dist);
 
-    if (first_child) dir = "#" + dir;
-    else if (last_child) dir = dir + "#";
+  if (first_child) dir = "#" + dir;
+  else if (last_child) dir = dir + "#";
 
-    Template::Data data;
+  Template::Data data;
 
-    bool is_root = (hid == 0);
+  bool is_root = (hid == 0);
 
-    data.set( "f-hid",   inst->forms[hid] );
-    data.set( "f-sid",   ((first_child || last_child) ? NONE_FORM : inst->forms[sid]));
-    data.set( "f-cid",   inst->forms[cid] );
-    data.set( "p-hid",   inst->postags[hid] );
-    data.set( "p-sid",   ((first_child || last_child) ? NONE_POSTAG : inst->postags[sid]));
-    data.set( "p-cid",   inst->postags[cid] );
-    data.set( "p-hid-1", ((hid <= 1) ? NONE_POSTAG : inst->postags[hid - 1]) );
-    data.set( "p-hid+1", ((is_root || hid+1 >= len) ? NONE_POSTAG : inst->postags[hid + 1]) );
-    data.set( "p-cid-1", ((cid <= 1) ? NONE_POSTAG : inst->postags[cid - 1]) );
-    data.set( "p-cid+1", ((cid + 1 >= len) ? NONE_POSTAG : inst->postags[cid +1]) );
-    data.set( "p-sid-1", ((first_child || last_child || sid <= 1) ? NONE_POSTAG : inst->postags[sid-1]));
-    data.set( "p-sid+1", ((first_child || last_child || sid+1 >= len) ? NONE_POSTAG : inst->postags[sid+1]));
-    data.set( "dir",     dir );
-    data.set( "dist",    dist );
+  data.set( "f-hid",   inst->forms[hid] );
+  data.set( "f-sid",   ((first_child || last_child) ? NONE_FORM : inst->forms[sid]));
+  data.set( "f-cid",   inst->forms[cid] );
+  data.set( "p-hid",   inst->postags[hid] );
+  data.set( "p-sid",   ((first_child || last_child) ? NONE_POSTAG : inst->postags[sid]));
+  data.set( "p-cid",   inst->postags[cid] );
+  data.set( "p-hid-1", ((hid <= 1) ? NONE_POSTAG : inst->postags[hid - 1]) );
+  data.set( "p-hid+1", ((is_root || hid+1 >= len) ? NONE_POSTAG : inst->postags[hid + 1]) );
+  data.set( "p-cid-1", ((cid <= 1) ? NONE_POSTAG : inst->postags[cid - 1]) );
+  data.set( "p-cid+1", ((cid + 1 >= len) ? NONE_POSTAG : inst->postags[cid +1]) );
+  data.set( "p-sid-1", ((first_child || last_child || sid <= 1) ? NONE_POSTAG : inst->postags[sid-1]));
+  data.set( "p-sid+1", ((first_child || last_child || sid+1 >= len) ? NONE_POSTAG : inst->postags[sid+1]));
+  data.set( "dir",   dir );
+  data.set( "dist",  dist );
 
-    feat.reserve(1024);
+  feat.reserve(1024);
 
-    for (int i = 0; i < templates.size(); ++ i) {
-        templates[i]->render(data, feat);
-        cache[i].push_back(feat);
-    }
+  for (int i = 0; i < templates.size(); ++ i) {
+    templates[i]->render(data, feat);
+    cache[i].push_back(feat);
+  }
 
 	return 0;
 }
 
 // ================================================================ //
-// Grand Features Extractor                                         //
-//  feature templates is listed in `extractor.h`                    //
+// Grand Features Extractor                     //
+//  feature templates is listed in `extractor.h`          //
 //  the GRDExtractor is a singleton, which only be construct once   //
-//  during the life of the program.                                 //
+//  during the life of the program.                 //
 // ================================================================ //
 
 // Initialize the static member,
@@ -524,111 +524,111 @@ GRDExtractor * GRDExtractor::instance_ = 0;
 vector<Template *> GRDExtractor::templates;
 
 GRDExtractor * GRDExtractor::extractor() {
-    if (0 == instance_) {
-        instance_ = new GRDExtractor;
-    }
-    return instance_;
+  if (0 == instance_) {
+    instance_ = new GRDExtractor;
+  }
+  return instance_;
 }
 
 GRDExtractor::GRDExtractor() {
-    templates.reserve(100);
-
-    if (feat_opt.use_grand_basic) {
-        templates.push_back(new Template("21={p-hid}-{p-cid}-{p-gid}-{dir}-{gdir}"));
-        templates.push_back(new Template("21?={f-hid}-{p-cid}-{p-gid}-{dir}-{gdir}"));
-        templates.push_back(new Template("22?={p-hid}-{f-cid}-{p-gid}-{dir}-{gdir}"));
-        templates.push_back(new Template("23?={p-hid}-{p-cid}-{f-gid}-{dir}-{gdir}"));
-        templates.push_back(new Template("22={p-hid}-{p-gid}-{dir}-{gdir}"));
-        templates.push_back(new Template("23={p-cid}-{p-gid}-{dir}-{gdir}"));
-        templates.push_back(new Template("24={f-hid}-{f-gid}-{dir}-{gdir}"));
-        templates.push_back(new Template("25={f-cid}-{f-gid}-{dir}-{gdir}"));
-        templates.push_back(new Template("26={p-hid}-{f-gid}-{dir}-{gdir}"));
-        templates.push_back(new Template("27={p-cid}-{f-gid}-{dir}-{gdir}"));
-        templates.push_back(new Template("28={f-hid}-{p-gid}-{dir}-{gdir}"));
-        templates.push_back(new Template("29={f-cid}-{p-gid}-{dir}-{gdir}"));
-    }
-
-    if (feat_opt.use_grand_linear) {
-        templates.push_back(new Template("42={p-gid}-{p-gid+1}-{p-cid}-{dir}-{gdir}"));
-        templates.push_back(new Template("43={p-gid-1}-{p-gid}-{p-cid}-{dir}-{gdir}"));
-        templates.push_back(new Template("44={p-gid}-{p-cid}-{p-cid+1}-{dir}-{gdir}"));
-        templates.push_back(new Template("45={p-gid}-{p-cid-1}-{p-cid}-{dir}-{gdir}"));
-        templates.push_back(new Template("46={p-gid}-{p-gid+1}-{p-cid-1}-{p-cid}-{dir}-{gdir}"));
-        templates.push_back(new Template("47={p-gid-1}-{p-gid}-{p-cid-1}-{p-cid}-{dir}-{gdir}"));
-        templates.push_back(new Template("48={p-gid}-{p-gid+1}-{p-cid}-{p-cid+1}-{dir}-{gdir}"));
-        templates.push_back(new Template("49={p-gid-1}-{p-gid}-{p-cid}-{p-cid+1}-{dir}-{gdir}"));
-        templates.push_back(new Template("50={p-gid}-{p-gid+1}-{p-hid}-{dir}-{gdir}"));
-        templates.push_back(new Template("51={p-gid-1}-{p-gid}-{p-hid}-{dir}-{gdir}"));
-        templates.push_back(new Template("52={p-gid}-{p-hid}-{p-hid+1}-{dir}-{gdir}"));
-        templates.push_back(new Template("53={p-gid}-{p-hid-1}-{p-hid}-{dir}-{gdir}"));
-        templates.push_back(new Template("54={p-gid}-{p-gid+1}-{p-hid-1}-{p-hid}-{dir}-{gdir}"));
-        templates.push_back(new Template("55={p-gid-1}-{p-gid}-{p-hid-1}-{p-hid}-{dir}-{gdir}"));
-        templates.push_back(new Template("56={p-gid}-{p-gid+1}-{p-hid}-{p-hid+1}-{dir}-{gdir}"));
-        templates.push_back(new Template("57={p-gid-1}-{p-gid}-{p-hid}-{p-hid+1}-{dir}-{gdir}"));
-    }
+  templates.reserve(100);
+
+  if (feat_opt.use_grand_basic) {
+    templates.push_back(new Template("21={p-hid}-{p-cid}-{p-gid}-{dir}-{gdir}"));
+    templates.push_back(new Template("21?={f-hid}-{p-cid}-{p-gid}-{dir}-{gdir}"));
+    templates.push_back(new Template("22?={p-hid}-{f-cid}-{p-gid}-{dir}-{gdir}"));
+    templates.push_back(new Template("23?={p-hid}-{p-cid}-{f-gid}-{dir}-{gdir}"));
+    templates.push_back(new Template("22={p-hid}-{p-gid}-{dir}-{gdir}"));
+    templates.push_back(new Template("23={p-cid}-{p-gid}-{dir}-{gdir}"));
+    templates.push_back(new Template("24={f-hid}-{f-gid}-{dir}-{gdir}"));
+    templates.push_back(new Template("25={f-cid}-{f-gid}-{dir}-{gdir}"));
+    templates.push_back(new Template("26={p-hid}-{f-gid}-{dir}-{gdir}"));
+    templates.push_back(new Template("27={p-cid}-{f-gid}-{dir}-{gdir}"));
+    templates.push_back(new Template("28={f-hid}-{p-gid}-{dir}-{gdir}"));
+    templates.push_back(new Template("29={f-cid}-{p-gid}-{dir}-{gdir}"));
+  }
+
+  if (feat_opt.use_grand_linear) {
+    templates.push_back(new Template("42={p-gid}-{p-gid+1}-{p-cid}-{dir}-{gdir}"));
+    templates.push_back(new Template("43={p-gid-1}-{p-gid}-{p-cid}-{dir}-{gdir}"));
+    templates.push_back(new Template("44={p-gid}-{p-cid}-{p-cid+1}-{dir}-{gdir}"));
+    templates.push_back(new Template("45={p-gid}-{p-cid-1}-{p-cid}-{dir}-{gdir}"));
+    templates.push_back(new Template("46={p-gid}-{p-gid+1}-{p-cid-1}-{p-cid}-{dir}-{gdir}"));
+    templates.push_back(new Template("47={p-gid-1}-{p-gid}-{p-cid-1}-{p-cid}-{dir}-{gdir}"));
+    templates.push_back(new Template("48={p-gid}-{p-gid+1}-{p-cid}-{p-cid+1}-{dir}-{gdir}"));
+    templates.push_back(new Template("49={p-gid-1}-{p-gid}-{p-cid}-{p-cid+1}-{dir}-{gdir}"));
+    templates.push_back(new Template("50={p-gid}-{p-gid+1}-{p-hid}-{dir}-{gdir}"));
+    templates.push_back(new Template("51={p-gid-1}-{p-gid}-{p-hid}-{dir}-{gdir}"));
+    templates.push_back(new Template("52={p-gid}-{p-hid}-{p-hid+1}-{dir}-{gdir}"));
+    templates.push_back(new Template("53={p-gid}-{p-hid-1}-{p-hid}-{dir}-{gdir}"));
+    templates.push_back(new Template("54={p-gid}-{p-gid+1}-{p-hid-1}-{p-hid}-{dir}-{gdir}"));
+    templates.push_back(new Template("55={p-gid-1}-{p-gid}-{p-hid-1}-{p-hid}-{dir}-{gdir}"));
+    templates.push_back(new Template("56={p-gid}-{p-gid+1}-{p-hid}-{p-hid+1}-{dir}-{gdir}"));
+    templates.push_back(new Template("57={p-gid-1}-{p-gid}-{p-hid}-{p-hid+1}-{dir}-{gdir}"));
+  }
 }
 
 GRDExtractor::~GRDExtractor() {
-    for (int i = 0; i < templates.size(); ++ i) {
-        delete templates[i];
-    }
+  for (int i = 0; i < templates.size(); ++ i) {
+    delete templates[i];
+  }
 }
 
 int GRDExtractor::num_templates() {
-    if (0 == instance_) {
-        instance_ = new GRDExtractor;
-    }
+  if (0 == instance_) {
+    instance_ = new GRDExtractor;
+  }
 
-    return templates.size();
+  return templates.size();
 }
 
 
 int GRDExtractor::extract3o(Instance * inst, int hid, int cid, int gid, vector< StringVec > & cache) {
-    int len = inst->size();
-
-    bool no_grand = (hid == gid || cid == gid);
-    bool no_grandr = (cid == gid);
-
-    string dir, gdir, feat;
-
-    __GET_DIRECTION(hid, cid, dir);
-
-    if (no_grand) {
-        gdir = (cid == gid ? "#R" : "#L");
-    } else {
-        __GET_DIRECTION(cid, gid, gdir);
-    }
-
-    Template::Data data;
-    bool is_root = (hid == 0);
-
-    data.set( "f-hid",   inst->forms[hid] );
-    data.set( "f-gid",   (no_grand ? NONE_FORM : inst->forms[gid]));
-    data.set( "f-cid",   inst->forms[cid] );
-    data.set( "p-hid",   inst->postags[hid] );
-    data.set( "p-gid",   (no_grand ? NONE_POSTAG : inst->postags[gid]));
-    data.set( "p-cid",   inst->postags[cid] );
-    data.set( "p-hid-1", ((hid <= 1) ? NONE_POSTAG : inst->postags[hid - 1]) );
-    data.set( "p-hid+1", ((is_root || hid+1 >= len) ? NONE_POSTAG : inst->postags[hid + 1]) );
-    data.set( "p-cid-1", ((cid <= 1) ? NONE_POSTAG : inst->postags[cid - 1]) );
-    data.set( "p-cid+1", ((cid + 1 >= len) ? NONE_POSTAG : inst->postags[cid +1]) );
-    data.set( "p-gid-1", ((no_grand || gid <= 1) ? NONE_POSTAG : inst->postags[gid-1]));
-    data.set( "p-gid+1", ((no_grand || gid+1 >= len) ? NONE_POSTAG : inst->postags[gid+1]));
-    data.set( "dir",     dir );
-    data.set( "gdir",    gdir );
-
-    feat.reserve(1024);
-
-    for (int i = 0; i < templates.size(); ++ i) {
-        templates[i]->render(data, feat);
-        cache[i].push_back(feat);
-    }
-
-	return 0;
+  int len = inst->size();
+
+  bool no_grand = (hid == gid || cid == gid);
+  // bool no_grandr = (cid == gid);
+
+  string dir, gdir, feat;
+
+  __GET_DIRECTION(hid, cid, dir);
+
+  if (no_grand) {
+    gdir = (cid == gid ? "#R" : "#L");
+  } else {
+    __GET_DIRECTION(cid, gid, gdir);
+  }
+
+  Template::Data data;
+  bool is_root = (hid == 0);
+
+  data.set( "f-hid",   inst->forms[hid] );
+  data.set( "f-gid",   (no_grand ? NONE_FORM : inst->forms[gid]));
+  data.set( "f-cid",   inst->forms[cid] );
+  data.set( "p-hid",   inst->postags[hid] );
+  data.set( "p-gid",   (no_grand ? NONE_POSTAG : inst->postags[gid]));
+  data.set( "p-cid",   inst->postags[cid] );
+  data.set( "p-hid-1", ((hid <= 1) ? NONE_POSTAG : inst->postags[hid - 1]) );
+  data.set( "p-hid+1", ((is_root || hid+1 >= len) ? NONE_POSTAG : inst->postags[hid + 1]) );
+  data.set( "p-cid-1", ((cid <= 1) ? NONE_POSTAG : inst->postags[cid - 1]) );
+  data.set( "p-cid+1", ((cid + 1 >= len) ? NONE_POSTAG : inst->postags[cid +1]) );
+  data.set( "p-gid-1", ((no_grand || gid <= 1) ? NONE_POSTAG : inst->postags[gid-1]));
+  data.set( "p-gid+1", ((no_grand || gid+1 >= len) ? NONE_POSTAG : inst->postags[gid+1]));
+  data.set( "dir",   dir );
+  data.set( "gdir",  gdir );
+
+  feat.reserve(1024);
+
+  for (int i = 0; i < templates.size(); ++ i) {
+    templates[i]->render(data, feat);
+    cache[i].push_back(feat);
+  }
+
+  return 0;
 }
 
-}       //  end for namespace parser
-}       //  end for namespace ltp
+}     //  end for namespace parser
+}     //  end for namespace ltp
 
 #undef  LEN
 #undef  LAST
diff --git a/src/parser/extractor.h b/src/parser/extractor.h
index cc93af0b7..b5b96b440 100644
--- a/src/parser/extractor.h
+++ b/src/parser/extractor.h
@@ -1,5 +1,5 @@
-#ifndef __EXTRACTOR_H__
-#define __EXTRACTOR_H__
+#ifndef __LTP_PARSER_EXTRACTOR_H__
+#define __LTP_PARSER_EXTRACTOR_H__
 
 #include <iostream>
 #include <sstream>
@@ -52,8 +52,15 @@ class Extractor {
 class POSUExtractor : public Extractor {
 public:
     static int extract1o(Instance * inst, int hid, vector<string> & cache);
-    static int extract2o(Instance * inst, int hid, int cid, vector<string> & cache);
-    static int extract3o(Instance * inst, int hid, int cid, int sid, vector<string> & cache);
+    static int extract2o(Instance * inst,
+                         int hid,
+                         int cid,
+                         vector<string> & cache);
+    static int extract3o(Instance * inst,
+                         int hid,
+                         int cid,
+                         int sid,
+                         vector<string> & cache);
 private:
     static const string prefix;
 };  //  end for class PosUnigramExtractor
@@ -164,9 +171,18 @@ class SIBExtractor : public Extractor {
 public:
     static SIBExtractor * extractor();
     static int num_templates();
-    static int extract1o(Instance * inst, int hid, vector<string> & cache);
-    static int extract2o(Instance * inst, int hid, int cid, vector<string> & cache);
-    static int extract3o(Instance * inst, int hid, int cid, int sid, vector< StringVec > & cache);
+    static int extract1o(Instance * inst,
+                         int hid,
+                         vector<string> & cache);
+    static int extract2o(Instance * inst,
+                         int hid,
+                         int cid,
+                         vector<string> & cache);
+    static int extract3o(Instance * inst,
+                         int hid,
+                         int cid,
+                         int sid,
+                         vector< StringVec > & cache);
 protected:
     SIBExtractor();
     ~SIBExtractor();
@@ -217,7 +233,11 @@ class GRDExtractor : public Extractor {
 public:
     static GRDExtractor * extractor();
     static int num_templates();
-    static int extract3o(Instance * inst, int hid, int cid, int gid, vector< StringVec > & cache);
+    static int extract3o(Instance * inst,
+                         int hid,
+                         int cid,
+                         int gid,
+                         vector< StringVec > & cache);
 protected:
     GRDExtractor();
     ~GRDExtractor();
@@ -230,4 +250,4 @@ class GRDExtractor : public Extractor {
 }   //  end for namespace parser
 }   //  end for namespace ltp
 
-#endif  //  end for ifndef __EXTRACTOR_H__
+#endif  //  end for ifndef __LTP_PARSER_EXTRACTOR_H__
diff --git a/src/parser/featurespace.cpp b/src/parser/featurespace.cpp
index c189e4952..1dbd07d43 100644
--- a/src/parser/featurespace.cpp
+++ b/src/parser/featurespace.cpp
@@ -12,273 +12,275 @@ namespace parser {
 using namespace ltp::utility;
 
 int FeatureSpace::retrieve(int gid, int tid, const char * key, bool create) {
-    // no boundary check, which is very dangerous
-    return groups[gid]->retrieve(tid, key, create);
+  // no boundary check, which is very dangerous
+  return groups[gid]->retrieve(tid, key, create);
 }
 
 int FeatureSpace::index(int gid, int tid, const char * key, int lid) {
-    // no boundary check, which is very dangerous
-    int bid = groups[gid]->retrieve(tid, key, false);
-    if (bid < 0) return -1;
+  // no boundary check, which is very dangerous
+  int bid = groups[gid]->retrieve(tid, key, false);
+  if (bid < 0) return -1;
 
-    return bid * _num_deprels + lid + offsets[gid];
+  return bid * _num_deprels + lid + offsets[gid];
 }
 
 void FeatureSpace::build_feature_space_truncate(int num_deprels) {
-    _num_deprels = num_deprels;
-    allocate_dictionary_groups();
+  _num_deprels = num_deprels;
+  allocate_dictionary_groups();
 }
 
 void FeatureSpace::set_offset_truncate() {
-    _offset=0;
-    _num_features=0;
-    offsets[DEP]=_offset;
-    if(feat_opt.use_dependency) {
-        _num_features += groups[DEP]->dim();
-        _offset += groups[DEP]->dim() * _num_deprels;
-    }
-
-    offsets[SIB]=_offset;
-    if(feat_opt.use_sibling) {
-        _num_features += groups[SIB]->dim();
-        _offset += groups[SIB]->dim() * _num_deprels;
-    }
-
-    offsets[GRD]=_offset;
-    if(feat_opt.use_grand) {
-        _num_features += groups[GRD]->dim();
-        _offset += groups[GRD]->dim() * _num_deprels;
-    }
+  _offset=0;
+  _num_features=0;
+  offsets[DEP]=_offset;
+  if(feat_opt.use_dependency) {
+    _num_features += groups[DEP]->dim();
+    _offset += groups[DEP]->dim() * _num_deprels;
+  }
+
+  offsets[SIB]=_offset;
+  if(feat_opt.use_sibling) {
+    _num_features += groups[SIB]->dim();
+    _offset += groups[SIB]->dim() * _num_deprels;
+  }
+
+  offsets[GRD]=_offset;
+  if(feat_opt.use_grand) {
+    _num_features += groups[GRD]->dim();
+    _offset += groups[GRD]->dim() * _num_deprels;
+  }
 }
 
-int FeatureSpace::build_feature_space(int num_deprels, 
-        const std::vector<Instance *> & instances) {
-    _num_deprels = num_deprels;
-    // allocate dictionary groups according to the options
-    allocate_dictionary_groups();
-
-    // loop over the training instances and extract gold features.
-    for (int i = 0; i < instances.size(); ++ i) {
-        Instance * inst = instances[i];
-
-        int len = inst->size();
-
-        if (feat_opt.use_dependency) {
-            int N = DEPExtractor::num_templates();
-
-            for (treeutils::DEPIterator itx(inst->heads); !itx.end(); ++ itx) {
-                int hid = itx.hid();
-                int cid = itx.cid();
-
-                std::vector< StringVec > cache;
-                cache.resize( N );
-
-                DEPExtractor::extractor()->extract2o(inst, hid, cid, cache);
-                for (int k = 0; k < cache.size(); ++ k) {
-                    for (int itx = 0; itx < cache[k].size(); ++ itx) {
-                        retrieve(DEP, k, cache[k][itx], true);
-                    }
-                }
-            }
-        }   //  end for if feat_opt.use_dependency
-
-        if (feat_opt.use_sibling) {
-            int N = SIBExtractor::num_templates();
-
-            for (treeutils::SIBIterator itx(inst->heads, feat_opt.use_last_sibling); !itx.end(); ++ itx) {
-                int hid = itx.hid();
-                int cid = itx.cid();
-                int sid = itx.sid();
-
-                std::vector< StringVec > cache;
-                cache.resize(N);
-                SIBExtractor::extract3o(inst, hid, cid, sid, cache);
-
-                for (int k = 0; k < cache.size(); ++ k) {
-                    for (int itx = 0; itx < cache[k].size(); ++ itx) {
-                        retrieve(SIB, k, cache[k][itx], true);
-                    }
-                }
-            }
-        }   //  end for if feat_opt.use_sibling
-
-        if (feat_opt.use_grand) {
-            int N = GRDExtractor::num_templates();
-
-            for (treeutils::GRDIterator itx(inst->heads, feat_opt.use_no_grand); !itx.end(); ++ itx) {
-                int hid = itx.hid();
-                int cid = itx.cid();
-                int gid = itx.gid();
-
-                std::vector< StringVec > cache;
-                cache.resize(N);
-                GRDExtractor::extract3o(inst, hid, cid, gid, cache);
-
-                for (int k = 0; k < cache.size(); ++ k) {
-                    for (int itx = 0; itx < cache[k].size(); ++ itx) {
-                        retrieve(GRD, k, cache[k][itx], true);
-                    }
-                }
-            }
-        }   //  end for feat_opt.use_grand
-
-        if ((i+1) % model_opt.display_interval== 0) {
-            TRACE_LOG("In building feature space, [%d] instances scanned.", i+1);
-        }
-    }
+int FeatureSpace::build_feature_space(int num_deprels,
+    const std::vector<Instance *> & instances) {
+  _num_deprels = num_deprels;
+  // allocate dictionary groups according to the options
+  allocate_dictionary_groups();
 
-    _offset = 0;
-    _num_features = 0;
+  // loop over the training instances and extract gold features.
+  for (int i = 0; i < instances.size(); ++ i) {
+    Instance * inst = instances[i];
 
-    offsets[DEP] = _offset;
     if (feat_opt.use_dependency) {
-        _num_features += groups[DEP]->dim();
-        _offset += groups[DEP]->dim() * _num_deprels;
-    }
-
-    offsets[SIB] = _offset;
-    if (feat_opt.use_sibling) {
-        _num_features += groups[SIB]->dim();
-        _offset += groups[SIB]->dim() * _num_deprels;
-    }
-
-    offsets[GRD] = _offset;
-    if (feat_opt.use_grand) {
-        _num_features += groups[GRD]->dim();
-        _offset += groups[GRD]->dim() * _num_deprels;
-    }
+      int N = DEPExtractor::num_templates();
 
-    /*offsets[GRDSIB] = offset;
-    if (feat_opt.use_grandsibling) {
-        offset += groups[GRDSIB]->dim() * _num_deprels;
-    }*/
+      for (treeutils::DEPIterator itx(inst->heads); !itx.end(); ++ itx) {
+        int hid = itx.hid();
+        int cid = itx.cid();
 
-    return _offset;
-}
+        std::vector< StringVec > cache;
+        cache.resize( N );
 
-int FeatureSpace::allocate_dictionary_groups() {
-    int ret = 0;
-    if (feat_opt.use_dependency) {
-        groups[DEP] = new DictionaryCollections( DEPExtractor::num_templates() );
-        ++ ret;
-    }
+        DEPExtractor::extractor()->extract2o(inst, hid, cid, cache);
+        for (int k = 0; k < cache.size(); ++ k) {
+          for (int itx = 0; itx < cache[k].size(); ++ itx) {
+            retrieve(DEP, k, cache[k][itx], true);
+          }
+        }
+      }
+    }   //  end for if feat_opt.use_dependency
 
     if (feat_opt.use_sibling) {
-        groups[SIB] = new DictionaryCollections( SIBExtractor::num_templates() );
-        ++ ret;
-    }
+      int N = SIBExtractor::num_templates();
+
+      for (treeutils::SIBIterator itx(inst->heads, feat_opt.use_last_sibling);
+           !itx.end();
+           ++ itx) {
+        int hid = itx.hid();
+        int cid = itx.cid();
+        int sid = itx.sid();
+
+        std::vector< StringVec > cache;
+        cache.resize(N);
+        SIBExtractor::extract3o(inst, hid, cid, sid, cache);
+
+        for (int k = 0; k < cache.size(); ++ k) {
+          for (int itx = 0; itx < cache[k].size(); ++ itx) {
+            retrieve(SIB, k, cache[k][itx], true);
+          }
+        }
+      }
+    }   //  end for if feat_opt.use_sibling
 
     if (feat_opt.use_grand) {
-        groups[GRD] = new DictionaryCollections( GRDExtractor::num_templates() );
-        ++ ret;
-    }
-
-    /*if (feat_opt.use_grand_sibling) {
-        groups[GRDSIB] = new DictionaryGroup( GRDSIBExtractor::num_template() );
-        ++ ret;
-    }
+      int N = GRDExtractor::num_templates();
+
+      for (treeutils::GRDIterator itx(inst->heads, feat_opt.use_no_grand);
+           !itx.end();
+           ++ itx) {
+        int hid = itx.hid();
+        int cid = itx.cid();
+        int gid = itx.gid();
+
+        std::vector< StringVec > cache;
+        cache.resize(N);
+        GRDExtractor::extract3o(inst, hid, cid, gid, cache);
+
+        for (int k = 0; k < cache.size(); ++ k) {
+          for (int itx = 0; itx < cache[k].size(); ++ itx) {
+            retrieve(GRD, k, cache[k][itx], true);
+          }
+        }
+      }
+    }   //  end for feat_opt.use_grand
 
-    if (feat_opt.use_postag_unigram) {
-        groups[POSU] = new DictionaryGroup( POSUExtractor::num_template() );
-        ++ ret;
+    if ((i+1) % model_opt.display_interval== 0) {
+      TRACE_LOG("In building feature space, [%d] instances scanned.", i+1);
     }
+  }
+
+  _offset = 0;
+  _num_features = 0;
+
+  offsets[DEP] = _offset;
+  if (feat_opt.use_dependency) {
+    _num_features += groups[DEP]->dim();
+    _offset += groups[DEP]->dim() * _num_deprels;
+  }
+
+  offsets[SIB] = _offset;
+  if (feat_opt.use_sibling) {
+    _num_features += groups[SIB]->dim();
+    _offset += groups[SIB]->dim() * _num_deprels;
+  }
+
+  offsets[GRD] = _offset;
+  if (feat_opt.use_grand) {
+    _num_features += groups[GRD]->dim();
+    _offset += groups[GRD]->dim() * _num_deprels;
+  }
+
+  /*offsets[GRDSIB] = offset;
+  if (feat_opt.use_grandsibling) {
+    offset += groups[GRDSIB]->dim() * _num_deprels;
+  }*/
+
+  return _offset;
+}
 
-    if (feat_opt.use_postag_bigram) {
-        groups[POSB] = new DictionaryGroup( POSBExtractor::num_template() );
-        ++ ret;
-    }*/
-
-    return ret;
+int FeatureSpace::allocate_dictionary_groups() {
+  int ret = 0;
+  if (feat_opt.use_dependency) {
+    groups[DEP] = new DictionaryCollections( DEPExtractor::num_templates() );
+    ++ ret;
+  }
+
+  if (feat_opt.use_sibling) {
+    groups[SIB] = new DictionaryCollections( SIBExtractor::num_templates() );
+    ++ ret;
+  }
+
+  if (feat_opt.use_grand) {
+    groups[GRD] = new DictionaryCollections( GRDExtractor::num_templates() );
+    ++ ret;
+  }
+
+  /*if (feat_opt.use_grand_sibling) {
+    groups[GRDSIB] = new DictionaryGroup( GRDSIBExtractor::num_template() );
+    ++ ret;
+  }
+
+  if (feat_opt.use_postag_unigram) {
+    groups[POSU] = new DictionaryGroup( POSUExtractor::num_template() );
+    ++ ret;
+  }
+
+  if (feat_opt.use_postag_bigram) {
+    groups[POSB] = new DictionaryGroup( POSBExtractor::num_template() );
+    ++ ret;
+  }*/
+
+  return ret;
 }
 
 int FeatureSpace::num_features() {
-    return _num_features;
+  return _num_features;
 }
 
 int FeatureSpace::dim() {
-    return _offset;
+  return _offset;
 }
 
 void FeatureSpace::save(std::ostream & out) {
-    if (feat_opt.use_dependency) {
-        groups[DEP]->dump(out);
-    }
+  if (feat_opt.use_dependency) {
+    groups[DEP]->dump(out);
+  }
 
-    if (feat_opt.use_sibling) {
-        groups[SIB]->dump(out);
-    }
+  if (feat_opt.use_sibling) {
+    groups[SIB]->dump(out);
+  }
 
-    if (feat_opt.use_grand) {
-        groups[GRD]->dump(out);
-    }
+  if (feat_opt.use_grand) {
+    groups[GRD]->dump(out);
+  }
 
-    /*if (feat_opt.use_grand_sibling) {
-        groups[GRDSIB]->dump(out);
-    }
+  /*if (feat_opt.use_grand_sibling) {
+    groups[GRDSIB]->dump(out);
+  }
 
-    if (feat_opt.use_postag_unigram) {
-        groups[POSU]->dump(out);
-    }
+  if (feat_opt.use_postag_unigram) {
+    groups[POSU]->dump(out);
+  }
 
-    if (feat_opt.use_postag_bigram) {
-        groups[POSB]->dump(out);
-    }*/
+  if (feat_opt.use_postag_bigram) {
+    groups[POSB]->dump(out);
+  }*/
 }
 
 bool FeatureSpace::load(int num_deprels, std::istream & in) {
 
-    _num_deprels = num_deprels;
-    _offset = 0;
-    _num_features = 0;
+  _num_deprels = num_deprels;
+  _offset = 0;
+  _num_features = 0;
 
-    offsets[DEP] = _offset;
-    if (feat_opt.use_dependency) {
-        groups[DEP] = new DictionaryCollections( DEPExtractor::num_templates() );
-        if (!groups[DEP]->load(in)) {
-            return false;
-        }
-
-        _num_features += groups[DEP]->dim();
-        _offset += groups[DEP]->dim() * _num_deprels;
+  offsets[DEP] = _offset;
+  if (feat_opt.use_dependency) {
+    groups[DEP] = new DictionaryCollections( DEPExtractor::num_templates() );
+    if (!groups[DEP]->load(in)) {
+      return false;
     }
 
-    offsets[SIB] = _offset;
-    if (feat_opt.use_sibling) {
-        groups[SIB] = new DictionaryCollections( SIBExtractor::num_templates() );
-        if (!groups[SIB]->load(in)) {
-            return false;
-        }
-
-        _num_features += groups[SIB]->dim();
-        _offset += groups[SIB]->dim() * _num_deprels;
-    }
+    _num_features += groups[DEP]->dim();
+    _offset += groups[DEP]->dim() * _num_deprels;
+  }
 
-    offsets[GRD] = _offset;
-    if (feat_opt.use_grand) {
-        groups[GRD] = new DictionaryCollections( GRDExtractor::num_templates() );
-        if (!groups[GRD]->load(in)) {
-            return false;
-        }
-        _num_features += groups[GRD]->dim();
-        _offset += groups[GRD]->dim() * _num_deprels;
+  offsets[SIB] = _offset;
+  if (feat_opt.use_sibling) {
+    groups[SIB] = new DictionaryCollections( SIBExtractor::num_templates() );
+    if (!groups[SIB]->load(in)) {
+      return false;
     }
 
-    /*if (feat_opt.use_grand_sibling) {
-        groups[GRDSIB] = new DictionaryGroup( GRDSIBExtractor::num_template() );
-        ++ ret;
-    }
+    _num_features += groups[SIB]->dim();
+    _offset += groups[SIB]->dim() * _num_deprels;
+  }
 
-    if (feat_opt.use_postag_unigram) {
-        groups[POSU] = new DictionaryGroup( POSUExtractor::num_template() );
-        ++ ret;
+  offsets[GRD] = _offset;
+  if (feat_opt.use_grand) {
+    groups[GRD] = new DictionaryCollections( GRDExtractor::num_templates() );
+    if (!groups[GRD]->load(in)) {
+      return false;
     }
-
-    if (feat_opt.use_postag_bigram) {
-        groups[POSB] = new DictionaryGroup( POSBExtractor::num_template() );
-        ++ ret;
-    }*/
-
-    return true;
+    _num_features += groups[GRD]->dim();
+    _offset += groups[GRD]->dim() * _num_deprels;
+  }
+
+  /*if (feat_opt.use_grand_sibling) {
+    groups[GRDSIB] = new DictionaryGroup( GRDSIBExtractor::num_template() );
+    ++ ret;
+  }
+
+  if (feat_opt.use_postag_unigram) {
+    groups[POSU] = new DictionaryGroup( POSUExtractor::num_template() );
+    ++ ret;
+  }
+
+  if (feat_opt.use_postag_bigram) {
+    groups[POSB] = new DictionaryGroup( POSBExtractor::num_template() );
+    ++ ret;
+  }*/
+
+  return true;
 
 }
 
diff --git a/src/parser/featurespace.h b/src/parser/featurespace.h
index 8041c68c3..990db5511 100644
--- a/src/parser/featurespace.h
+++ b/src/parser/featurespace.h
@@ -1,5 +1,5 @@
-#ifndef __FEATURE_SPACE_H__
-#define __FEATURE_SPACE_H__
+#ifndef __LTP_PARSER_FEATURE_SPACE_H__
+#define __LTP_PARSER_FEATURE_SPACE_H__
 
 #include <iostream>
 #include <vector>
@@ -12,80 +12,80 @@ namespace ltp {
 namespace parser {
 class FeatureSpaceIterator {
 public:
-    FeatureSpaceIterator():
-        _dicts(NULL),
-        _i(0),
-        _state(0){
+  FeatureSpaceIterator()
+    : _dicts(NULL),
+      _i(0),
+      _state(0){
+  }
+
+  FeatureSpaceIterator(DictionaryCollections *dicts)
+    : _dicts(dicts),
+      _i(0),
+      _state(0) {
+    ++(*this);
+  }
+
+  ~FeatureSpaceIterator(){
+  }
+
+  const char * key() { return _j.key(); }
+  int id() { return (*_j.value()); }
+  int tid() { return _i; }
+
+  bool end() {
+    int x = _dicts->size();
+    if((x) == _i) {
+      return true;
     }
-
-    FeatureSpaceIterator(DictionaryCollections *dicts):
-        _dicts(dicts),
-        _i(0),
-        _state(0) {
-        ++(*this);
-    }
-
-    ~FeatureSpaceIterator(){
-    }
-
-    const char * key() { return _j.key(); }
-    int id() { return (*_j.value()); }
-    int tid() { return _i; }
-
-    bool end() { 
-        int x = _dicts->size();
-        if((x) == _i) {
-            return true; 
-        }
-        return false;
-    }
-
-    FeatureSpaceIterator & operator =(const FeatureSpaceIterator & other) {
-        _dicts  = other._dicts;
-        _i      = other._i;
-        _state  = other._state;
-
-        return *this;
-    }
-
-    void operator ++() {
-        switch (_state) {
-            case 0:
-                for (_i = 0; ; ++_i) {
-                    if(NULL == _dicts->getDictionary(_i)) {
-                        return;
-                    }
-
-                    if (_dicts->getDictionary(_i)->database.begin() == 
-                            _dicts->getDictionary(_i)->database.end()) {
-                        _state = 1;
-                        return;
-                    }
-
-                    for (_j = _dicts->getDictionary(_i)->database.begin();
-                            _j != _dicts->getDictionary(_i)->database.end(); 
-                            ++_j) {
-                        _state = 1;
-                        return;
-            case 1:;
-                    }
-                }
+    return false;
+  }
+
+  FeatureSpaceIterator & operator =(const FeatureSpaceIterator & other) {
+    _dicts  = other._dicts;
+    _i    = other._i;
+    _state  = other._state;
+
+    return *this;
+  }
+
+  void operator ++() {
+    switch (_state) {
+      case 0:
+        for (_i = 0; ; ++_i) {
+          if(NULL == _dicts->getDictionary(_i)) {
+            return;
+          }
+
+          if (_dicts->getDictionary(_i)->database.begin() ==
+              _dicts->getDictionary(_i)->database.end()) {
+            _state = 1;
+            return;
+          }
+
+          for (_j = _dicts->getDictionary(_i)->database.begin();
+              _j != _dicts->getDictionary(_i)->database.end();
+              ++_j) {
+            _state = 1;
+            return;
+      case 1:;
+          }
         }
     }
+  }
 
-    int getI() {
-        return _i;
-    }
+  int getI() {
+    return _i;
+  }
 
-    DictionaryCollections * getDicts() {
-        return _dicts;
-    }
+  DictionaryCollections * getDicts() {
+    return _dicts;
+  }
 
 private:
-    int _i;
-    int _state;
-    utility::SmartMap<int>::const_iterator _j;
-    DictionaryCollections * _dicts;
+  int _i;
+  int _state;
+  utility::SmartMap<int>::const_iterator _j;
+  DictionaryCollections * _dicts;
 };
 
 /*
@@ -94,134 +94,134 @@ class FeatureSpaceIterator {
  */
 class FeatureSpace {
 public:
-    enum { DEP, SIB, GRD, GRDSIB, POSU, POSB };
+  enum { DEP, SIB, GRD, GRDSIB, POSU, POSB };
 
 public:
-    /*
-     * Constructor of feature space, construct feature space with
-     * instances. Number of dependency relations is given when 
-     * constructing the feature space.
-     *
-     *  @param[in]  _num_deprels    the number of dependency relations
-     */
-    FeatureSpace() : _num_deprels(1), _offset(0) {
-        // set all the group to be empty
-        for (int i = 0; i < NUM_FEATURE_GROUPS; ++ i) {
-            groups[i]  = 0;
-            offsets[i] = 0;
-        }
-    }
-
-    ~FeatureSpace() {
-        for (int i = 0; i < NUM_FEATURE_GROUPS; ++ i) {
-            if (groups[i]) {
-                delete groups[i];
-            }
-        }
+  /*
+   * Constructor of feature space, construct feature space with
+   * instances. Number of dependency relations is given when
+   * constructing the feature space.
+   *
+   *  @param[in]  _num_deprels  the number of dependency relations
+   */
+  FeatureSpace() : _num_deprels(1), _offset(0) {
+    // set all the group to be empty
+    for (int i = 0; i < NUM_FEATURE_GROUPS; ++ i) {
+      groups[i]  = 0;
+      offsets[i] = 0;
     }
+  }
 
-    /*
-     * Build feature space from the instances. For dependency parsing, 
-     * there is no negative feature, so the feature space can be maintained
-     * once the training instance is given.
-     *
-     *  @param[in]  num_deprels     
-     *  @param[in]  instances       the instances
-     */
-    int build_feature_space( int num_deprels, const std::vector<Instance *> & instances);
-
-    /*
-     * Build feature space for truncate, just like the function above
-     *
-     *  @param
-     */
-    void build_feature_space_truncate(int num_deprels);
-
-    /*After copy the dic item from the model that not equal to Zero,set the offset */
-    void set_offset_truncate();
-
-    /*
-     * Retrieve the feature string and maintain its index in the
-     * feature space.
-     *
-     *  @param[in]  gid,    the group index
-     *  @parma[in]  tid,    the template index
-     *  @param[in]  key,    the key
-     *  @param[in]  create, if true, a new key will be created.
-     *  @return     int     index of the key, -1 if not exist.
-     */
-    int retrieve(int gid, int tid, const char * key, bool create);
-
-
-    /*
-     * Maintain the index of this key with certain label, for the
-     * labeled case, lid is automically set as zero.
-     *
-     *  @param[in]  gid,    the group index
-     *  @param[in]  tid,    the template index
-     *  @param[in]  key,    the key
-     *  @param[in]  lid,    the label index, default as zero
-     *  @return     int     the index of the (key, label)
-     */
-    int index(int gid, int tid, const char * key, int lid = 0);
-
-    /*
-     * Get number of dimension of the features. For example, supposing there
-     * are two groups of features whose number of feature is 10 and 20. and 6
-     * is the number of dependency relations, then 10 * 6 + 20 * 6 is return.
-     *
-     *  @return     int     the number of labels
-     */
-    int dim();
-
-    /*
-     * Get number of dimension of the features. For example, supposing there
-     * are two groups of features whose number of feature is 10 and 20, then
-     * 10 + 20 is return.
-     *
-     *  @return     int     the number of labels
-     */
-    int num_features();
-
-    /*
-     * save the features space to the output stream
-     *
-     *  @param[out] out     the output stream
-     */
-    void save(ostream & out);
-
-    /*
-     * load feature space from input stream
-     *
-     *  @param[in]  num_deprels the number of dependency relation type
-     *  @param[in]  in          the input stream
-     */
-    bool load(int num_deprels, istream & in);
-
-    FeatureSpaceIterator begin(int gid) {
-        return FeatureSpaceIterator(groups[gid]);
+  ~FeatureSpace() {
+    for (int i = 0; i < NUM_FEATURE_GROUPS; ++ i) {
+      if (groups[i]) {
+        delete groups[i];
+      }
     }
+  }
+
+  /*
+   * Build feature space from the instances. For dependency parsing,
+   * there is no negative feature, so the feature space can be maintained
+   * once the training instance is given.
+   *
+   *  @param[in]  num_deprels
+   *  @param[in]  instances     the instances
+   */
+  int build_feature_space(int num_deprels, const std::vector<Instance *> & instances);
+
+  /*
+   * Build feature space for truncate, just like the function above
+   *
+   *  @param
+   */
+  void build_feature_space_truncate(int num_deprels);
+
+  /*After copy the dic item from the model that not equal to Zero,set the offset */
+  void set_offset_truncate();
+
+  /*
+   * Retrieve the feature string and maintain its index in the
+   * feature space.
+   *
+   *  @param[in]  gid,  the group index
+   *  @parma[in]  tid,  the template index
+   *  @param[in]  key,  the key
+   *  @param[in]  create, if true, a new key will be created.
+   *  @return   int   index of the key, -1 if not exist.
+   */
+  int retrieve(int gid, int tid, const char * key, bool create);
+
+
+  /*
+   * Maintain the index of this key with certain label, for the
+   * labeled case, lid is automically set as zero.
+   *
+   *  @param[in]  gid,  the group index
+   *  @param[in]  tid,  the template index
+   *  @param[in]  key,  the key
+   *  @param[in]  lid,  the label index, default as zero
+   *  @return   int   the index of the (key, label)
+   */
+  int index(int gid, int tid, const char * key, int lid = 0);
+
+  /*
+   * Get number of dimension of the features. For example, supposing there
+   * are two groups of features whose number of feature is 10 and 20. and 6
+   * is the number of dependency relations, then 10 * 6 + 20 * 6 is return.
+   *
+   *  @return   int   the number of labels
+   */
+  int dim();
+
+  /*
+   * Get number of dimension of the features. For example, supposing there
+   * are two groups of features whose number of feature is 10 and 20, then
+   * 10 + 20 is return.
+   *
+   *  @return   int   the number of labels
+   */
+  int num_features();
+
+  /*
+   * save the features space to the output stream
+   *
+   *  @param[out] out   the output stream
+   */
+  void save(ostream & out);
+
+  /*
+   * load feature space from input stream
+   *
+   *  @param[in]  num_deprels the number of dependency relation type
+   *  @param[in]  in      the input stream
+   */
+  bool load(int num_deprels, istream & in);
+
+  FeatureSpaceIterator begin(int gid) {
+    return FeatureSpaceIterator(groups[gid]);
+  }
 private:
-    const static int NUM_FEATURE_GROUPS = 6;
+  const static int NUM_FEATURE_GROUPS = 6;
 
-    int _offset;
-    int _num_features;
-    int _num_deprels;
+  int _offset;
+  int _num_features;
+  int _num_deprels;
 
-    int offsets[NUM_FEATURE_GROUPS]; /*< offset of group */
-    DictionaryCollections * groups[NUM_FEATURE_GROUPS];
+  int offsets[NUM_FEATURE_GROUPS]; /*< offset of group */
+  DictionaryCollections * groups[NUM_FEATURE_GROUPS];
 
 private:
-    /*
-     * Allocate the feature groups according the options
-     *
-     *  @return     int         number of actived dictinary group
-     */
-    int allocate_dictionary_groups();
+  /*
+   * Allocate the feature groups according the options
+   *
+   *  @return   int     number of actived dictinary group
+   */
+  int allocate_dictionary_groups();
 };
 
 }   // end for namespace parser
 }   // end for namespace ltp
 
-#endif  //  end for __FEATURE_SPACE_H__
+#endif  //  end for __LTP_PARSER_FEATURE_SPACE_H__
 
diff --git a/src/parser/featurevec.h b/src/parser/featurevec.h
index 4585e66ea..7174091a5 100644
--- a/src/parser/featurevec.h
+++ b/src/parser/featurevec.h
@@ -1,5 +1,5 @@
-#ifndef __FEATURE_VECTOR_H__
-#define __FEATURE_VECTOR_H__
+#ifndef __LTP_PARSER_FEATURE_VECTOR_H__
+#define __LTP_PARSER_FEATURE_VECTOR_H__
 
 #include <iostream>
 #include <fstream>
@@ -8,110 +8,110 @@ namespace ltp {
 namespace parser {
 
 struct FeatureVector {
-    FeatureVector() : n(0), idx(0), val(0), loff(0) {}
-    ~FeatureVector() {
-        // clear();
+  FeatureVector() : n(0), idx(0), val(0), loff(0) {}
+  ~FeatureVector() {
+    // clear();
+  }
+
+  int n;
+  int * idx; 
+  double * val;
+  int loff;
+
+  /*
+   * clear the FeatureVector
+   */
+  void clear() {
+    if (idx) {
+      delete [](idx);
+      idx = 0;
     }
 
-    int n;
-    int * idx; 
-    double * val;
-    int loff;
-
-    /*
-     * clear the FeatureVector
-     */
-    void clear() {
-        if (idx) {
-            delete [](idx);
-            idx = 0;
-        }
-
-        if (val) {
-            delete [](val);
-            val = 0;
-        }
+    if (val) {
+      delete [](val);
+      val = 0;
     }
+  }
 };
 
 struct FeatureVectorDB : public FeatureVector {
-    FeatureVectorDB() : offset(-1) {}
-    ~FeatureVectorDB() {
+  FeatureVectorDB() : offset(-1) {}
+  ~FeatureVectorDB() {
+  }
+
+  long long offset;
+
+  /*
+   * Write the feature vector to file, return offset of the featurevec
+   * This method is discarded because of the low performance of file
+   * operation.
+   *
+   *  @param[in]  ofs   the output filestream
+   *  @return   int   offset of the feature.
+   */
+  long long write(std::ostream & ofs) {
+    // 
+    if (n <= 0 || idx == 0) {
+      offset = -1;
+      return -1;
     }
 
-    long long offset;
-
-    /*
-     * Write the feature vector to file, return offset of the featurevec
-     * This method is discarded because of the low performance of file
-     * operation.
-     *
-     *  @param[in]  ofs     the output filestream
-     *  @return     int     offset of the feature.
-     */
-    long long write(std::ostream & ofs) {
-        // 
-        if (n <= 0 || idx == 0) {
-            offset = -1;
-            return -1;
-        }
-
-        char ch = (val == 0 ? 0 : 1);
-        offset = ofs.tellp();
-
-        ofs.write(&ch, 1);
-        ofs.write(reinterpret_cast<const char *>(&n), sizeof(int));
-        ofs.write(reinterpret_cast<const char *>(idx), sizeof(int) * n);
-        if (val) {
-            ofs.write(reinterpret_cast<const char *>(val), sizeof(double) * n);
-        }
-
-        return offset;
+    char ch = (val == 0 ? 0 : 1);
+    offset = ofs.tellp();
+
+    ofs.write(&ch, 1);
+    ofs.write(reinterpret_cast<const char *>(&n), sizeof(int));
+    ofs.write(reinterpret_cast<const char *>(idx), sizeof(int) * n);
+    if (val) {
+      ofs.write(reinterpret_cast<const char *>(val), sizeof(double) * n);
+    }
+
+    return offset;
+  }
+
+  /*
+   * Read the feature vector from filestream, This method is discarded
+   * because of the low performance of file operation.
+   *
+   *  @param[in]  ifs   the input filestream
+   */
+  int read(std::istream & ifs) {
+    if (offset < 0) {
+      return -1;
     }
 
-    /*
-     * Read the feature vector from filestream, This method is discarded
-     * because of the low performance of file operation.
-     *
-     *  @param[in]  ifs     the input filestream
-     */
-    int read(std::istream & ifs) {
-        if (offset < 0) {
-            return -1;
-        }
-
-        ifs.seekg(offset);
-
-        char ch = 0;
-        ifs.read(&ch, 1);
-        ifs.read(reinterpret_cast<char *>(&n), sizeof(int));
-        idx = new int[n];
-        ifs.read(reinterpret_cast<char *>(idx), sizeof(int) * n);
-        if (ch) {
-            val = new double[n];
-            ifs.read(reinterpret_cast<char *>(val), sizeof(double) * n);
-        }
-
-        return 0;
+    ifs.seekg(offset);
+
+    char ch = 0;
+    ifs.read(&ch, 1);
+    ifs.read(reinterpret_cast<char *>(&n), sizeof(int));
+    idx = new int[n];
+    ifs.read(reinterpret_cast<char *>(idx), sizeof(int) * n);
+    if (ch) {
+      val = new double[n];
+      ifs.read(reinterpret_cast<char *>(val), sizeof(double) * n);
+    }
+
+    return 0;
+  }
+
+  /*
+   * free memory of feature vector.
+   */
+  void nice() {
+    if (idx) {
+      delete [](idx);
+      idx = 0;
     }
 
-    /*
-     * free memory of feature vector.
-     */
-    void nice() {
-        if (idx) {
-            delete [](idx);
-            idx = 0;
-        }
-
-        if (val) {
-            delete [](val);
-            val = 0;
-        }
+    if (val) {
+      delete [](val);
+      val = 0;
     }
+  }
 };
 
-}       //  end for namespace parser
-}       //  end for namespace ltp
+}     //  end for namespace parser
+}     //  end for namespace ltp
 
-#endif  //  end for __FEATURE_VECTOR__
+#endif  //  end for __LTP_PARSER_FEATURE_VECTOR_H__
diff --git a/src/parser/instance.h b/src/parser/instance.h
index 965a67c7a..b637e4f36 100644
--- a/src/parser/instance.h
+++ b/src/parser/instance.h
@@ -1,5 +1,5 @@
-#ifndef __INSTANCE_H__
-#define __INSTANCE_H__
+#ifndef __LTP_PARSER_INSTANCE_H__
+#define __LTP_PARSER_INSTANCE_H__
 
 #include <iostream>
 #include <string>
@@ -16,294 +16,296 @@ using namespace ltp::math;
 
 class Instance {
 public:
-    Instance(){
+  Instance(){
+  }
+
+  ~Instance() {
+    free_features();
+  }
+
+  /*
+   * Get length of the instance. Instance's length is defined as number
+   * of form tokens.
+   *
+   *  @return   size_t        the number of tokens
+   */
+  size_t size() const {
+    return forms.size();
+  }
+
+  /*
+   * Get number of error of the heads. Prepositive condition is number
+   * of predicted_heads greater than 0 and number of predicated_heads
+   * equals number of heads.
+   *
+   *  @param[in]  ignore_punctation   specify whether ignore punction
+   *  @return   int         the number of errors
+   */
+  int num_error_heads(bool ignore_punctation = true) const {
+    if (predicted_heads.size() == 0) {
+      return size();
     }
 
-    ~Instance() {
-        free_features();
-    }
+    int ret = 0;
+    int len = size();
+    for (int i = 1; i < len; ++ i) {
+      if (ignore_punctation && postags[i] == "wp") {
+        continue;
+      }
 
-    /*
-     * Get length of the instance. Instance's length is defined as number
-     * of form tokens.
-     *
-     *  @return     size_t              the number of tokens
-     */
-    size_t size() const {
-        return forms.size();
+      if (predicted_heads[i] != heads[i]) {
+        ++ ret;
+      }
     }
 
-    /*
-     * Get number of error of the heads. Prepositive condition is number 
-     * of predicted_heads greater than 0 and number of predicated_heads
-     * equals number of heads.
-     *
-     *  @param[in]  ignore_punctation   specify whether ignore punction
-     *  @return     int                 the number of errors
-     */
-    int num_error_heads(bool ignore_punctation = true) const {
-        if (predicted_heads.size() == 0) {
-            return size();
-        }
-
-        int ret = 0;
-        int len = size();
-        for (int i = 1; i < len; ++ i) {
-            if (ignore_punctation && postags[i] == "wp") {
-                continue;
-            }
+    return ret;
+  }
 
-            if (predicted_heads[i] != heads[i]) {
-                ++ ret;
-            }
-        }
-
-        return ret;
+  int num_error_labels(bool ignore_punctation = true) {
+    if (predicted_heads.size() == 0 || predicted_deprelsidx.size() == 0) {
+      return size();
     }
 
-    int num_error_labels(bool ignore_punctation = true) {
-        if (predicted_heads.size() == 0 || predicted_deprelsidx.size() == 0) {
-            return size();
-        }
-
-        int ret = 0;
-        int len = size();
-        for (int i = 1; i < len; ++ i) {
-            if (ignore_punctation && postags[i] == "wp") {
-                continue;
-            }
-
-            if (predicted_heads[i] == heads[i] && predicted_deprelsidx[i] != deprelsidx[i]) {
-                ++ ret;
-            }
-        }
-
-        return ret;
-    }
-
-    double num_errors() {
-        return num_error_heads() + 0.5 * num_error_labels();
+    int ret = 0;
+    int len = size();
+    for (int i = 1; i < len; ++ i) {
+      if (ignore_punctation && postags[i] == "wp") {
+        continue;
+      }
+
+      if (predicted_heads[i] == heads[i]
+          && predicted_deprelsidx[i] != deprelsidx[i]) {
+        ++ ret;
+      }
     }
 
-    int num_correct_heads(bool ignore_punctation = true) {
-        if (predicted_heads.size() == 0) {
-            return 0;
-        }
-
-        int ret = 0;
-        int len = size();
-        for (int i = 1; i < len; ++ i) {
-            if (ignore_punctation && postags[i] == "wp") {
-                continue;
-            }
+    return ret;
+  }
 
-            if (predicted_heads[i] == heads[i]) {
-                ++ ret;
-            }
-        }
+  double num_errors() {
+    return num_error_heads() + 0.5 * num_error_labels();
+  }
 
-        return ret;
+  int num_correct_heads(bool ignore_punctation = true) {
+    if (predicted_heads.size() == 0) {
+      return 0;
     }
 
-    int num_correct_heads_and_labels(bool ignore_punctation = true) {
-        if (predicted_heads.size() == 0 || predicted_deprelsidx.size() == 0) {
-            return 0;
-        }
+    int ret = 0;
+    int len = size();
+    for (int i = 1; i < len; ++ i) {
+      if (ignore_punctation && postags[i] == "wp") {
+        continue;
+      }
 
-        int ret = 0;
-        int len = size();
-        for (int i = 1; i < len; ++ i) {
-            if (ignore_punctation && postags[i] == "wp") {
-                continue;
-            }
+      if (predicted_heads[i] == heads[i]) {
+        ++ ret;
+      }
+    }
 
-            if (predicted_heads[i] == heads[i] && (predicted_deprelsidx[i] == deprelsidx[i])) {
-                ++ ret;
-            }
-        }
+    return ret;
+  }
 
-        return ret;
+  int num_correct_heads_and_labels(bool ignore_punctation = true) {
+    if (predicted_heads.size() == 0 || predicted_deprelsidx.size() == 0) {
+      return 0;
     }
 
-    int num_rels(bool ignore_punctation = true) const {
-        if (!ignore_punctation) {
-            return forms.size() - 1;
-        } else {
-            int ret = 0;
-            int len = size();
-            for (int i = 1; i < len; ++ i) {
-                if (postags[i] != "wp") {
-                    ++ ret;
-                }
-            }
-            return ret;
-        }
-        return -1;
+    int ret = 0;
+    int len = size();
+    for (int i = 1; i < len; ++ i) {
+      if (ignore_punctation && postags[i] == "wp") {
+        continue;
+      }
+
+      if (predicted_heads[i] == heads[i]
+          && (predicted_deprelsidx[i] == deprelsidx[i])) {
+        ++ ret;
+      }
     }
 
-    void cleanup() {
-        free_features();
-        features.zero();
-        predicted_features.zero();
-        depu_features.dealloc();
-        depu_scores.dealloc();
-        depl_features.dealloc();
-        depl_scores.dealloc();
-        sibu_features.dealloc();
-        sibu_scores.dealloc();
-        sibl_features.dealloc();
-        sibl_scores.dealloc();
-        grdu_features.dealloc();
-        grdu_scores.dealloc();
-        grdl_features.dealloc();
-        grdl_scores.dealloc();
+    return ret;
+  }
+
+  int num_rels(bool ignore_punctation = true) const {
+    if (!ignore_punctation) {
+      return forms.size() - 1;
+    } else {
+      int ret = 0;
+      int len = size();
+      for (int i = 1; i < len; ++ i) {
+        if (postags[i] != "wp") {
+          ++ ret;
+        }
+      }
+      return ret;
     }
+    return -1;
+  }
+
+  void cleanup() {
+    free_features();
+    features.zero();
+    predicted_features.zero();
+    depu_features.dealloc();
+    depu_scores.dealloc();
+    depl_features.dealloc();
+    depl_scores.dealloc();
+    sibu_features.dealloc();
+    sibu_scores.dealloc();
+    sibl_features.dealloc();
+    sibl_scores.dealloc();
+    grdu_features.dealloc();
+    grdu_scores.dealloc();
+    grdl_features.dealloc();
+    grdl_scores.dealloc();
+  }
 public:
 
-    std::vector< std::string >                  forms;      /*< the forms */
-    std::vector< std::string >                  lemmas;     /*< the lemmas */
-    std::vector< std::vector< std::string> >    chars;      /*< the characters */
-    std::vector< std::string >                  postags;    /*< the postags */
+  std::vector< std::string >                forms;    /*< the forms */
+  std::vector< std::string >                lemmas;   /*< the lemmas */
+  std::vector< std::vector< std::string> >  chars;    /*< the characters */
+  std::vector< std::string >                postags;  /*< the postags */
 
-    std::vector<int>                            heads;
-    std::vector<int>                            deprelsidx;
-    std::vector< std::string >                  deprels;
-    std::vector<int>                            predicted_heads;
-    std::vector<int>                            predicted_deprelsidx;
-    std::vector< std::string >                  predicted_deprels;
+  std::vector<int>              heads;
+  std::vector<int>              deprelsidx;
+  std::vector< std::string >    deprels;
+  std::vector<int>              predicted_heads;
+  std::vector<int>              predicted_deprelsidx;
+  std::vector< std::string >    predicted_deprels;
 
-    SparseVec               predicted_features;
-    SparseVec               features;
+  SparseVec         predicted_features;
+  SparseVec         features;
 
-    /* features group */
-    //Vec<FeatureVector *>    posu_features;
-    //Vec<double>             posu_scores;
+  /* features group */
+  //Vec<FeatureVector *>  posu_features;
+  //Vec<double>       posu_scores;
 
-    Mat<FeatureVector *>    depu_features;
-    Mat<double>             depu_scores;
+  Mat<FeatureVector *>  depu_features;
+  Mat<double>           depu_scores;
 
-    Mat3<FeatureVector *>   depl_features;
-    Mat3<double>            depl_scores;
+  Mat3<FeatureVector *> depl_features;
+  Mat3<double>          depl_scores;
 
-    Mat3<FeatureVector *>   sibu_features;
-    Mat3<double>            sibu_scores;
+  Mat3<FeatureVector *> sibu_features;
+  Mat3<double>          sibu_scores;
 
-    Mat4<FeatureVector *>   sibl_features;
-    Mat4<double>            sibl_scores;
+  Mat4<FeatureVector *> sibl_features;
+  Mat4<double>          sibl_scores;
 
-    Mat3<FeatureVector *>   grdu_features;
-    Mat3<double>            grdu_scores;
+  Mat3<FeatureVector *> grdu_features;
+  Mat3<double>          grdu_scores;
 
-    Mat4<FeatureVector *>   grdl_features;
-    Mat4<double>            grdl_scores;
+  Mat4<FeatureVector *> grdl_features;
+  Mat4<double>          grdl_scores;
 
-    std::vector<int>             verb_cnt;
-    std::vector<int>             conj_cnt;
-    std::vector<int>             punc_cnt;
+  std::vector<int>      verb_cnt;
+  std::vector<int>      conj_cnt;
+  std::vector<int>      punc_cnt;
 
 private:
-    void free_features() {
-        int len;
-        FeatureVector ** fvs;
-        if ((len = depu_features.total_size()) > 0 && 
-                (fvs = depu_features.c_buf())) {
-            for (int i = 0; i < len; ++ i) {
-                if (fvs[i]) {
-                    fvs[i]->clear();
-                    delete fvs[i];
-                }
-            }
+  void free_features() {
+    int len;
+    FeatureVector ** fvs;
+    if ((len = depu_features.total_size()) > 0
+        && (fvs = depu_features.c_buf())) {
+      for (int i = 0; i < len; ++ i) {
+        if (fvs[i]) {
+          fvs[i]->clear();
+          delete fvs[i];
         }
+      }
+    }
 
-        // in labeled case, different labels share memory, index should
-        // be avoid double delete
-        if ((len = depl_features.total_size()) > 0 && 
-                (fvs = depl_features.c_buf())) {
-            int d1 = depl_features.dim1();
-            int d2 = depl_features.dim2();
-            int d3 = depl_features.dim3();
-
-            for (int i = 0; i < d1; ++ i) {
-                for (int j = 0; j < d2; ++ j) {
-                    if (depl_features[i][j][0]) {
-                        depl_features[i][j][0]->clear();
-                    }
-                    for (int l = 0; l < d3; ++ l) {
-                        if (depl_features[i][j][l]) {
-                            delete depl_features[i][j][l];
-                        }
-                    }
-                }
+    // in labeled case, different labels share memory, index should
+    // be avoid double delete
+    if ((len = depl_features.total_size()) > 0 
+        && (fvs = depl_features.c_buf())) {
+      int d1 = depl_features.dim1();
+      int d2 = depl_features.dim2();
+      int d3 = depl_features.dim3();
+
+      for (int i = 0; i < d1; ++ i) {
+        for (int j = 0; j < d2; ++ j) {
+          if (depl_features[i][j][0]) {
+            depl_features[i][j][0]->clear();
+          }
+          for (int l = 0; l < d3; ++ l) {
+            if (depl_features[i][j][l]) {
+              delete depl_features[i][j][l];
             }
+          }
         }
+      }
+    }
 
-        if ((len = sibu_features.total_size()) > 0 &&
-                (fvs = sibu_features.c_buf())) {
-            for (int i = 0; i < len; ++ i) {
-                if (fvs[i]) {
-                    fvs[i]->clear();
-                    delete fvs[i];
-                }
-            }
+    if ((len = sibu_features.total_size()) > 0
+        && (fvs = sibu_features.c_buf())) {
+      for (int i = 0; i < len; ++ i) {
+        if (fvs[i]) {
+          fvs[i]->clear();
+          delete fvs[i];
         }
+      }
+    }
 
-        if ((len = sibl_features.total_size()) > 0 &&
-                (fvs = sibl_features.c_buf())) {
-            int d1 = sibl_features.dim1();
-            int d2 = sibl_features.dim2();
-            int d3 = sibl_features.dim3();
-            int d4 = sibl_features.dim4();
-
-            for (int i = 0; i < d1; ++ i) {
-                for (int j = 0; j < d2; ++ j) {
-                    for (int k = 0; k < d3; ++ k) {
-                        if (sibl_features[i][j][k][0]) {
-                            sibl_features[i][j][k][0]->clear();
-                        }
-                        for (int l = 0; l < d4; ++ l) {
-                            if (sibl_features[i][j][k][l]) {
-                                delete sibl_features[i][j][k][l];
-                            }
-                        }
-                    }
-                }
+    if ((len = sibl_features.total_size()) > 0
+        && (fvs = sibl_features.c_buf())) {
+      int d1 = sibl_features.dim1();
+      int d2 = sibl_features.dim2();
+      int d3 = sibl_features.dim3();
+      int d4 = sibl_features.dim4();
+
+      for (int i = 0; i < d1; ++ i) {
+        for (int j = 0; j < d2; ++ j) {
+          for (int k = 0; k < d3; ++ k) {
+            if (sibl_features[i][j][k][0]) {
+              sibl_features[i][j][k][0]->clear();
             }
-        }
- 
-        if ((len = grdu_features.total_size()) > 0 &&
-                (fvs = grdu_features.c_buf())) {
-            for (int i = 0; i < len; ++ i) {
-                if (fvs[i]) {
-                    fvs[i]->clear();
-                    delete fvs[i];
-                }
+            for (int l = 0; l < d4; ++ l) {
+              if (sibl_features[i][j][k][l]) {
+                delete sibl_features[i][j][k][l];
+              }
             }
+          }
         }
+      }
+    }
 
-        if ((len = grdl_features.total_size()) > 0 &&
-                (fvs = grdl_features.c_buf())) {
-            int d1 = grdl_features.dim1();
-            int d2 = grdl_features.dim2();
-            int d3 = grdl_features.dim3();
-            int d4 = grdl_features.dim4();
-
-            for (int i = 0; i < d1; ++ i) {
-                for (int j = 0; j < d2; ++ j) {
-                    for (int k = 0; k < d3; ++ k) {
-                        if (grdl_features[i][j][k][0]) {
-                            grdl_features[i][j][k][0]->clear();
-                        }
-                        for (int l = 0; l < d4; ++ l) {
-                            if (grdl_features[i][j][k][l]) {
-                                delete grdl_features[i][j][k][l];
-                            }
-                        }
-                    }
-                }
-            }
+    if ((len = grdu_features.total_size()) > 0
+        && (fvs = grdu_features.c_buf())) {
+      for (int i = 0; i < len; ++ i) {
+        if (fvs[i]) {
+          fvs[i]->clear();
+          delete fvs[i];
         }
+      }
+    }
 
+    if (grdl_features.total_size() > 0
+        && (fvs = grdl_features.c_buf())) {
+      int d1 = grdl_features.dim1();
+      int d2 = grdl_features.dim2();
+      int d3 = grdl_features.dim3();
+      int d4 = grdl_features.dim4();
+
+      for (int i = 0; i < d1; ++ i) {
+        for (int j = 0; j < d2; ++ j) {
+          for (int k = 0; k < d3; ++ k) {
+            if (grdl_features[i][j][k][0]) {
+              grdl_features[i][j][k][0]->clear();
+            }
+            for (int l = 0; l < d4; ++ l) {
+              if (grdl_features[i][j][k][l]) {
+                delete grdl_features[i][j][k][l];
+              }
+            }
+          }
+        }
+      }
     }
+
+  }
 };  // end for class Instance
 }   // end for namespace parser
 }   // end for namespace ltp
diff --git a/src/parser/lgdpj.cpp b/src/parser/lgdpj.cpp
index 073caf731..7baef0430 100644
--- a/src/parser/lgdpj.cpp
+++ b/src/parser/lgdpj.cpp
@@ -12,27 +12,28 @@
 using namespace ltp::parser;
 
 void usage(void) {
-    std::cerr << "lgdpj - Training and testing suite for Chinese Dependency Parsering" << std::endl;
-    std::cerr << "Copyright (C) 2012-2013 HIT-SCIR" << std::endl;
-    std::cerr << std::endl;
-    std::cerr << "Usage: $./lgdpj <config_file>" << std::endl;
-    std::cerr << std::endl;
+  std::cerr << "lgdpj - Training and testing suite for Chinese Dependency Parsering"
+            << std::endl;
+  std::cerr << "Copyright (C) 2012-2014 HIT-SCIR" << std::endl;
+  std::cerr << std::endl;
+  std::cerr << "Usage: $./lgdpj <config_file>" << std::endl;
+  std::cerr << std::endl;
 }
 
 int main(int argc, char ** argv) {
-    if (argc < 2) {
-        usage();
-        return -1;
-    }
+  if (argc < 2) {
+    usage();
+    return -1;
+  }
 
-    ConfigParser cfg(argv[1]);
+  ConfigParser cfg(argv[1]);
 
-    if (!cfg) {
-        ERROR_LOG("Failed to parse config file.")
-        return -1;
-    }
+  if (!cfg) {
+    ERROR_LOG("Failed to parse config file.")
+    return -1;
+  }
 
-    Parser parser(cfg);
-    parser.run();
-    return 0;
+  Parser parser(cfg);
+  parser.run();
+  return 0;
 }
diff --git a/src/parser/model.cpp b/src/parser/model.cpp
index 5038034a2..9ab1c7c03 100644
--- a/src/parser/model.cpp
+++ b/src/parser/model.cpp
@@ -4,238 +4,238 @@ namespace ltp {
 namespace parser {
 
 int Model::num_deprels() {
-    if (_num_deprels < 0) {
-        // unlabeled case
-        if (0 == deprels.size()) {
-            _num_deprels = 1;
-        } else {
-            _num_deprels = deprels.size();
-        }
+  if (_num_deprels < 0) {
+    // unlabeled case
+    if (0 == deprels.size()) {
+      _num_deprels = 1;
+    } else {
+      _num_deprels = deprels.size();
     }
-    return _num_deprels;
+  }
+  return _num_deprels;
 }
 
 int Model::num_postags() {
-    if (_num_postags < 0) {
-        // unlabeled case
-        if (0 == postags.size()) {
-            _num_postags = 1;
-        } else {
-            _num_postags = postags.size();
-        }
+  if (_num_postags < 0) {
+    // unlabeled case
+    if (0 == postags.size()) {
+      _num_postags = 1;
+    } else {
+      _num_postags = postags.size();
     }
+  }
 
-    return _num_postags;
+  return _num_postags;
 }
 
 int Model::num_features() {
-    if (_num_features < 0) {
-        _num_features = space.num_features();
-    }
-    return _num_features;
+  if (_num_features < 0) {
+    _num_features = space.num_features();
+  }
+  return _num_features;
 }
 
 int Model::dim() {
-    if (_dim < 0) {
-        _dim = space.dim();
-    }
-    return _dim;
+  if (_dim < 0) {
+    _dim = space.dim();
+  }
+  return _dim;
 }
 
 void Model::save(ostream & out) {
-    // write a signature
-    char chunk[16] = {'l','g','d','p', 'j', 0};
-    out.write(chunk, 16);
-    unsigned int tmp;
-
-    int off = out.tellp();
-
-    unsigned basic_offset =  0;
-    unsigned postag_offset = 0;
-    unsigned deprels_offset = 0;
-    unsigned feature_offset = 0;
-    unsigned parameter_offset = 0;
-
-    // write pseduo position
-    write_uint(out, 0); //  basic offset
-    write_uint(out, 0); //  postag offset
-    write_uint(out, 0); //  deprels offset
-    write_uint(out, 0); //  features offset
-    write_uint(out, 0); //  parameters offset
-
-    // model and feature information
-    // labeled model
-    basic_offset = out.tellp();
-    tmp = model_opt.labeled;
-    write_uint(out, tmp);
-
-    // decode order
-    strncpy(chunk, model_opt.decoder_name.c_str(), 16);
-    out.write(chunk, 16);
-
-    // use dependency
-    tmp = feat_opt.use_dependency;
-    write_uint(out, tmp);
-
-    // use dependency unigram
-    tmp = feat_opt.use_dependency_unigram;
-    write_uint(out, tmp);
-
-    // use dependency bigram
-    tmp = feat_opt.use_dependency_bigram;
-    write_uint(out, tmp);
-
-    // use dependency surrounding
-    tmp = feat_opt.use_dependency_surrounding;
-    write_uint(out, tmp);
-
-    // use dependency between
-    tmp = feat_opt.use_dependency_between;
-    write_uint(out, tmp);
-
-    // use sibling
-    tmp = feat_opt.use_sibling;
-    write_uint(out, tmp);
-
-    // use sibling basic
-    tmp = feat_opt.use_sibling_basic;
-    write_uint(out, tmp);
-
-    // use sibling linear
-    tmp = feat_opt.use_sibling_linear;
-    write_uint(out, tmp);
-
-    // use grand
-    tmp = feat_opt.use_grand;
-    write_uint(out, tmp);
-
-    // use grand basic
-    tmp = feat_opt.use_grand_basic;
-    write_uint(out, tmp);
-
-    // use grand linear
-    tmp = feat_opt.use_grand_linear;
-    write_uint(out, tmp);
-
-    // save postag lexicon
-    postag_offset = out.tellp();
-    postags.dump(out);
-
-    // save dependency relation lexicon
-    deprels_offset = out.tellp();
-    deprels.dump(out);
-
-    feature_offset = out.tellp();
-    space.save(out);
-
-    parameter_offset = out.tellp();
-    param.dump(out);
-
-    out.seekp(off);
-    write_uint(out, basic_offset);
-    write_uint(out, postag_offset);
-    write_uint(out, deprels_offset);
-    write_uint(out, feature_offset);
-    write_uint(out, parameter_offset);
-
-    // out.seekp(0, std::ios::end);
+  // write a signature
+  char chunk[16] = {'l','g','d','p', 'j', 0};
+  out.write(chunk, 16);
+  unsigned int tmp;
+
+  int off = out.tellp();
+
+  unsigned basic_offset =  0;
+  unsigned postag_offset = 0;
+  unsigned deprels_offset = 0;
+  unsigned feature_offset = 0;
+  unsigned parameter_offset = 0;
+
+  // write pseduo position
+  write_uint(out, 0); //  basic offset
+  write_uint(out, 0); //  postag offset
+  write_uint(out, 0); //  deprels offset
+  write_uint(out, 0); //  features offset
+  write_uint(out, 0); //  parameters offset
+
+  // model and feature information
+  // labeled model
+  basic_offset = out.tellp();
+  tmp = model_opt.labeled;
+  write_uint(out, tmp);
+
+  // decode order
+  strncpy(chunk, model_opt.decoder_name.c_str(), 16);
+  out.write(chunk, 16);
+
+  // use dependency
+  tmp = feat_opt.use_dependency;
+  write_uint(out, tmp);
+
+  // use dependency unigram
+  tmp = feat_opt.use_dependency_unigram;
+  write_uint(out, tmp);
+
+  // use dependency bigram
+  tmp = feat_opt.use_dependency_bigram;
+  write_uint(out, tmp);
+
+  // use dependency surrounding
+  tmp = feat_opt.use_dependency_surrounding;
+  write_uint(out, tmp);
+
+  // use dependency between
+  tmp = feat_opt.use_dependency_between;
+  write_uint(out, tmp);
+
+  // use sibling
+  tmp = feat_opt.use_sibling;
+  write_uint(out, tmp);
+
+  // use sibling basic
+  tmp = feat_opt.use_sibling_basic;
+  write_uint(out, tmp);
+
+  // use sibling linear
+  tmp = feat_opt.use_sibling_linear;
+  write_uint(out, tmp);
+
+  // use grand
+  tmp = feat_opt.use_grand;
+  write_uint(out, tmp);
+
+  // use grand basic
+  tmp = feat_opt.use_grand_basic;
+  write_uint(out, tmp);
+
+  // use grand linear
+  tmp = feat_opt.use_grand_linear;
+  write_uint(out, tmp);
+
+  // save postag lexicon
+  postag_offset = out.tellp();
+  postags.dump(out);
+
+  // save dependency relation lexicon
+  deprels_offset = out.tellp();
+  deprels.dump(out);
+
+  feature_offset = out.tellp();
+  space.save(out);
+
+  parameter_offset = out.tellp();
+  param.dump(out);
+
+  out.seekp(off);
+  write_uint(out, basic_offset);
+  write_uint(out, postag_offset);
+  write_uint(out, deprels_offset);
+  write_uint(out, feature_offset);
+  write_uint(out, parameter_offset);
+
+  // out.seekp(0, std::ios::end);
 }
 
 bool Model::load(istream & in) {
-    char chunk[16];
-    in.read(chunk, 16);
-    if (strcmp(chunk, "lgdpj")) {
-        return false;
-    }
+  char chunk[16];
+  in.read(chunk, 16);
+  if (strcmp(chunk, "lgdpj")) {
+    return false;
+  }
 
-    unsigned int basic_offset = read_uint(in);
-    unsigned int postag_offset = read_uint(in);
-    unsigned int deprels_offset = read_uint(in);
-    unsigned int feature_offset = read_uint(in);
-    unsigned int parameter_offset = read_uint(in);
+  unsigned int basic_offset = read_uint(in);
+  unsigned int postag_offset = read_uint(in);
+  unsigned int deprels_offset = read_uint(in);
+  unsigned int feature_offset = read_uint(in);
+  unsigned int parameter_offset = read_uint(in);
 
-    in.seekg(basic_offset);
-    model_opt.labeled = (read_uint(in) == 1);
+  in.seekg(basic_offset);
+  model_opt.labeled = (read_uint(in) == 1);
 
-    // decode order
-    in.read(chunk, 16);
-    model_opt.decoder_name = chunk;
+  // decode order
+  in.read(chunk, 16);
+  model_opt.decoder_name = chunk;
 
-    // use dependency
-    feat_opt.use_dependency = (read_uint(in) == 1);
+  // use dependency
+  feat_opt.use_dependency = (read_uint(in) == 1);
 
-    // use dependency unigram
-    feat_opt.use_dependency_unigram = (read_uint(in) == 1);
+  // use dependency unigram
+  feat_opt.use_dependency_unigram = (read_uint(in) == 1);
 
-    // use dependency bigram
-    feat_opt.use_dependency_bigram = (read_uint(in) == 1);
+  // use dependency bigram
+  feat_opt.use_dependency_bigram = (read_uint(in) == 1);
 
-    // use dependency surrounding
-    feat_opt.use_dependency_surrounding = (read_uint(in) == 1);
+  // use dependency surrounding
+  feat_opt.use_dependency_surrounding = (read_uint(in) == 1);
 
-    // use dependency between
-    feat_opt.use_dependency_between = (read_uint(in) == 1);
+  // use dependency between
+  feat_opt.use_dependency_between = (read_uint(in) == 1);
 
-    // use sibling
-    feat_opt.use_sibling = (read_uint(in) == 1);
+  // use sibling
+  feat_opt.use_sibling = (read_uint(in) == 1);
 
-    // use sibling basic
-    feat_opt.use_sibling_basic = (read_uint(in) == 1);
+  // use sibling basic
+  feat_opt.use_sibling_basic = (read_uint(in) == 1);
 
-    // use sibling linear
-    feat_opt.use_sibling_linear = (read_uint(in) == 1);
+  // use sibling linear
+  feat_opt.use_sibling_linear = (read_uint(in) == 1);
 
-    // use grand
-    feat_opt.use_grand = (read_uint(in) == 1);
+  // use grand
+  feat_opt.use_grand = (read_uint(in) == 1);
 
-    // use grand basic
-    feat_opt.use_grand_basic = (read_uint(in) == 1);
+  // use grand basic
+  feat_opt.use_grand_basic = (read_uint(in) == 1);
 
-    // use grand linear
-    feat_opt.use_grand_linear = (read_uint(in) == 1);
+  // use grand linear
+  feat_opt.use_grand_linear = (read_uint(in) == 1);
 
-    // automically detrieve 
-    feat_opt.use_unlabeled_dependency = (!model_opt.labeled &&
-            feat_opt.use_dependency);
+  // automically detrieve
+  feat_opt.use_unlabeled_dependency = (!model_opt.labeled
+                                       && feat_opt.use_dependency);
 
-    feat_opt.use_labeled_dependency = (model_opt.labeled &&
-            feat_opt.use_dependency);
+  feat_opt.use_labeled_dependency = (model_opt.labeled
+                                     && feat_opt.use_dependency);
 
-    feat_opt.use_unlabeled_sibling = (!model_opt.labeled &&
-            feat_opt.use_sibling);
+  feat_opt.use_unlabeled_sibling = (!model_opt.labeled
+                                    && feat_opt.use_sibling);
 
-    feat_opt.use_labeled_sibling = (model_opt.labeled &&
-            feat_opt.use_sibling);
+  feat_opt.use_labeled_sibling = (model_opt.labeled
+                                  && feat_opt.use_sibling);
 
-    feat_opt.use_unlabeled_grand = (!model_opt.labeled &&
-            feat_opt.use_grand);
+  feat_opt.use_unlabeled_grand = (!model_opt.labeled
+                                  && feat_opt.use_grand);
 
-    feat_opt.use_labeled_grand = (model_opt.labeled &&
-            feat_opt.use_grand);
+  feat_opt.use_labeled_grand = (model_opt.labeled
+                                && feat_opt.use_grand);
 
-    in.seekg(postag_offset);
-    if (!postags.load(in)) {
-        return false;
-    }
+  in.seekg(postag_offset);
+  if (!postags.load(in)) {
+    return false;
+  }
 
-    in.seekg(deprels_offset);
-    if (!deprels.load(in)) {
-        return false;
-    }
+  in.seekg(deprels_offset);
+  if (!deprels.load(in)) {
+    return false;
+  }
 
-    in.seekg(feature_offset);
-    if (!space.load(num_deprels(), in)) {
-        return false;
-    }
+  in.seekg(feature_offset);
+  if (!space.load(num_deprels(), in)) {
+    return false;
+  }
 
-    in.seekg(parameter_offset);
-    if (!param.load(in)) {
-        return false;
-    }
+  in.seekg(parameter_offset);
+  if (!param.load(in)) {
+    return false;
+  }
 
-    return true;
+  return true;
 }
 
-}       //  end for namespace parser
+}     //  end for namespace parser
 
-}       //  end for namespace ltp
+}     //  end for namespace ltp
diff --git a/src/parser/model.h b/src/parser/model.h
index a8b1c26d9..31e5fa847 100644
--- a/src/parser/model.h
+++ b/src/parser/model.h
@@ -1,5 +1,5 @@
-#ifndef __MODEL_H__
-#define __MODEL_H__
+#ifndef __LTP_PARSER_MODEL_H__
+#define __LTP_PARSER_MODEL_H__
 
 #include "featurespace.h"
 #include "parameters.h"
@@ -10,83 +10,83 @@ namespace parser {
 
 class Model {
 public:
-    Model() : 
-        _dim(-1), 
-        _num_deprels(-1), 
-        _num_postags(-1),
-        _num_features(-1) {}
-
-    ~Model() {}
-
-    /*
-     * get the number of dependency relation types
-     *
-     *  @return int     the number of dependency relation type
-     */
-    int num_deprels(); 
-
-    /*
-     * get the number of postag types
-     *
-     *  @return int     the number of postag type
-     */
-    int num_postags(); 
-
-    /*
-     * get the number of features
-     *
-     *  @return int     the number of features
-     */
-    int num_features();
-
-    /*
-     * get the number of dimension
-     *
-     *  @return int     the number of dimension
-     */
-    int dim();
+  Model() :
+    _dim(-1),
+    _num_deprels(-1),
+    _num_postags(-1),
+    _num_features(-1) {}
+
+  ~Model() {}
+
+  /*
+   * get the number of dependency relation types
+   *
+   *  @return int   the number of dependency relation type
+   */
+  int num_deprels();
+
+  /*
+   * get the number of postag types
+   *
+   *  @return int   the number of postag type
+   */
+  int num_postags();
+
+  /*
+   * get the number of features
+   *
+   *  @return int   the number of features
+   */
+  int num_features();
+
+  /*
+   * get the number of dimension
+   *
+   *  @return int   the number of dimension
+   */
+  int dim();
 
 private:
-    int _num_deprels;
-    int _num_postags;
-    int _num_features;
-    int _dim;
+  int _num_deprels;
+  int _num_postags;
+  int _num_features;
+  int _dim;
 
 public:
-    FeatureSpace            space;
-    Parameters              param;
-
-    IndexableSmartMap       postags;
-    IndexableSmartMap       deprels;
-
-    /*
-     * save the model to the output stream.
-     *
-     *  @param  out     the output stream
-     */
-    void save(ostream & out);
-
-    /*
-     * load the model from the input stream, return true on
-     * success, otherwise false
-     *
-     *  @param  in      the input stream
-     *  @return bool    true on success, otherwise false
-     */
-    bool load(istream & in);
+  FeatureSpace      space;
+  Parameters        param;
+
+  IndexableSmartMap     postags;
+  IndexableSmartMap     deprels;
+
+  /*
+   * save the model to the output stream.
+   *
+   *  @param  out   the output stream
+   */
+  void save(ostream & out);
+
+  /*
+   * load the model from the input stream, return true on
+   * success, otherwise false
+   *
+   *  @param  in    the input stream
+   *  @return bool  true on success, otherwise false
+   */
+  bool load(istream & in);
 
 private:
-    void write_uint(ostream & out, unsigned int val) {
-        out.write(reinterpret_cast<const char *>(&val), sizeof(unsigned int));
-    }
-
-    unsigned int read_uint(istream & in) {
-        char p[4];
-        in.read(reinterpret_cast<char*>(p), sizeof(unsigned int));
-        return *reinterpret_cast<const unsigned int*>(p);
-    }
-};      //  end for class model
-
-}       //  end for namespace parser
-}       //  end for namespace ltp
-#endif  //  end for __MODEL_H__
+  void write_uint(ostream & out, unsigned int val) {
+    out.write(reinterpret_cast<const char *>(&val), sizeof(unsigned int));
+  }
+
+  unsigned int read_uint(istream & in) {
+    char p[4];
+    in.read(reinterpret_cast<char*>(p), sizeof(unsigned int));
+    return *reinterpret_cast<const unsigned int*>(p);
+  }
+};    //  end for class model
+
+}     //  end for namespace parser
+}     //  end for namespace ltp
+#endif  //  end for __LTP_PARSER_MODEL_H__
diff --git a/src/parser/options.h b/src/parser/options.h
index 98402be0e..ff5e51f68 100644
--- a/src/parser/options.h
+++ b/src/parser/options.h
@@ -1,5 +1,5 @@
-#ifndef __OPTIONS_H__
-#define __OPTIONS_H__
+#ifndef __LTP_PARSER_OPTIONS_H__
+#define __LTP_PARSER_OPTIONS_H__
 
 #include <iostream>
 
@@ -9,74 +9,72 @@ namespace parser {
 using namespace std;
 
 struct TrainOptions {
-    string  train_file;             /*< the training file */
-    string  holdout_file;           /*< the develop file */
-    int     max_iter;               /*< the iteration number */
-    // training algorithm parameter
-    string  algorithm;              /*< the algorithm */
-    string  model_name;             /*< the model name */
-    bool    conservative_update;    /*< conservative update */
+  string  train_file;             /*< the training file */
+  string  holdout_file;           /*< the develop file */
+  string  algorithm;              /*< the algorithm */
+  string  model_name;             /*< the model name */
+  int     rare_feature_threshold; /*< specify the max number of rare feature */
+  int     max_iter;               /*< the iteration number */
 };
 
 struct TestOptions {
-    string test_file;               /*< test file path */
-    string model_file;              /*< model file path. in test mode, config is
-                                     *< writen in model */
+  string test_file;         /*< test file path */
+  string model_file;        /*< model file path. in test mode, config is
+                             *< writen in model */
 };
 
 struct FeatureOptions {
-    bool use_postag;                /*< use postag feature, not implemented */
-    bool use_postag_unigram;        /*< use postag unigram feature, not implemented */
-    bool use_postag_bigram;         /*< use postag bigram feature, not implemented */
-    bool use_postag_chars;          // template: pos+chars
-
-    // dependency feature group
-    bool use_dependency;            /*< use dependency feature */
-    bool use_dependency_unigram;    /*< use dependency unigram feature */
-    bool use_dependency_bigram;     /*< use dependency bigram feature */
-    bool use_dependency_surrounding;/*< use dependency surrounding feature */
-    bool use_dependency_between;    /*< use dependency between features */
-
-    bool use_sibling;               /*< use sibling feature */
-    bool use_sibling_basic;         /*< use sibling basic feature */
-    bool use_sibling_linear;        /*< use sibling linear feature */
-
-    bool use_grand;                 /*< use grand features, not implemented */
-    bool use_grand_basic;
-    bool use_grand_linear;
-
-    // sth weired
-    bool use_last_sibling;
-    bool use_no_grand;
-
-    // automaticall calculate
-    bool use_distance_in_features;  /*< use distance, always true */
-    bool use_unlabeled_dependency;  /*< equals to !model.labeled and use_dependency */
-    bool use_labeled_dependency;    /*< equals to model.labeled and use_dependency */
-    bool use_unlabeled_sibling;     /*< equals to !model.labeled and use_sibling */
-    bool use_labeled_sibling;       /*< equals to model.labeled and use_sibling */
-    bool use_unlabeled_grand;       /*< equals to !model.labeled and use_grand */
-    bool use_labeled_grand;         /*< equals to model.labeled and use_grand */
-
-    bool use_lemma;
-    bool use_coarse_postag;
+  bool use_postag;            /*< use postag feature, not implemented */
+  bool use_postag_unigram;    /*< use postag unigram feature, not implemented */
+  bool use_postag_bigram;     /*< use postag bigram feature, not implemented */
+  bool use_postag_chars;      // template: pos+chars
+
+  // dependency feature group
+  bool use_dependency;            /*< use dependency feature */
+  bool use_dependency_unigram;    /*< use dependency unigram feature */
+  bool use_dependency_bigram;     /*< use dependency bigram feature */
+  bool use_dependency_surrounding;/*< use dependency surrounding feature */
+  bool use_dependency_between;    /*< use dependency between features */
+
+  bool use_sibling;               /*< use sibling feature */
+  bool use_sibling_basic;         /*< use sibling basic feature */
+  bool use_sibling_linear;        /*< use sibling linear feature */
+
+  bool use_grand;                 /*< use grand features, not implemented */
+  bool use_grand_basic;
+  bool use_grand_linear;
+
+  // sth weired
+  bool use_last_sibling;
+  bool use_no_grand;
+
+  // automaticall calculate
+  bool use_distance_in_features;  /*< use distance, always true */
+  bool use_unlabeled_dependency;  /*< equals to !model.labeled and use_dependency */
+  bool use_labeled_dependency;    /*< equals to model.labeled and use_dependency */
+  bool use_unlabeled_sibling;     /*< equals to !model.labeled and use_sibling */
+  bool use_labeled_sibling;       /*< equals to model.labeled and use_sibling */
+  bool use_unlabeled_grand;       /*< equals to !model.labeled and use_grand */
+  bool use_labeled_grand;         /*< equals to model.labeled and use_grand */
+
+  bool use_lemma;
+  bool use_coarse_postag;
 
 };
 
 struct ModelOptions {
-    bool    labeled;                /*< specify use label */
-    string  decoder_name;           /*< the training order */
-    int     display_interval;       /*< the display interval */
+  bool    labeled;            /*< specify use label */
+  string  decoder_name;       /*< the training order */
+  int     display_interval;   /*< the display interval */
 };
 
 // declear the global options
-extern ModelOptions     model_opt;
-extern TrainOptions     train_opt;
-extern TestOptions      test_opt;
+extern ModelOptions   model_opt;
+extern TrainOptions   train_opt;
+extern TestOptions    test_opt;
 extern FeatureOptions   feat_opt;
 
-}       //  end for namespace parser
-}       //  end for namespace ltp
+}     //  end for namespace parser
+}     //  end for namespace ltp
 
-
-#endif  //  end for __OPTIONS_H__
+#endif  //  end for __LTP_PARSER_OPTIONS_H__
diff --git a/src/parser/parameters.h b/src/parser/parameters.h
index 861dbc8cc..59dd3a5eb 100644
--- a/src/parser/parameters.h
+++ b/src/parser/parameters.h
@@ -1,5 +1,5 @@
-#ifndef __PARAMETERS_H__
-#define __PARAMETERS_H__
+#ifndef __LTP_PARSER_PARAMETERS_H__
+#define __LTP_PARSER_PARAMETERS_H__
 
 #include "sparsevec.h"
 #include "featurevec.h"
@@ -11,156 +11,156 @@ using namespace ltp::math;
 
 class Parameters {
 public:
-    int _dim;
-    double * _W;
-    double * _W_sum;
-    int *    _W_time;
-
-    Parameters() :
-        _dim(0),
-        _W(0),
-        _W_sum(0),
-        _W_time(0) {}
-
-    ~Parameters() {
-        dealloc();
+  int _dim;
+  double * _W;
+  double * _W_sum;
+  int *    _W_time;
+
+  Parameters() :
+    _dim(0),
+    _W(0),
+    _W_sum(0),
+    _W_time(0) {}
+
+  ~Parameters() {
+    dealloc();
+  }
+
+  void realloc(int dim) {
+    dealloc();
+    _dim = dim;
+
+    if (dim > 0) {
+      _W      = new double[dim];
+      _W_sum  = new double[dim];
+      _W_time = new int[dim];
     }
 
-    void realloc(int dim) {
-        dealloc();
-        _dim = dim;
-
-        if (dim > 0) {
-            _W      = new double[dim];
-            _W_sum  = new double[dim];
-            _W_time = new int[dim];
-        }
-
-        for (int i = 0; i < dim; ++ i) {
-            _W[i]       = 0;
-            _W_sum[i]   = 0;
-            _W_time[i]  = 0;
-        }
+    for (int i = 0; i < dim; ++ i) {
+      _W[i]       = 0;
+      _W_sum[i]   = 0;
+      _W_time[i]  = 0;
     }
-
-    void dealloc() {
-        if (_W && (_W == _W_sum)) {
-            delete [](_W);
-            _W = 0;
-            _W_sum = 0;
-        } else {
-            if (_W) {
-                delete [](_W);
-                _W = 0;
-            }
-            if (_W_sum) {
-                delete [](_W_sum);
-                _W_sum = 0;
-            }
-        }
-        if (_W_time) {
-            delete [](_W_time);
-            _W_time = 0;
-        }
+  }
+
+  void dealloc() {
+    if (_W && (_W == _W_sum)) {
+      delete [](_W);
+      _W = 0;
+      _W_sum = 0;
+    } else {
+      if (_W) {
+        delete [](_W);
+        _W = 0;
+      }
+      if (_W_sum) {
+        delete [](_W_sum);
+        _W_sum = 0;
+      }
     }
-
-    void add(const SparseVec & vec, int now, double scale = 1.) {
-        for (SparseVec::const_iterator itx = vec.begin();
-                itx != vec.end();
-                itx ++) {
-            int idx = itx->first;
-            int elapsed = now - _W_time[idx];
-            double upd = scale * itx->second;
-            double cur_val = _W[idx];
-
-            _W[idx]         = cur_val + upd;
-            _W_sum[idx]    += elapsed * cur_val + upd;
-            _W_time[idx]    = now;
-        }
+    if (_W_time) {
+      delete [](_W_time);
+      _W_time = 0;
     }
-
-    double dot(const SparseVec & vec, bool use_avg = false) const {
-        const double * const p = (use_avg ? _W_sum : _W);
-        double ret = 0.;
-        for (SparseVec::const_iterator itx = vec.begin();
-                itx != vec.end();
-                ++ itx) {
-            ret += p[itx->first] * itx->second;
-        }
-        return ret;
+  }
+
+  void add(const SparseVec & vec, int now, double scale = 1.) {
+    for (SparseVec::const_iterator itx = vec.begin();
+        itx != vec.end();
+        ++ itx) {
+      int idx = itx->first;
+      int elapsed = now - _W_time[idx];
+      double upd = scale * itx->second;
+      double cur_val = _W[idx];
+
+      _W[idx]       = cur_val + upd;
+      _W_sum[idx]  += elapsed * cur_val + upd;
+      _W_time[idx]  = now;
     }
-
-    double dot(const FeatureVector * vec, bool use_avg = false) const {
-        const double * const p = (use_avg ? _W_sum : _W);
-        double ret = 0.;
-        for (int i = 0; i < vec->n; ++ i) {
-            if (vec->val) {
-                ret += p[vec->idx[i] + vec->loff] * vec->val[i];
-            } else {
-                ret += p[vec->idx[i] + vec->loff];
-            }
-        }
-        return ret;
+  }
+
+  double dot(const SparseVec & vec, bool use_avg = false) const {
+    const double * const p = (use_avg ? _W_sum : _W);
+    double ret = 0.;
+    for (SparseVec::const_iterator itx = vec.begin();
+        itx != vec.end();
+        ++ itx) {
+      ret += p[itx->first] * itx->second;
     }
-    double dot(const int idx,bool use_avg=false) const {
-        const double * const p= (use_avg ? _W_sum : _W);
-        return p[idx];
+    return ret;
+  }
+
+  double dot(const FeatureVector * vec, bool use_avg = false) const {
+    const double * const p = (use_avg ? _W_sum : _W);
+    double ret = 0.;
+    for (int i = 0; i < vec->n; ++ i) {
+      if (vec->val) {
+        ret += p[vec->idx[i] + vec->loff] * vec->val[i];
+      } else {
+        ret += p[vec->idx[i] + vec->loff];
+      }
     }
-
-    void str(ostream& out, int width = 10) {
-        out << "\t";
-        for (int i = 0; i < width; ++ i) {
-            out << "[" << i << "]\t";
-        }
-        out << endl;
-        for (int i = 0; i < _dim; ++ i) {
-            if (i % width == 0) {
-                out << "[" << i << "-" << (i / width + 1)  * width - 1 << "]\t";
-            }
-            out << _W[i] << "\t";
-            if ((i + 1) % width == 0) {
-                out << endl;
-            }
-        }
+    return ret;
+  }
+  double dot(const int idx,bool use_avg=false) const {
+    const double * const p= (use_avg ? _W_sum : _W);
+    return p[idx];
+  }
+
+  void str(ostream& out, int width = 10) {
+    out << "\t";
+    for (int i = 0; i < width; ++ i) {
+      out << "[" << i << "]\t";
+    }
+    out << endl;
+    for (int i = 0; i < _dim; ++ i) {
+      if (i % width == 0) {
+        out << "[" << i << "-" << (i / width + 1)  * width - 1 << "]\t";
+      }
+      out << _W[i] << "\t";
+      if ((i + 1) % width == 0) {
         out << endl;
+      }
     }
+    out << endl;
+  }
 
-    void flush(int now) {
-        for(int i = 0; i < _dim; ++i) {
-            _W_sum[i] += (now - _W_time[i]) * _W[i];
-            _W_time[i] = now;
-        }
+  void flush(int now) {
+    for(int i = 0; i < _dim; ++i) {
+      _W_sum[i] += (now - _W_time[i]) * _W[i];
+      _W_time[i] = now;
     }
+  }
+
+  void dump(ostream & out, bool use_avg = true) {
+    const double * p = (use_avg ? _W_sum : _W);
+    char chunk[16] = {'p', 'a', 'r', 'a', 'm', 0};
+    out.write(chunk, 16);
+    out.write(reinterpret_cast<const char *>(&_dim), sizeof(int));
+    if (_dim > 0) {
+      out.write(reinterpret_cast<const char *>(p), sizeof(double) * _dim);
+    }
+  }
 
-    void dump(ostream & out, bool use_avg = true) {
-        const double * p = (use_avg ? _W_sum : _W);
-        char chunk[16] = {'p', 'a', 'r', 'a', 'm', 0};
-        out.write(chunk, 16);
-        out.write(reinterpret_cast<const char *>(&_dim), sizeof(int));
-        if (_dim > 0) {
-            out.write(reinterpret_cast<const char *>(p), sizeof(double) * _dim);
-        }
+  bool load(istream & in) {
+    char chunk[16];
+    in.read(chunk, 16);
+    if (strcmp(chunk, "param")) {
+      return false;
     }
 
-    bool load(istream & in) {
-        char chunk[16];
-        in.read(chunk, 16);
-        if (strcmp(chunk, "param")) {
-            return false;
-        }
-
-        in.read(reinterpret_cast<char *>(&_dim), sizeof(int));
-        if (_dim > 0) {
-            _W = new double[_dim];
-            in.read(reinterpret_cast<char *>(_W), sizeof(double) * _dim);
-            _W_sum = _W;
-        }
-
-        return true;
+    in.read(reinterpret_cast<char *>(&_dim), sizeof(int));
+    if (_dim > 0) {
+      _W = new double[_dim];
+      in.read(reinterpret_cast<char *>(_W), sizeof(double) * _dim);
+      _W_sum = _W;
     }
+
+    return true;
+  }
 };
 
 }   //  end for namespace parser
 }   //  end for namespace ltp
 
-#endif  //  end for __PARAMETERS_H__
+#endif  //  end for __LTP_PARSER_PARAMETERS_H__
diff --git a/src/parser/parser.cpp b/src/parser/parser.cpp
index 59d6ebc20..c753d6372 100644
--- a/src/parser/parser.cpp
+++ b/src/parser/parser.cpp
@@ -15,1216 +15,1349 @@
 namespace ltp {
 namespace parser {
 
-Parser::Parser() {
-    init_opt();
+Parser::Parser() :
+  __TRAIN__(false),
+  __TEST__(false),
+  model(0),
+  decoder(0) {
+  init_opt();
 }
 
-Parser::Parser(ConfigParser & cfg) {
-    init_opt();
-    parse_cfg(cfg);
+Parser::Parser(ConfigParser & cfg) :
+  __TRAIN__(false),
+  __TEST__(false),
+  model(0),
+  decoder(0) {
+  init_opt();
+  parse_cfg(cfg);
 }
 
 Parser::~Parser() {
-    if (decoder) {
-        delete decoder;
-    }
+  if (decoder) {
+    delete decoder;
+  }
+
+  if (model) {
+    delete model;
+  }
 
-    if (model) {
-        delete model;
+  for (int i = 0; i < train_dat.size(); ++ i) {
+    if (train_dat[i]) {
+      delete train_dat[i];
     }
+  }
 }
 
-void Parser::init_opt() {
-    model_opt.labeled           = false;
-    model_opt.decoder_name      = "1o";
-    model_opt.display_interval  = 1000;
+void
+Parser::init_opt() {
+  model_opt.labeled           = false;
+  model_opt.decoder_name      = "1o";
+  model_opt.display_interval  = 1000;
+
+  train_opt.train_file              = "";
+  train_opt.holdout_file            = "";
+  train_opt.max_iter                = 10;
+  train_opt.algorithm               = "pa";
+  train_opt.model_name              = "";
+  train_opt.rare_feature_threshold  = 0;
+
+  test_opt.test_file  = "";
+  test_opt.model_file = "";
+
+  feat_opt.use_postag                 = false;
+  feat_opt.use_postag_unigram         = false;
+  feat_opt.use_postag_bigram          = false;
+
+  feat_opt.use_dependency             = false;
+  feat_opt.use_dependency_unigram     = false;
+  feat_opt.use_dependency_bigram      = false;
+  feat_opt.use_dependency_surrounding = false;
+  feat_opt.use_dependency_between     = false;
+
+  feat_opt.use_sibling                = false;
+  feat_opt.use_sibling_basic          = false;
+  feat_opt.use_sibling_linear         = false;
+
+  feat_opt.use_grand                  = false;
+  feat_opt.use_grand_basic            = false;
+  feat_opt.use_grand_linear           = false;
+
+  feat_opt.use_last_sibling           = false;
+  feat_opt.use_no_grand               = false;
+  feat_opt.use_distance_in_features   = true;
+}
 
-    train_opt.train_file        = "";
-    train_opt.holdout_file      = "";
-    train_opt.max_iter          = 10;
-    train_opt.algorithm         = "pa";
-    train_opt.model_name        = "";
+Model *
+Parser::erase_rare_features(const int * feature_group_updated_time) {
+  Model * new_model = new Model;
 
-    test_opt.test_file  = "";
-    test_opt.model_file = "";
+  for(int i = 0; i < model->deprels.size(); ++ i) {
+    const char * key = model-> deprels.at(i);
+    new_model->deprels.push(key);
+  }
 
-    feat_opt.use_postag                 =   false;
-    feat_opt.use_postag_unigram         =   false;
-    feat_opt.use_postag_bigram          =   false;
+  for(int i = 0; i< model->postags.size(); ++ i) {
+    const char * key = model -> postags.at(i);
+    new_model->postags.push(key);
+  }
 
-    feat_opt.use_dependency             =   false;
-    feat_opt.use_dependency_unigram     =   false;
-    feat_opt.use_dependency_bigram      =   false;
-    feat_opt.use_dependency_surrounding =   false;
-    feat_opt.use_dependency_between     =   false;
+  build_feature_space_truncate(new_model);
 
-    feat_opt.use_sibling                =   false;
-    feat_opt.use_sibling_basic          =   false;
-    feat_opt.use_sibling_linear         =   false;
+  if(feat_opt.use_dependency) {//DEP
+    copy_featurespace(new_model,
+                      FeatureSpace::DEP,
+                      feature_group_updated_time);
+  }
 
-    feat_opt.use_grand                  =   false;
-    feat_opt.use_grand_basic            =   false;
-    feat_opt.use_grand_linear           =   false;
+  if(feat_opt.use_sibling) {//SIB
+    copy_featurespace(new_model,
+                      FeatureSpace::SIB,
+                      feature_group_updated_time);
+  }
 
-    feat_opt.use_last_sibling           =   false;
-    feat_opt.use_no_grand               =   false;
-    feat_opt.use_distance_in_features   =   true;
+  if(feat_opt.use_grand) {//GRD
+    copy_featurespace(new_model,
+                      FeatureSpace::GRD,
+                      feature_group_updated_time);
+  }
 
-}
+  TRACE_LOG("Scanning old features space, building new feature space is done");
 
-Model * Parser::truncate() {
-    // main process of performing model truncation
-    // this process can mainly be divied into 3 steps:
-    //
-    //  [1] foreach group in featurespace: truncate featurespace of group;
-    //  [2] reset the offset for the model;
-    //  [3] foreach group in featurespace: build paramter of group;
-    //
-    Model * new_model = new Model;
-    for(int i = 0 ;i < model -> deprels.size(); ++i) {
-        const char * key = model-> deprels.at(i);
-        new_model->deprels.push(key);
-    }
+  new_model->space.set_offset_truncate();
+  TRACE_LOG("Setting offset for each collection is done");
 
-    for(int i=0 ; i< model->postags.size(); ++i) {
-        const char * key = model -> postags.at(i);
-        new_model->postags.push(key);
-    }
+  new_model->param.realloc(new_model->dim());
+  TRACE_LOG("Parameter dimension of new model is [%d]",new_model->space.dim());
 
-    build_feature_space_truncate(new_model);
+  if(feat_opt.use_dependency) {//DEP
+    copy_parameters(new_model, FeatureSpace::DEP);
+  }
 
-    if(feat_opt.use_dependency) {//DEP
-        copy_featurespace(new_model,FeatureSpace::DEP);
-    }
+  if(feat_opt.use_sibling) {//SIB
+    copy_parameters(new_model, FeatureSpace::SIB);
+  }
 
-    if(feat_opt.use_sibling) {//SIB
-        copy_featurespace(new_model,FeatureSpace::SIB);
-    }
-
-    if(feat_opt.use_grand) {//GRD
-        copy_featurespace(new_model,FeatureSpace::GRD);
-    }
-
-    TRACE_LOG("Scanning old features space, building new feature space is done");
-    new_model->space.set_offset_truncate();
-    TRACE_LOG("Setting offset for each collection is done");
+  if(feat_opt.use_grand) {//GRD
+    copy_parameters(new_model, FeatureSpace::GRD);
+  }
 
-    new_model->param.realloc(new_model->dim());
-    TRACE_LOG("Parameter dimension of new model is [%d]",new_model->space.dim());
+  TRACE_LOG("Building new model is done");
+  return new_model;
+}
 
-    if(feat_opt.use_dependency) {//DEP
-        copy_parameters(new_model,FeatureSpace::DEP);
+void
+Parser::copy_featurespace(Model * new_model,
+                          int gid,
+                          const int * feature_group_updated_time) {
+  // perform the feature space truncation
+  // the stategy here is travel through the old feature space, test a group of
+  // feature whether their are all zero. if all zero detected, don't insert it
+  // into new feature space.
+
+  int L = model->num_deprels();
+  for (FeatureSpaceIterator itx = model->space.begin(gid); !itx.end(); ++ itx) {
+    const char * key = itx.key();
+    int tid = itx.tid();
+    int id = model->space.index(gid, tid, key);
+    bool flag = false;
+
+    for (int l = 0; l < L; ++ l) {
+      double p = model -> param.dot(id+l);
+      if(p != 0.) {
+        flag=true;
+      }
     }
 
-    if(feat_opt.use_sibling) {//SIB
-        copy_parameters(new_model,FeatureSpace::SIB);
+    if(!flag) {
+      continue;
     }
 
-    if(feat_opt.use_grand) {//GRD
-        copy_parameters(new_model,FeatureSpace::GRD);
+    int idx = id / L;
+    if(feature_group_updated_time
+       && (feature_group_updated_time[idx] < train_opt.rare_feature_threshold)) {
+      continue;
     }
 
-    TRACE_LOG("Building new model is done");
-    return new_model;
+    new_model->space.retrieve(gid, tid, key, true);
+  }
 }
 
-void Parser::copy_featurespace(Model * new_model, int gid) {
-    // perform the feature space truncation
-    // the stategy here is travel through the old feature space, test a group of
-    // feature whether their are all zero. if all zero detected, don't insert it
-    // into new feature space.
-    for (FeatureSpaceIterator itx = model->space.begin(gid); !itx.end(); ++ itx) {
-        const char * key = itx.key();
-        int tid = itx.tid();
-        int id = model->space.index(gid, tid, key);
-        bool flag = false;
-        int L = model-> num_deprels();
-
-        for (int l = 0; l < L; ++ l) {
-            double p = model -> param.dot(id+l);
-            if(p != 0.) {
-                flag=true;
-            }
-        }
+void
+Parser::copy_parameters(Model * new_model, int gid) {
+  // perform the parameter trunction
+  // the prerequiest is feature space of new model is already built.
+  // the process travel through the feature space of new model and retrieve
+  // the key in old feature space, then preform the copy operation.
+  int L = model-> num_deprels();
 
-        if(!flag) {
-            continue;
-        }
+  for (FeatureSpaceIterator itx = new_model->space.begin(gid); !itx.end(); ++itx) {
+    const char * key = itx.key();
+    int tid = itx.tid();
 
-        new_model->space.retrieve(gid, tid, key, true);
-    }
-}
-
-void Parser::copy_parameters(Model * new_model, int gid) {
-    // perform the parameter trunction
-    // the prerequiest is feature space of new model is already built.
-    // the process travel through the feature space of new model and retrieve
-    // the key in old feature space, then preform the copy operation.
-    for (FeatureSpaceIterator itx = new_model->space.begin(gid); !itx.end(); ++itx) {
-        const char * key = itx.key();
-        int tid = itx.tid();
-
-        int old_id = model->space.index(gid, tid, key);
-        int new_id = new_model->space.index(gid, tid, key);
+    int old_id = model->space.index(gid, tid, key);
+    int new_id = new_model->space.index(gid, tid, key);
 
-        int L = model-> num_deprels();
-
-        for (int l = 0; l < L; ++l) {
-            new_model->param._W[new_id + l]     = model->param._W[old_id+l];
-            new_model->param._W_sum[new_id + l] = model->param._W_sum[old_id+l];
-        }
+    for (int l = 0; l < L; ++l) {
+      new_model->param._W[new_id + l]     = model->param._W[old_id+l];
+      new_model->param._W_sum[new_id + l] = model->param._W_sum[old_id+l];
     }
+  }
 }
 
-bool Parser::parse_cfg(utility::ConfigParser & cfg) {
-    string  strbuf;
-    int     intbuf;
+bool
+Parser::parse_cfg(utility::ConfigParser & cfg) {
+  string  strbuf;
+  int   intbuf;
 
-    if (cfg.has_section("model")) {
-        if (cfg.get_integer("model", "labeled", intbuf)) {
-            model_opt.labeled = (intbuf == 1);
-        }
-        if (cfg.get("model", "decoder-name", strbuf)) {
-            model_opt.decoder_name = strbuf;
-        } else {
-            WARNING_LOG("decoder-name is not configed, [1o] is set as default.");
-        }
+  if (cfg.has_section("model")) {
+    if (cfg.get_integer("model", "labeled", intbuf)) {
+      model_opt.labeled = (intbuf == 1);
     }
+    if (cfg.get("model", "decoder-name", strbuf)) {
+      model_opt.decoder_name = strbuf;
+    } else {
+      WARNING_LOG("decoder-name is not configed, [1o] is set as default.");
+    }
+  }
 
-    __TRAIN__ = false;
-
-    if (cfg.has_section("train")) {
-        TRACE_LOG("train model specified.");
-        __TRAIN__ = true;
-
-        if (cfg.get("train", "train-file", strbuf)) {
-            train_opt.train_file = strbuf;
-        } else {
-            ERROR_LOG("train-file config item is not set.");
-            return false;
-        }   //  end for if (cfg.get("train", "train-file", strbuf))
-
-        if (cfg.get("train", "holdout-file", strbuf)) {
-            train_opt.holdout_file = strbuf;
-        } else {
-            ERROR_LOG("holdout-file config item is not set.");
-            return false;
-        }
-
-        if (cfg.get("train", "algorithm", strbuf)) {
-            train_opt.algorithm = strbuf;
-        } else {
-            WARNING_LOG("algorithm is not configed, [PA] is set as default.");
-        }
-
-        train_opt.model_name = train_opt.train_file + "." + train_opt.algorithm + ".model";
-        if (cfg.get("train", "model-name", strbuf)) {
-            train_opt.model_name = strbuf;
-        } else {
-            WARNING_LOG("model name is not configed, [%s] is set as default",
-                    train_opt.model_name.c_str());
-        }
-
-        if (cfg.get_integer("train", "max-iter", intbuf)) {
-            train_opt.max_iter = intbuf;
-        } else {
-            WARNING_LOG("max-iter is not configed, [10] is set as default.");
-        }
-    }   //  end for cfg.has_section("train")
-
-    __TEST__ = false;
+  __TRAIN__ = false;
 
-    if (cfg.has_section("test")) {
-        __TEST__ = true;
+  if (cfg.has_section("train")) {
+    TRACE_LOG("train model specified.");
+    __TRAIN__ = true;
 
-        if (cfg.get("test", "test-file", strbuf)) {
-            test_opt.test_file = strbuf;
-        } else {
-            ERROR_LOG("test-file config item is not set.");
-            return false;
-        }   //  end for if (cfg.get("train", "train-file", strbuf))
+    if (cfg.get("train", "train-file", strbuf)) {
+      train_opt.train_file = strbuf;
+    } else {
+      ERROR_LOG("train-file config item is not set.");
+      return false;
+    }   //  end for if (cfg.get("train", "train-file", strbuf))
 
-        if (cfg.get("test", "model-file", strbuf)) {
-            test_opt.model_file = strbuf;
-        } else {
-            ERROR_LOG("model-file config item is not set.");
-            return false;
-        }
+    if (cfg.get("train", "holdout-file", strbuf)) {
+      train_opt.holdout_file = strbuf;
+    } else {
+      ERROR_LOG("holdout-file config item is not set.");
+      return false;
     }
 
-    if (cfg.has_section("feature")) {
-        if (cfg.get_integer("feature", "use-postag", intbuf)) {
-            feat_opt.use_postag = (intbuf == 1);
-        }
+    if (cfg.get("train", "algorithm", strbuf)) {
+      train_opt.algorithm = strbuf;
+    } else {
+      WARNING_LOG("algorithm is not configed, [PA] is set as default.");
+    }
 
-        if (cfg.get_integer("feature", "use-postag-unigram", intbuf)) {
-            feat_opt.use_postag_unigram = (intbuf == 1);
-        }
+    train_opt.model_name = (train_opt.train_file
+                            + "."
+                            + train_opt.algorithm
+                            + ".model");
+    if (cfg.get("train", "model-name", strbuf)) {
+      train_opt.model_name = strbuf;
+    } else {
+      WARNING_LOG("model name is not configed, [%s] is set as default",
+                  train_opt.model_name.c_str());
+    }
 
-        if (cfg.get_integer("feature", "use-postag-bigram", intbuf)) {
-            feat_opt.use_postag_bigram = (intbuf == 1);
-        }
+    if (cfg.get_integer("train", "rare-feature-threshold", intbuf)) {
+      train_opt.rare_feature_threshold = intbuf;
+    } else {
+      WARNING_LOG("rare feature's threshold is not configed, use 0 as default");
+    }
 
-        if (cfg.get_integer("feature", "use-dependency", intbuf)) {
-            feat_opt.use_dependency = (intbuf == 1);
-        }
+    if (cfg.get_integer("train", "max-iter", intbuf)) {
+      train_opt.max_iter = intbuf;
+    } else {
+      WARNING_LOG("max-iter is not configed, [10] is set as default.");
+    }
+  }   //  end for cfg.has_section("train")
 
-        if (cfg.get_integer("feature", "use-dependency-unigram", intbuf)) {
-            feat_opt.use_dependency_unigram = (intbuf == 1);
-        }
+  __TEST__ = false;
 
-        if (cfg.get_integer("feature", "use-dependency-bigram", intbuf)) {
-            feat_opt.use_dependency_bigram = (intbuf == 1);
-        }
+  if (cfg.has_section("test")) {
+    __TEST__ = true;
 
-        if (cfg.get_integer("feature", "use-dependency-surrounding", intbuf)) {
-            feat_opt.use_dependency_surrounding = (intbuf == 1);
-        }
+    if (cfg.get("test", "test-file", strbuf)) {
+      test_opt.test_file = strbuf;
+    } else {
+      ERROR_LOG("test-file config item is not set.");
+      return false;
+    }   //  end for if (cfg.get("train", "train-file", strbuf))
 
-        if (cfg.get_integer("feature", "use-dependency-between", intbuf)) {
-            feat_opt.use_dependency_between = (intbuf == 1);
-        }
+    if (cfg.get("test", "model-file", strbuf)) {
+      test_opt.model_file = strbuf;
+    } else {
+      ERROR_LOG("model-file config item is not set.");
+      return false;
+    }
+  }
 
-        if (cfg.get_integer("feature", "use-sibling", intbuf)) {
-            feat_opt.use_sibling = (intbuf == 1);
-        }
+  if (cfg.has_section("feature")) {
+    if (cfg.get_integer("feature", "use-postag", intbuf)) {
+      feat_opt.use_postag = (intbuf == 1);
+    }
 
-        if (cfg.get_integer("feature", "use-sibling-basic", intbuf)) {
-            feat_opt.use_sibling_basic = (intbuf == 1);
-        }
+    if (cfg.get_integer("feature", "use-postag-unigram", intbuf)) {
+      feat_opt.use_postag_unigram = (intbuf == 1);
+    }
 
-        if (cfg.get_integer("feature", "use-sibling-linear", intbuf)) {
-            feat_opt.use_sibling_linear = (intbuf == 1);
-        }
+    if (cfg.get_integer("feature", "use-postag-bigram", intbuf)) {
+      feat_opt.use_postag_bigram = (intbuf == 1);
+    }
 
-        if (cfg.get_integer("feature", "use-grand", intbuf)) {
-            feat_opt.use_grand = (intbuf == 1);
-        }
+    if (cfg.get_integer("feature", "use-dependency", intbuf)) {
+      feat_opt.use_dependency = (intbuf == 1);
+    }
 
-        if (cfg.get_integer("feature", "use-grand-basic", intbuf)) {
-            feat_opt.use_grand_basic = (intbuf == 1);
-        }
+    if (cfg.get_integer("feature", "use-dependency-unigram", intbuf)) {
+      feat_opt.use_dependency_unigram = (intbuf == 1);
+    }
 
-        if (cfg.get_integer("feature", "use-grand-linear", intbuf)) {
-            feat_opt.use_grand_linear = (intbuf == 1);
-        }
+    if (cfg.get_integer("feature", "use-dependency-bigram", intbuf)) {
+      feat_opt.use_dependency_bigram = (intbuf == 1);
+    }
 
+    if (cfg.get_integer("feature", "use-dependency-surrounding", intbuf)) {
+      feat_opt.use_dependency_surrounding = (intbuf == 1);
     }
 
-    if (model_opt.decoder_name == "1o") {
-        if (feat_opt.use_sibling) {
-            WARNING_LOG("Sibling features should not be configed "
-                    "with 1st-order decoder.");
-            TRACE_LOG("Sibling features is inactived.");
-            feat_opt.use_sibling = false;
-        }
+    if (cfg.get_integer("feature", "use-dependency-between", intbuf)) {
+      feat_opt.use_dependency_between = (intbuf == 1);
+    }
 
-        if (feat_opt.use_grand) {
-            WARNING_LOG("Grandchild features should not be configed "
-                    "with 1st-order decoder.");
-            TRACE_LOG("Grandchild features is inactived.");
-            feat_opt.use_grand = false;
-        }
-    } else if (model_opt.decoder_name == "2o-sib") {
-        if (feat_opt.use_grand) {
-            WARNING_LOG("Grandchild features should not be configed "
-                    "with 2nd-order-sibling decoder.");
-            TRACE_LOG("Grandchild features is inactived.");
-            feat_opt.use_grand = false;
-        }
+    if (cfg.get_integer("feature", "use-sibling", intbuf)) {
+      feat_opt.use_sibling = (intbuf == 1);
     }
 
-    // detrieve dependency type from configuration
-    feat_opt.use_unlabeled_dependency = (model_opt.labeled == false &&
-            feat_opt.use_dependency);
+    if (cfg.get_integer("feature", "use-sibling-basic", intbuf)) {
+      feat_opt.use_sibling_basic = (intbuf == 1);
+    }
 
-    feat_opt.use_labeled_dependency = (model_opt.labeled == true &&
-            feat_opt.use_dependency);
+    if (cfg.get_integer("feature", "use-sibling-linear", intbuf)) {
+      feat_opt.use_sibling_linear = (intbuf == 1);
+    }
 
-    // detrieve sibling type from configuration
-    feat_opt.use_unlabeled_sibling = (model_opt.labeled == false &&
-            feat_opt.use_sibling);
+    if (cfg.get_integer("feature", "use-grand", intbuf)) {
+      feat_opt.use_grand = (intbuf == 1);
+    }
 
-    feat_opt.use_labeled_sibling = (model_opt.labeled == true &&
-            feat_opt.use_sibling);
+    if (cfg.get_integer("feature", "use-grand-basic", intbuf)) {
+      feat_opt.use_grand_basic = (intbuf == 1);
+    }
 
-    feat_opt.use_unlabeled_grand = (model_opt.labeled == false &&
-            feat_opt.use_grand);
+    if (cfg.get_integer("feature", "use-grand-linear", intbuf)) {
+      feat_opt.use_grand_linear = (intbuf == 1);
+    }
+  }
 
-    feat_opt.use_labeled_grand = (model_opt.labeled == true &&
-            feat_opt.use_grand);
+  // incompatible configuration check
+  if (model_opt.decoder_name == "1o") {
+    if (feat_opt.use_sibling) {
+      WARNING_LOG("Sibling features should not be configed "
+                  "with 1st-order decoder.");
+      TRACE_LOG("Sibling features is inactived.");
+      feat_opt.use_sibling = false;
+    }
 
-    return true;
+    if (feat_opt.use_grand) {
+      WARNING_LOG("Grandchild features should not be configed "
+                  "with 1st-order decoder.");
+      TRACE_LOG("Grandchild features is inactived.");
+      feat_opt.use_grand = false;
+    }
+  } else if (model_opt.decoder_name == "2o-sib") {
+    if (feat_opt.use_grand) {
+      WARNING_LOG("Grandchild features should not be configed "
+                   "with 2nd-order-sibling decoder.");
+      TRACE_LOG("Grandchild features is inactived.");
+      feat_opt.use_grand = false;
+    }
+  }
+
+  // detrieve dependency type from configuration
+  feat_opt.use_unlabeled_dependency = (model_opt.labeled == false
+                                       && feat_opt.use_dependency);
+  feat_opt.use_labeled_dependency   = (model_opt.labeled == true
+                                       && feat_opt.use_dependency);
+
+  // detrieve sibling type from configuration
+  feat_opt.use_unlabeled_sibling    = (model_opt.labeled == false
+                                       && feat_opt.use_sibling);
+  feat_opt.use_labeled_sibling      = (model_opt.labeled == true
+                                       && feat_opt.use_sibling);
+  feat_opt.use_unlabeled_grand      = (model_opt.labeled == false
+                                       && feat_opt.use_grand);
+  feat_opt.use_labeled_grand        = (model_opt.labeled == true
+                                       && feat_opt.use_grand);
+
+  return true;
 }
 
-void Parser::build_configuration(void) {
-    // build postags set, deprels set.
-    // map deprels from string to int when model_opt.labeled is configed.
-    // need to check if the model is initialized
+void
+Parser::build_configuration(void) {
+  // build postags set, deprels set.
+  // map deprels from string to int when model_opt.labeled is configed.
+  // need to check if the model is initialized
 
-    for (int i = 0; i < train_dat.size(); ++ i) {
-        int len = train_dat[i]->size();
+  for (int i = 0; i < train_dat.size(); ++ i) {
+    int len = train_dat[i]->size();
 
-        // if labeled is configured, init the deprelsidxs
-        if (model_opt.labeled) {
-            train_dat[i]->deprelsidx.resize(len);
-            train_dat[i]->predicted_deprelsidx.resize(len);
-        }
+    // if labeled is configured, init the deprelsidxs
+    if (model_opt.labeled) {
+      train_dat[i]->deprelsidx.resize(len);
+      train_dat[i]->predicted_deprelsidx.resize(len);
+    }
 
-        for (int j = 1; j < len; ++ j) {
-            model->postags.push(train_dat[i]->postags[j].c_str());
-            if (model_opt.labeled) {
-                int idx = -1;
-                idx = model->deprels.push(train_dat[i]->deprels[j].c_str());
-                train_dat[i]->deprelsidx[j] = idx;
-            }
-        }
+    for (int j = 1; j < len; ++ j) {
+      model->postags.push(train_dat[i]->postags[j].c_str());
+      if (model_opt.labeled) {
+        int idx = model->deprels.push(train_dat[i]->deprels[j].c_str());
+        train_dat[i]->deprelsidx[j] = idx;
+      }
     }
+  }
 }
 
-void Parser::build_feature_space(void) {
-    model->space.build_feature_space(model->num_deprels(), train_dat);
+void
+Parser::build_feature_space(void) {
+  model->space.build_feature_space(model->num_deprels(), train_dat);
 }   //  end for build_feature_space
 
-void Parser::build_feature_space_truncate(Model * m) {
-    m->space.build_feature_space_truncate(m->num_deprels());
+void
+Parser::build_feature_space_truncate(Model * m) {
+  m->space.build_feature_space_truncate(m->num_deprels());
 }
 
-void Parser::collect_unlabeled_features_of_one_instance(Instance * inst,
-        const vector<int> & heads,
-        SparseVec & vec ) {
+void
+Parser::collect_unlabeled_features_of_one_instance(Instance * inst,
+                                                   const vector<int> & heads,
+                                                   SparseVec & vec ) {
 
-    vec.zero();
-    if (feat_opt.use_dependency) {
-        for (treeutils::DEPIterator itx(heads); !itx.end(); ++ itx) {
-            int hid = itx.hid();
-            int cid = itx.cid();
+  vec.zero();
+  if (feat_opt.use_dependency) {
+    for (treeutils::DEPIterator itx(heads); !itx.end(); ++ itx) {
+      int hid = itx.hid();
+      int cid = itx.cid();
 
-            const FeatureVector * fv = inst->depu_features[hid][cid];
-            if (NULL == fv) {
-                continue;
-            }
+      const FeatureVector * fv = inst->depu_features[hid][cid];
+      if (NULL == fv) {
+        continue;
+      }
 
-            vec.add(fv->idx, fv->val, fv->n, 1.);
-        }
+      vec.add(fv->idx, fv->val, fv->n, 1.);
     }
-
-    if (feat_opt.use_sibling) {
-        for (treeutils::SIBIterator itx(heads, feat_opt.use_last_sibling); !itx.end(); ++ itx) {
-            int hid = itx.hid();
-            int cid = itx.cid();
-            int sid = itx.sid();
-
-            const FeatureVector * fv = inst->sibu_features[hid][cid][sid];
-            if (NULL == fv) {
-                continue;
-            }
-
-            vec.add(fv->idx, fv->val, fv->n, 1.);
-        }
+  }
+
+  if (feat_opt.use_sibling) {
+    for (treeutils::SIBIterator itx(heads, feat_opt.use_last_sibling);
+         !itx.end();
+         ++ itx) {
+      int hid = itx.hid();
+      int cid = itx.cid();
+      int sid = itx.sid();
+
+      const FeatureVector * fv = inst->sibu_features[hid][cid][sid];
+      if (NULL == fv) {
+        continue;
+      }
+
+      vec.add(fv->idx, fv->val, fv->n, 1.);
     }
+  }
+
+  if (feat_opt.use_grand) {
+    for (treeutils::GRDIterator itx(heads, feat_opt.use_no_grand);
+         !itx.end();
+         ++ itx) {
+      int hid = itx.hid();
+      int cid = itx.cid();
+      int gid = itx.gid();
+
+      const FeatureVector * fv = inst->grdu_features[hid][cid][gid];
+      if (NULL == fv) {
+        continue;
+      }
+
+      vec.add(fv->idx, fv->val, fv->n, 1.);
+    }
+  }
+}
 
-    if (feat_opt.use_grand) {
-        for (treeutils::GRDIterator itx(heads, feat_opt.use_no_grand); !itx.end(); ++ itx) {
-            int hid = itx.hid();
-            int cid = itx.cid();
-            int gid = itx.gid();
-
-            const FeatureVector * fv = inst->grdu_features[hid][cid][gid];
-            if (NULL == fv) {
-                continue;
-            }
+void
+Parser::collect_labeled_features_of_one_instance(Instance * inst,
+                                                 const vector<int> & heads,
+                                                 const vector<int> & deprelsidx,
+                                                 SparseVec & vec) {
+  vec.zero();
+  if (feat_opt.use_dependency) {
+    for (treeutils::DEPIterator itx(heads); !itx.end(); ++ itx) {
+      int hid = itx.hid();
+      int cid = itx.cid();
+      int relidx = deprelsidx[cid];
+
+      const FeatureVector * fv = inst->depl_features[hid][cid][relidx];
+      if (NULL == fv) {
+        continue;
+      }
+
+      vec.add(fv->idx, fv->val, fv->n, fv->loff, 1.);
+    }
+  }
+
+  if (feat_opt.use_sibling) {
+    for (treeutils::SIBIterator itx(heads, feat_opt.use_last_sibling);
+         !itx.end();
+         ++ itx) {
+      int hid = itx.hid();
+      int cid = itx.cid();
+      int sid = itx.sid();
+      int relidx = deprelsidx[cid];
+
+      const FeatureVector * fv = inst->sibl_features[hid][cid][sid][relidx];
+      if (NULL == fv) {
+        continue;
+      }
+
+      vec.add(fv->idx, fv->val, fv->n, fv->loff, 1.);
+    }
+  }
+
+  if (feat_opt.use_grand) {
+    for (treeutils::GRDIterator itx(heads, feat_opt.use_no_grand);
+         !itx.end();
+         ++ itx) {
+      int hid = itx.hid();
+      int cid = itx.cid();
+      int gid = itx.gid();
+      int relidx = deprelsidx[cid];
+
+      const FeatureVector * fv = inst->grdl_features[hid][cid][gid][relidx];
+      if (NULL == fv) {
+        continue;
+      }
+
+      vec.add(fv->idx, fv->val, fv->n, fv->loff, 1.);
+    }
+  }
+}
 
-            vec.add(fv->idx, fv->val, fv->n, 1.);
-        }
+void
+Parser::collect_features_of_one_instance(Instance * inst, bool gold) {
+  if (gold) {
+    if (!model_opt.labeled) {
+      collect_unlabeled_features_of_one_instance(inst,
+          inst->heads,
+          inst->features);
+    } else {
+      collect_labeled_features_of_one_instance(inst,
+          inst->heads,
+          inst->deprelsidx,
+          inst->features);
     }
+  } else {
+    if (!model_opt.labeled) {
+      collect_unlabeled_features_of_one_instance(inst,
+          inst->predicted_heads,
+          inst->predicted_features);
+    } else {
+      collect_labeled_features_of_one_instance(inst,
+          inst->predicted_heads,
+          inst->predicted_deprelsidx,
+          inst->predicted_features);
+    }
+  }
 }
 
-void Parser::collect_labeled_features_of_one_instance(Instance * inst,
-        const vector<int> & heads,
-        const vector<int> & deprelsidx,
-        SparseVec & vec) {
+bool
+Parser::read_instances(const char * filename, vector<Instance *> & dat) {
+  Instance * inst = NULL;
+  ifstream f(filename);
+  if (!f) {
+    return false;
+  }
 
-    vec.zero();
-    if (feat_opt.use_dependency) {
-        for (treeutils::DEPIterator itx(heads); !itx.end(); ++ itx) {
-            int hid = itx.hid();
-            int cid = itx.cid();
-            int relidx = deprelsidx[cid];
+  CoNLLReader reader(f);
 
-            const FeatureVector * fv = inst->depl_features[hid][cid][relidx];
-            if (NULL == fv) {
-                continue;
-            }
+  int num_inst = 0;
 
-            vec.add(fv->idx, fv->val, fv->n, fv->loff, 1.);
-        }
+  while ((inst = reader.next())) {
+    dat.push_back(inst);
+    ++ num_inst;
+
+    if (num_inst % model_opt.display_interval == 0) {
+      TRACE_LOG("Reading in [%d] instances.", num_inst);
     }
+  }
 
-    if (feat_opt.use_sibling) {
-        for (treeutils::SIBIterator itx(heads, feat_opt.use_last_sibling); !itx.end(); ++ itx) {
-            int hid = itx.hid();
-            int cid = itx.cid();
-            int sid = itx.sid();
-            int relidx = deprelsidx[cid];
-
-            const FeatureVector * fv = inst->sibl_features[hid][cid][sid][relidx];
-            if (NULL == fv) {
-                continue;
-            }
-
-            vec.add(fv->idx, fv->val, fv->n, fv->loff, 1.);
-        }
+  return true;
+}
+
+Decoder *
+Parser::build_decoder(void) {
+  Decoder * deco = NULL;
+  if (model_opt.decoder_name == "1o") {
+    if (!model_opt.labeled) {
+      deco = new Decoder1O();
+    } else {
+      deco = new Decoder1O(model->num_deprels());
     }
 
-    if (feat_opt.use_grand) {
-        for (treeutils::GRDIterator itx(heads, feat_opt.use_no_grand); !itx.end(); ++ itx) {
-            int hid = itx.hid();
-            int cid = itx.cid();
-            int gid = itx.gid();
-            int relidx = deprelsidx[cid];
-
-            const FeatureVector * fv = inst->grdl_features[hid][cid][gid][relidx];
-            if (NULL == fv) {
-                continue;
-            }
-
-            vec.add(fv->idx, fv->val, fv->n, fv->loff, 1.);
-        }
+  } else if (model_opt.decoder_name == "2o-sib") {
+    if (!model_opt.labeled) {
+      deco = new Decoder2O();
+    } else {
+      deco = new Decoder2O(model->num_deprels());
     }
-}
 
-void Parser::collect_features_of_one_instance(Instance * inst, bool gold) {
-    if (gold) {
-        if (!model_opt.labeled) {
-            collect_unlabeled_features_of_one_instance(inst,
-                    inst->heads,
-                    inst->features);
-        } else {
-            collect_labeled_features_of_one_instance(inst,
-                    inst->heads,
-                    inst->deprelsidx,
-                    inst->features);
-        }
+  } else if (model_opt.decoder_name == "2o-carreras") {
+    if (!model_opt.labeled) {
+      deco = new Decoder2OCarreras();
     } else {
-        if (!model_opt.labeled) {
-            collect_unlabeled_features_of_one_instance(inst,
-                    inst->predicted_heads,
-                    inst->predicted_features);
-        } else {
-            collect_labeled_features_of_one_instance(inst,
-                    inst->predicted_heads,
-                    inst->predicted_deprelsidx,
-                    inst->predicted_features);
-        }
+      deco = new Decoder2OCarreras(model->num_deprels());
     }
+  }
+  return deco;
 }
 
-bool Parser::read_instances(const char * filename, vector<Instance *> & dat) {
-    Instance * inst = NULL;
-    ifstream f(filename);
-    if (!f) {
-        return false;
-    }
+void
+Parser::extract_features(Instance * inst) {
+  int len = inst->size();
+  int L   = model->num_deprels();
+  // FeatureSpace & space = model->space;
 
-    CoNLLReader reader(f);
+  if (feat_opt.use_dependency) {
 
-    int num_inst = 0;
+    if (!model_opt.labeled) {
+      inst->depu_features.resize(len, len);
+      inst->depu_scores.resize(len, len);
 
-    while ((inst = reader.next())) {
-        dat.push_back(inst);
-        ++ num_inst;
+      inst->depu_features = 0;
+      inst->depu_scores = DOUBLE_NEG_INF;
+    } else {
+      inst->depl_features.resize(len, len, L);
+      inst->depl_scores.resize(len, len, L);
 
-        if (num_inst % model_opt.display_interval == 0) {
-            TRACE_LOG("Reading in [%d] instances.", num_inst);
-        }
+      inst->depl_features = 0;
+      inst->depl_scores = DOUBLE_NEG_INF;
     }
 
-    return true;
-}
+    vector< StringVec >  cache;
+    vector< int >   cache_again;
 
-Decoder * Parser::build_decoder(void) {
-    Decoder * deco;
-    if (model_opt.decoder_name == "1o") {
-        if (!model_opt.labeled) {
-            deco = new Decoder1O();
-        } else {
-            deco = new Decoder1O(model->num_deprels());
-        }
+    int N = DEPExtractor::num_templates();
 
-    } else if (model_opt.decoder_name == "2o-sib") {
-        if (!model_opt.labeled) {
-            deco = new Decoder2O();
-        } else {
-            deco = new Decoder2O(model->num_deprels());
+    cache.resize( N );
+
+    for (treeutils::DEPTreeSpaceIterator itx(len); !itx.end(); ++ itx) {
+      int hid = itx.hid();
+      int cid = itx.cid();
+
+      // here the self-implementated String Vector is little
+      // fasteer than the list<string>
+      for (int i = 0; i < N; ++ i) {
+        cache[i].clear();
+      }
+
+      DEPExtractor::extract2o(inst, hid, cid, cache);
+      cache_again.clear();
+
+      for (int tid = 0; tid < cache.size(); ++ tid) {
+        for (int itx = 0; itx < cache[tid].size(); ++ itx) {
+          int idx = model->space.index(FeatureSpace::DEP, tid, cache[tid][itx], 0);
+          // std::cout << "idx: " << idx << std::endl;
+          if (idx >= 0) {
+            cache_again.push_back(idx);
+          }
         }
+      }
+
+      int num_feat = cache_again.size();
 
-    } else if (model_opt.decoder_name == "2o-carreras") {
+      if (num_feat > 0) {
         if (!model_opt.labeled) {
-            deco = new Decoder2OCarreras();
+          inst->depu_features[hid][cid] = new FeatureVector;
+          inst->depu_features[hid][cid]->n = num_feat;
+          inst->depu_features[hid][cid]->idx = 0;
+          inst->depu_features[hid][cid]->val = 0;
+
+          inst->depu_features[hid][cid]->idx = new int[num_feat];
+          for (int j = 0; j < num_feat; ++ j) {
+            inst->depu_features[hid][cid]->idx[j] = cache_again[j];
+          }
         } else {
-            deco = new Decoder2OCarreras(model->num_deprels());
+          int l = 0;
+          int * idx = new int[num_feat];
+          for (int j = 0; j < num_feat; ++ j) {
+            idx[j] = cache_again[j];
+          }
+
+          inst->depl_features[hid][cid][l] = new FeatureVector;
+          inst->depl_features[hid][cid][l]->n = num_feat;
+          inst->depl_features[hid][cid][l]->val = 0;
+          inst->depl_features[hid][cid][l]->loff = 0;
+          inst->depl_features[hid][cid][l]->idx = idx;
+
+          for (l = 1; l < L; ++ l) {
+            inst->depl_features[hid][cid][l] = new FeatureVector;
+            inst->depl_features[hid][cid][l]->n = num_feat;
+            inst->depl_features[hid][cid][l]->idx = idx;
+            inst->depl_features[hid][cid][l]->val = 0;
+            inst->depl_features[hid][cid][l]->loff = l;
+          }
         }
+      }
+    }   //  end for DEPTreeSpaceIterator itx
+  }   //  end for feat_opt.use_dependency
+
+  if (feat_opt.use_sibling) {
+    if (!model_opt.labeled) {
+      inst->sibu_features.resize(len, len, len);
+      inst->sibu_scores.resize(len, len, len);
+
+      inst->sibu_features = 0;
+      inst->sibu_scores = DOUBLE_NEG_INF;
+    } else {
+      inst->sibl_features.resize(len, len, len, L);
+      inst->sibl_scores.resize(len, len, len, L);
+
+      inst->sibl_features = 0;
+      inst->sibl_scores = DOUBLE_NEG_INF;
     }
-    return deco;
-}
 
+    int N = SIBExtractor::num_templates();
 
-void Parser::extract_features(Instance * inst) {
-    int len = inst->size();
-    int L   = model->num_deprels();
-    FeatureSpace& space = model->space;
+    vector< StringVec > cache;
+    vector< int > cache_again;
 
-    if (feat_opt.use_dependency) {
+    cache.resize(N);
 
-        if (!model_opt.labeled) {
-            inst->depu_features.resize(len, len);
-            inst->depu_scores.resize(len, len);
+    for (treeutils::SIBTreeSpaceIterator itx(len, feat_opt.use_last_sibling);
+         !itx.end();
+         ++ itx) {
+      int hid = itx.hid();
+      int cid = itx.cid();
+      int sid = itx.sid();
 
-            inst->depu_features = 0;
-            inst->depu_scores = DOUBLE_NEG_INF;
-        } else {
-            inst->depl_features.resize(len, len, L);
-            inst->depl_scores.resize(len, len, L);
+      for (int i = 0; i < N; ++ i) {
+        cache[i].clear();
+      }
+
+      SIBExtractor::extract3o(inst, hid, cid, sid, cache);
+      cache_again.clear();
 
-            inst->depl_features = 0;
-            inst->depl_scores = DOUBLE_NEG_INF;
+      //
+      for (int tid = 0; tid < cache.size(); ++ tid) {
+        for (int itx = 0; itx < cache[tid].size(); ++ itx) {
+          int idx = model->space.index(FeatureSpace::SIB, tid, cache[tid][itx]);
+          if (idx >= 0) {
+            cache_again.push_back(idx);
+          }
         }
+      }
 
-        vector< StringVec >  cache;
-        vector< int >     cache_again;
-
-        int N = DEPExtractor::num_templates();
-
-        cache.resize( N );
-
-        for (treeutils::DEPTreeSpaceIterator itx(len); !itx.end(); ++ itx) {
-            int hid = itx.hid();
-            int cid = itx.cid();
-
-            // here the self-implementated String Vector is little
-            // fasteer than the list<string>
-            for (int i = 0; i < N; ++ i) {
-                cache[i].clear();
-            }
-
-            DEPExtractor::extract2o(inst, hid, cid, cache);
-            cache_again.clear();
-
-            for (int tid = 0; tid < cache.size(); ++ tid) {
-                for (int itx = 0; itx < cache[tid].size(); ++ itx) {
-                    int idx = model->space.index(FeatureSpace::DEP, tid, cache[tid][itx], 0);
-                    // std::cout << "idx: " << idx << std::endl;
-                    if (idx >= 0) {
-                        cache_again.push_back(idx);
-                    }
-                }
-            }
-
-            int num_feat = cache_again.size();
-
-            if (num_feat > 0) {
-                if (!model_opt.labeled) {
-                    inst->depu_features[hid][cid] = new FeatureVector;
-                    inst->depu_features[hid][cid]->n = num_feat;
-                    inst->depu_features[hid][cid]->idx = 0;
-                    inst->depu_features[hid][cid]->val = 0;
-
-                    inst->depu_features[hid][cid]->idx = new int[num_feat];
-                    for (int j = 0; j < num_feat; ++ j) {
-                        inst->depu_features[hid][cid]->idx[j] = cache_again[j];
-                    }
-                } else {
-                    int l = 0;
-                    int * idx = new int[num_feat];
-                    for (int j = 0; j < num_feat; ++ j) {
-                        idx[j] = cache_again[j];
-                    }
-
-                    inst->depl_features[hid][cid][l] = new FeatureVector;
-                    inst->depl_features[hid][cid][l]->n = num_feat;
-                    inst->depl_features[hid][cid][l]->val = 0;
-                    inst->depl_features[hid][cid][l]->loff = 0;
-                    inst->depl_features[hid][cid][l]->idx = idx;
-
-                    for (l = 1; l < L; ++ l) {
-                        inst->depl_features[hid][cid][l] = new FeatureVector;
-                        inst->depl_features[hid][cid][l]->n = num_feat;
-                        inst->depl_features[hid][cid][l]->idx = idx;
-                        inst->depl_features[hid][cid][l]->val = 0;
-                        inst->depl_features[hid][cid][l]->loff = l;
-                    }
-                }
-            }
-        }   //  end for DEPTreeSpaceIterator itx
-    }   //  end for feat_opt.use_dependency
+      int num_feat = cache_again.size();
 
-    if (feat_opt.use_sibling) {
+      if (num_feat > 0) {
         if (!model_opt.labeled) {
-            inst->sibu_features.resize(len, len, len);
-            inst->sibu_scores.resize(len, len, len);
-
-            inst->sibu_features = 0;
-            inst->sibu_scores = DOUBLE_NEG_INF;
+          inst->sibu_features[hid][cid][sid] = new FeatureVector;
+          inst->sibu_features[hid][cid][sid]->n = num_feat;
+          inst->sibu_features[hid][cid][sid]->idx = 0;
+          inst->sibu_features[hid][cid][sid]->val = 0;
+
+          inst->sibu_features[hid][cid][sid]->idx = new int[num_feat];
+          for (int j = 0; j < num_feat; ++ j) {
+            inst->sibu_features[hid][cid][sid]->idx[j] = cache_again[j];
+          }
         } else {
-            inst->sibl_features.resize(len, len, len, L);
-            inst->sibl_scores.resize(len, len, len, L);
-
-            inst->sibl_features = 0;
-            inst->sibl_scores = DOUBLE_NEG_INF;
+          int l = 0;
+          int * idx = new int[num_feat];
+          for (int j = 0; j < num_feat; ++ j) {
+            idx[j] = cache_again[j];
+          }
+
+          inst->sibl_features[hid][cid][sid][l] = new FeatureVector;
+          inst->sibl_features[hid][cid][sid][l]->n = num_feat;
+          inst->sibl_features[hid][cid][sid][l]->val = 0;
+          inst->sibl_features[hid][cid][sid][l]->idx = idx;
+          inst->sibl_features[hid][cid][sid][l]->loff = 0;
+
+          for (l = 1; l < L; ++ l) {
+            inst->sibl_features[hid][cid][sid][l] = new FeatureVector;
+            inst->sibl_features[hid][cid][sid][l]->n = num_feat;
+            inst->sibl_features[hid][cid][sid][l]->val = 0;
+            inst->sibl_features[hid][cid][sid][l]->idx = idx;
+            inst->sibl_features[hid][cid][sid][l]->loff = l;
+          }   //  end for if model_opt.labeled
         }
+      }
+    }   //  end for SIBTreeSpaceIterator itx
+  }   //  end for feat_opt.use_sibling
 
-        int N = SIBExtractor::num_templates();
-
-        vector< StringVec > cache;
-        vector< int > cache_again;
-
-        cache.resize(N);
-
-        for (treeutils::SIBTreeSpaceIterator itx(len, feat_opt.use_last_sibling); !itx.end(); ++ itx) {
-            int hid = itx.hid();
-            int cid = itx.cid();
-            int sid = itx.sid();
-
-            for (int i = 0; i < N; ++ i) {
-                cache[i].clear();
-            }
-
-            SIBExtractor::extract3o(inst, hid, cid, sid, cache);
-            cache_again.clear();
-
-            //
-            for (int tid = 0; tid < cache.size(); ++ tid) {
-                for (int itx = 0; itx < cache[tid].size(); ++ itx) {
-                    int idx = model->space.index(FeatureSpace::SIB, tid, cache[tid][itx]);
-                    if (idx >= 0) {
-                        cache_again.push_back(idx);
-                    }
-                }
-            }
-
-            int num_feat = cache_again.size();
-
-            if (num_feat > 0) {
-                if (!model_opt.labeled) {
-                    inst->sibu_features[hid][cid][sid] = new FeatureVector;
-                    inst->sibu_features[hid][cid][sid]->n = num_feat;
-                    inst->sibu_features[hid][cid][sid]->idx = 0;
-                    inst->sibu_features[hid][cid][sid]->val = 0;
-
-                    inst->sibu_features[hid][cid][sid]->idx = new int[num_feat];
-                    for (int j = 0; j < num_feat; ++ j) {
-                        inst->sibu_features[hid][cid][sid]->idx[j] = cache_again[j];
-                    }
-                } else {
-                    int l = 0;
-                    int * idx = new int[num_feat];
-                    for (int j = 0; j < num_feat; ++ j) {
-                        idx[j] = cache_again[j];
-                    }
-
-                    inst->sibl_features[hid][cid][sid][l] = new FeatureVector;
-                    inst->sibl_features[hid][cid][sid][l]->n = num_feat;
-                    inst->sibl_features[hid][cid][sid][l]->val = 0;
-                    inst->sibl_features[hid][cid][sid][l]->idx = idx;
-                    inst->sibl_features[hid][cid][sid][l]->loff = 0;
-
-                    for (l = 1; l < L; ++ l) {
-                        inst->sibl_features[hid][cid][sid][l] = new FeatureVector;
-                        inst->sibl_features[hid][cid][sid][l]->n = num_feat;
-                        inst->sibl_features[hid][cid][sid][l]->val = 0;
-                        inst->sibl_features[hid][cid][sid][l]->idx = idx;
-                        inst->sibl_features[hid][cid][sid][l]->loff = l;
-                    }   //  end for if model_opt.labeled
-                }
-            }
-        }   //  end for SIBTreeSpaceIterator itx
-    }   //  end for feat_opt.use_sibling
+  if (feat_opt.use_grand) {
+    if (!model_opt.labeled) {
+      inst->grdu_features.resize(len, len, len);
+      inst->grdu_scores.resize(len, len, len);
 
-    if (feat_opt.use_grand) {
-        if (!model_opt.labeled) {
-            inst->grdu_features.resize(len, len, len);
-            inst->grdu_scores.resize(len, len, len);
+      inst->grdu_features = 0;
+      inst->grdu_scores = DOUBLE_NEG_INF;
+    } else {
+      inst->grdl_features.resize(len, len, len, L);
+      inst->grdl_scores.resize(len, len, len, L);
 
-            inst->grdu_features = 0;
-            inst->grdu_scores = DOUBLE_NEG_INF;
-        } else {
-            inst->grdl_features.resize(len, len, len, L);
-            inst->grdl_scores.resize(len, len, len, L);
+      inst->grdl_features = 0;
+      inst->grdl_scores = DOUBLE_NEG_INF;
+    }
 
-            inst->grdl_features = 0;
-            inst->grdl_scores = DOUBLE_NEG_INF;
-        }
+    int N = GRDExtractor::num_templates();
 
-        int N = GRDExtractor::num_templates();
-
-        vector< StringVec > cache;
-        vector< int > cache_again;
-
-        cache.resize(N);
-
-        for (treeutils::GRDTreeSpaceIterator itx(len, feat_opt.use_no_grand); !itx.end(); ++ itx) {
-            int hid = itx.hid();
-            int cid = itx.cid();
-            int gid = itx.gid();
-
-            for (int i = 0; i < N; ++ i) {
-                cache[i].clear();
-            }
-
-            GRDExtractor::extract3o(inst, hid, cid, gid, cache);
-            cache_again.clear();
-
-            for (int tid = 0; tid < cache.size(); ++ tid) {
-                for (int itx = 0; itx < cache[tid].size(); ++ itx) {
-                    int idx = model->space.index(FeatureSpace::GRD, tid, cache[tid][itx]);
-                    if (idx >= 0) {
-                        cache_again.push_back(idx);
-                    }
-                }
-            }
-
-            int num_feat = cache_again.size();
-
-            if (num_feat > 0) {
-                if (!model_opt.labeled) {
-                    inst->grdu_features[hid][cid][gid] = new FeatureVector;
-                    inst->grdu_features[hid][cid][gid]->n = num_feat;
-                    inst->grdu_features[hid][cid][gid]->idx = 0;
-                    inst->grdu_features[hid][cid][gid]->val = 0;
-
-                    inst->grdu_features[hid][cid][gid]->idx = new int[num_feat];
-                    for (int j = 0; j < num_feat; ++ j) {
-                        inst->grdu_features[hid][cid][gid]->idx[j] = cache_again[j];
-                    }
-                } else {
-                    int l = 0;
-                    int * idx = new int[num_feat];
-                    for (int j = 0; j < num_feat; ++ j) {
-                        idx[j] = cache_again[j];
-                    }
-
-                    inst->grdl_features[hid][cid][gid][l] = new FeatureVector;
-                    inst->grdl_features[hid][cid][gid][l]->n = num_feat;
-                    inst->grdl_features[hid][cid][gid][l]->val = 0;
-                    inst->grdl_features[hid][cid][gid][l]->idx = idx;
-                    inst->grdl_features[hid][cid][gid][l]->loff = 0;
-
-                    for (l = 1; l < L; ++ l) {
-                        inst->grdl_features[hid][cid][gid][l] = new FeatureVector;
-                        inst->grdl_features[hid][cid][gid][l]->n = num_feat;
-                        inst->grdl_features[hid][cid][gid][l]->val = 0;
-                        inst->grdl_features[hid][cid][gid][l]->idx = idx;
-                        inst->grdl_features[hid][cid][gid][l]->loff = l;
-                    }   //  end for if model_opt.labeled
-                }
-            }
-        }
-    }   //  end for feat_opt.use_grand
-}
+    vector< StringVec > cache;
+    vector< int > cache_again;
+
+    cache.resize(N);
 
-void Parser::extract_features(vector<Instance *>& dat) {
-    // ofstream fout("lgdpj.fv.tmp", std::ofstream::binary);
-    // DependencyExtractor
-    for (int i = 0; i < dat.size(); ++ i) {
-        extract_features(dat[i]);
+    for (treeutils::GRDTreeSpaceIterator itx(len, feat_opt.use_no_grand);
+         !itx.end();
+         ++ itx) {
+      int hid = itx.hid();
+      int cid = itx.cid();
+      int gid = itx.gid();
 
-        // dat[i]->dump_all_featurevec(fout);
-        if ((i + 1) % model_opt.display_interval == 0) {
-            TRACE_LOG("[%d] instance is extracted.", i + 1);
+      for (int i = 0; i < N; ++ i) {
+        cache[i].clear();
+      }
+
+      GRDExtractor::extract3o(inst, hid, cid, gid, cache);
+      cache_again.clear();
+
+      for (int tid = 0; tid < cache.size(); ++ tid) {
+        for (int itx = 0; itx < cache[tid].size(); ++ itx) {
+          int idx = model->space.index(FeatureSpace::GRD, tid, cache[tid][itx]);
+          if (idx >= 0) {
+            cache_again.push_back(idx);
+          }
         }
-    }   // end for i = 0; i < dat.size(); ++ i
+      }
 
-    // fout.close();
-}
+      int num_feat = cache_again.size();
 
-void Parser::build_gold_features() {
-    // ifstream fin("lgdpj.fv.tmp", std::ifstream::binary);
-    for (int i = 0; i < train_dat.size(); ++ i) {
-        // train_dat[i]->load_all_featurevec(fin);
-        collect_features_of_one_instance(train_dat[i], true);
-        // train_dat[i]->nice_all_featurevec();
+      if (num_feat > 0) {
+        if (!model_opt.labeled) {
+          inst->grdu_features[hid][cid][gid] = new FeatureVector;
+          inst->grdu_features[hid][cid][gid]->n = num_feat;
+          inst->grdu_features[hid][cid][gid]->idx = 0;
+          inst->grdu_features[hid][cid][gid]->val = 0;
+
+          inst->grdu_features[hid][cid][gid]->idx = new int[num_feat];
+          for (int j = 0; j < num_feat; ++ j) {
+            inst->grdu_features[hid][cid][gid]->idx[j] = cache_again[j];
+          }
+        } else {
+          int l = 0;
+          int * idx = new int[num_feat];
+          for (int j = 0; j < num_feat; ++ j) {
+            idx[j] = cache_again[j];
+          }
+
+          inst->grdl_features[hid][cid][gid][l] = new FeatureVector;
+          inst->grdl_features[hid][cid][gid][l]->n = num_feat;
+          inst->grdl_features[hid][cid][gid][l]->val = 0;
+          inst->grdl_features[hid][cid][gid][l]->idx = idx;
+          inst->grdl_features[hid][cid][gid][l]->loff = 0;
+
+          for (l = 1; l < L; ++ l) {
+            inst->grdl_features[hid][cid][gid][l] = new FeatureVector;
+            inst->grdl_features[hid][cid][gid][l]->n = num_feat;
+            inst->grdl_features[hid][cid][gid][l]->val = 0;
+            inst->grdl_features[hid][cid][gid][l]->idx = idx;
+            inst->grdl_features[hid][cid][gid][l]->loff = l;
+          }   //  end for if model_opt.labeled
+        }
+      }
     }
-    // fin.close();
+  }   //  end for feat_opt.use_grand
 }
 
-void Parser::train(void) {
-    const char * train_file = train_opt.train_file.c_str();
-    const char * holdout_file = train_opt.holdout_file.c_str();
+void
+Parser::extract_features(vector<Instance *>& dat) {
+  // ofstream fout("lgdpj.fv.tmp", std::ofstream::binary);
+  // DependencyExtractor
+  for (int i = 0; i < dat.size(); ++ i) {
+    extract_features(dat[i]);
 
-    if (!read_instances(train_file, train_dat)) {
-        ERROR_LOG("Failed to read train data from [%s].", train_file);
-        return;
-    } else {
-        TRACE_LOG("Read in [%d] train instances.", train_dat.size());
+    // dat[i]->dump_all_featurevec(fout);
+    if ((i + 1) % model_opt.display_interval == 0) {
+      TRACE_LOG("[%d] instance is extracted.", i + 1);
     }
+  }   // end for i = 0; i < dat.size(); ++ i
 
-    model = new Model;
+  // fout.close();
+}
 
-    TRACE_LOG("Start building configuration.");
-    build_configuration();
-    TRACE_LOG("Building configuration is done.");
-    TRACE_LOG("Number of postags: [%d]", model->num_postags());
-    TRACE_LOG("Number of deprels: [%d]", model->num_deprels());
+void
+Parser::build_gold_features() {
+  // ifstream fin("lgdpj.fv.tmp", std::ifstream::binary);
+  for (int i = 0; i < train_dat.size(); ++ i) {
+    // train_dat[i]->load_all_featurevec(fin);
+    collect_features_of_one_instance(train_dat[i], true);
+    // train_dat[i]->nice_all_featurevec();
+  }
+  // fin.close();
+}
 
-    TRACE_LOG("Start building feature space.");
-    build_feature_space();
-    TRACE_LOG("Building feature space is done.");
-    TRACE_LOG("Number of features: [%d]", model->space.num_features());
+void
+Parser::increase_group_updated_time(const math::SparseVec & vec,
+                                    int * feature_group_updated_time) {
+  if (!feature_group_updated_time) {
+    return;
+  }
+
+  int L = model->num_deprels();
+  for (math::SparseVec::const_iterator itx = vec.begin();
+      itx != vec.end();
+      ++ itx) {
+
+    int idx = itx->first;
+    if (itx->second != 0.0) {
+      ++ feature_group_updated_time[idx / L];
+    }
+  }
+}
 
-    model->param.realloc(model->dim());
-    TRACE_LOG("Allocate a parameter vector of [%d] dimension.", model->dim());
 
-    decoder = build_decoder();
+void
+Parser::train(void) {
+  const char * train_file   = train_opt.train_file.c_str();
+  // const char * holdout_file = train_opt.holdout_file.c_str();
 
-    for (int iter = 0; iter < train_opt.max_iter; ++ iter) {
-        TRACE_LOG("Start training epoch #%d.", (iter + 1));
+  if (!read_instances(train_file, train_dat)) {
+    ERROR_LOG("Failed to read train data from [%s].", train_file);
+    return;
+  } else {
+    TRACE_LOG("Read in [%d] train instances.", train_dat.size());
+  }
 
-        // random_shuffle(train_dat.begin(), train_dat.end());
-        for (int i = 0; i < train_dat.size(); ++ i) {
+  model = new Model;
 
-            extract_features(train_dat[i]);
-            calculate_score(train_dat[i], model->param);
-            decoder->decode(train_dat[i]);
-            collect_features_of_one_instance(train_dat[i], true);
-            collect_features_of_one_instance(train_dat[i], false);
+  TRACE_LOG("Start building configuration.");
+  build_configuration();
+  TRACE_LOG("Building configuration is done.");
+  TRACE_LOG("Number of postags: [%d]", model->num_postags());
+  TRACE_LOG("Number of deprels: [%d]", model->num_deprels());
 
-            // instance_verify(train_dat[i], cout, true);
+  TRACE_LOG("Start building feature space.");
+  build_feature_space();
+  TRACE_LOG("Building feature space is done.");
+  TRACE_LOG("Number of features: [%d]", model->space.num_features());
 
-            if (train_opt.algorithm == "pa") {
-                SparseVec update_features;
-                update_features.zero();
-                update_features.add(train_dat[i]->features, 1.);
-                update_features.add(train_dat[i]->predicted_features, -1.);
+  model->param.realloc(model->dim());
+  TRACE_LOG("Allocate a parameter vector of [%d] dimension.", model->dim());
 
-                double error = train_dat[i]->num_errors();
-                double score = model->param.dot(update_features, false);
-                double norm = update_features.L2();
-                double step = 0.;
+  int nr_feature_groups = model->num_features();
+  // int num_l = model->num_deprels();
+  int * feature_group_updated_time = NULL;
 
-                if (norm < EPS) {
-                    step = 0;
-                } else {
-                    step = (error - score) / norm;
-                }
+  if (model_opt.labeled
+      && train_opt.rare_feature_threshold > 0) {
+    feature_group_updated_time = new int[nr_feature_groups];
+    for (int i = 0; i < nr_feature_groups; ++ i) {
+      feature_group_updated_time[i] = 0;
+    }
+  }
 
-                model->param.add(update_features, 
-                        iter * train_dat.size() + i + 1, 
-                        step);
-            } else if (train_opt.algorithm == "ap") {
-                SparseVec update_features;
+  decoder = build_decoder();
 
-                update_features.add(train_dat[i]->features, 1.);
-                update_features.add(train_dat[i]->predicted_features, -1.);
+  int best_iteration = -1;
+  double best_las = -1;
+  double best_uas = -1;
 
-                model->param.add(update_features,
-                        iter * train_dat.size() + i + 1,
-                        1.);
-            }
+  for (int iter = 0; iter < train_opt.max_iter; ++ iter) {
+    TRACE_LOG("Start training epoch #%d.", (iter + 1));
 
-            if ((i + 1) % model_opt.display_interval == 0) {
-                TRACE_LOG("[%d] instances is trained.", i + 1);
-            }
+    // random_shuffle(train_dat.begin(), train_dat.end());
+    for (int i = 0; i < train_dat.size(); ++ i) {
 
-            train_dat[i]->cleanup();
+      extract_features(train_dat[i]);
+      calculate_score(train_dat[i], model->param);
+      decoder->decode(train_dat[i]);
+      collect_features_of_one_instance(train_dat[i], true);
+      collect_features_of_one_instance(train_dat[i], false);
+
+      // instance_verify(train_dat[i], cout, true);
+
+      if (train_opt.algorithm == "pa") {
+        SparseVec update_features;
+        update_features.zero();
+        update_features.add(train_dat[i]->features, 1.);
+        update_features.add(train_dat[i]->predicted_features, -1.);
+        increase_group_updated_time(update_features,
+                                    feature_group_updated_time);
+
+        double error = train_dat[i]->num_errors();
+        double score = model->param.dot(update_features, false);
+        double norm = update_features.L2();
+        double step = 0.;
+
+        if (norm < EPS) {
+          step = 0;
+        } else {
+          step = (error - score) / norm;
         }
 
-        model->param.flush( train_dat.size() * (iter + 1) );
-        Model * new_model = truncate();
-        swap(model,new_model);
-        evaluate();
+        model->param.add(update_features,
+                         iter * train_dat.size() + i + 1,
+                         step);
+      } else if (train_opt.algorithm == "ap") {
+        SparseVec update_features;
 
-        string saved_model_file = (train_opt.model_name + "." + to_str(iter) + ".model");
-        ofstream fout(saved_model_file.c_str(), std::ofstream::binary);
+        update_features.add(train_dat[i]->features, 1.);
+        update_features.add(train_dat[i]->predicted_features, -1.);
+        increase_group_updated_time(update_features,
+                                    feature_group_updated_time);
 
-        swap(model,new_model);
-        new_model->save(fout);
+        model->param.add(update_features,
+                         iter * train_dat.size() + i + 1,
+                         1.);
+      }
 
-        TRACE_LOG("Model for iteration [%d] is saved to [%s]",
-                iter + 1,
-                saved_model_file.c_str());
+      if ((i + 1) % model_opt.display_interval == 0) {
+        TRACE_LOG("[%d] instances is trained.", i + 1);
+      }
 
+      train_dat[i]->cleanup();
     }
 
-    delete model;
-    model = 0;
-}
-
-void Parser::evaluate(void) {
-    const char * holdout_file = train_opt.holdout_file.c_str();
+    model->param.flush( train_dat.size() * (iter + 1) );
 
-    int head_correct = 0;
-    int label_correct = 0;
-    int total_rels = 0;
+    Model * new_model;
 
-    ifstream f(holdout_file);
-    CoNLLReader reader(f);
+    new_model = erase_rare_features(feature_group_updated_time);
+    swap(model,new_model);
 
-    Instance * inst = NULL;
+    double las, uas;
+    evaluate(las, uas);
 
-    double before = get_time();
-    while ((inst = reader.next())) {
+    if(las > best_las) {
+      best_las = las;
+      best_uas = uas;
+      best_iteration = iter;
+    }
 
-        if (model_opt.labeled) {
-            inst->deprelsidx.resize(inst->size());
-            for (int i = 1; i < inst->size(); ++ i) {
-                inst->deprelsidx[i] = model->deprels.index(inst->deprels[i].c_str());
-            }
-        }
+    string saved_model_file = (train_opt.model_name
+                               + "."
+                               + to_str(iter)
+                               + ".model");
+    ofstream fout(saved_model_file.c_str(), std::ofstream::binary);
 
-        extract_features(inst);
-        calculate_score(inst, model->param, true);
+    swap(model,new_model);
+    new_model->save(fout);
+    delete new_model;
 
-        decoder->decode(inst);
+    TRACE_LOG("Model for iteration [%d] is saved to [%s]",
+        iter + 1,
+        saved_model_file.c_str());
 
-        total_rels += inst->num_rels();
-        head_correct += inst->num_correct_heads();
-        label_correct += inst->num_correct_heads_and_labels();
+  }
 
-        delete inst;
-    }
+  if (feature_group_updated_time) {
+    delete [](feature_group_updated_time);
+  }
+  TRACE_LOG("Best result (iteration = %d) : LAS = %lf | UAS = %f",
+            best_iteration,
+            best_las,
+            best_uas);
 
-    TRACE_LOG("UAS: %.4lf ( %d / %d )", 
-            (double)head_correct / total_rels, 
-            head_correct, 
-            total_rels);
+  delete model;
+  model = 0;
+}
 
-    if (model_opt.labeled) {
-        TRACE_LOG("LAS: %.4lf ( %d / %d )", 
-                (double)label_correct / total_rels, 
-                label_correct, 
-                total_rels);
-    }
+void
+Parser::evaluate(double &las, double &uas) {
+  const char * holdout_file = train_opt.holdout_file.c_str();
 
-    double after = get_time();
-    TRACE_LOG("consuming time: %.2lf", after - before);
+  int head_correct = 0;
+  int label_correct = 0;
+  int total_rels = 0;
 
-    // holdout_dat.clear();
-}
+  ifstream f(holdout_file);
+  CoNLLReader reader(f);
 
-void Parser::test() {
-    double before = get_time();
-    const char * model_file = test_opt.model_file.c_str();
-    ifstream mfs(model_file, std::ifstream::binary);
+  Instance * inst = NULL;
 
-    if (!mfs) {
-        ERROR_LOG("Failed to open file [%s].", model_file);
-        return;
-    }
+  double before = get_time();
+  while ((inst = reader.next())) {
 
-    model = new Model;
-    if (!model->load(mfs)) {
-        ERROR_LOG("Failed to load model");
-        return;
+    if (model_opt.labeled) {
+      inst->deprelsidx.resize(inst->size());
+      for (int i = 1; i < inst->size(); ++ i) {
+        inst->deprelsidx[i] = model->deprels.index(inst->deprels[i].c_str());
+      }
     }
 
-    TRACE_LOG("Number of postags                [%d]", model->num_postags());
-    TRACE_LOG("Number of deprels                [%d]", model->num_deprels());
-    TRACE_LOG("Number of features               [%d]", model->num_features());
-    TRACE_LOG("Number of dimension              [%d]", model->dim());
-    TRACE_LOG("Labeled:                         %s", 
-            (model_opt.labeled ? "true" : "fales"));
-    TRACE_LOG("Decoder:                         %s", 
-            model_opt.decoder_name.c_str());
-    TRACE_LOG("Dependency features:             %s",
-            (feat_opt.use_dependency ? "true" : "false"));
-    TRACE_LOG("Dependency features unigram:     %s", 
-            (feat_opt.use_dependency_unigram ? "true" : "false"));
-    TRACE_LOG("Dependency features bigram:      %s", 
-            (feat_opt.use_dependency_bigram ? "true" : "false"));
-    TRACE_LOG("Dependency features surrounding: %s", 
-            (feat_opt.use_dependency_surrounding ? "true" : "false"));
-    TRACE_LOG("Dependency features between:     %s", 
-            (feat_opt.use_dependency_between ? "true" : "false"));
-    TRACE_LOG("Sibling features:                %s",
-            (feat_opt.use_sibling ? "true" : "false"));
-    TRACE_LOG("Sibling basic features:          %s", 
-            (feat_opt.use_sibling_basic ? "true" : "false"));
-    TRACE_LOG("Sibling linear features:         %s", 
-            (feat_opt.use_sibling_linear ? "true" : "false"));
-    TRACE_LOG("Grandchild features:             %s",
-            (feat_opt.use_grand ? "true" : "false"));
-    TRACE_LOG("Grandchild basic features:       %s",
-            (feat_opt.use_grand_basic ? "true" : "false"));
-    TRACE_LOG("Grandchild linear features:      %s",
-            (feat_opt.use_grand_linear ? "true" : "false"));
-
-    const char * test_file = test_opt.test_file.c_str();
-
-    ifstream f(test_file);
-    if (!f) {
-        ERROR_LOG("Failed to load test file %s", test_file);
-        return;
-    }
+    extract_features(inst);
+    calculate_score(inst, model->param, true);
 
-    CoNLLReader reader(f);
-    CoNLLWriter writer(cout);
+    decoder->decode(inst);
 
-    Instance * inst = NULL;
+    total_rels += inst->num_rels();
+    head_correct += inst->num_correct_heads();
+    label_correct += inst->num_correct_heads_and_labels();
 
-    decoder=build_decoder();
-    cerr << get_time() - before << endl;
-    before = get_time();
+    delete inst;
+  }
 
-    int head_correct = 0;
-    int label_correct = 0;
-    int total_rels = 0;
+  uas = (double)head_correct / total_rels;
+  TRACE_LOG("UAS: %.4lf ( %d / %d )", uas,
+                                      head_correct,
+                                      total_rels);
 
-    while ((inst = reader.next())) {
-        int len = inst->size();
-        if (model_opt.labeled) {
-            inst->deprelsidx.resize(len);
-            for (int i = 1; i < len; ++ i) {
-                inst->deprelsidx[i] = model->deprels.index(inst->deprels[i].c_str());
-            }
-        }
+  las = 0;
+  if (model_opt.labeled) {
+    las = (double)label_correct / total_rels;
+    TRACE_LOG("LAS: %.4lf ( %d / %d )", las,
+                                        label_correct,
+                                        total_rels);
+  }
 
-        extract_features(inst);
-        calculate_score(inst, model->param, true);
+  double after = get_time();
+  TRACE_LOG("consuming time: %.2lf", after - before);
 
-        decoder->decode(inst);
-
-        if (model_opt.labeled) {
-            inst->predicted_deprels.resize(len);
-            for (int i = 1; i < len; ++ i) {
-                inst->predicted_deprels[i] = model->deprels.at(inst->predicted_deprelsidx[i]);
-            }
-        }
-
-        writer.write(inst);
+  // holdout_dat.clear();
+}
 
-        total_rels += inst->num_rels();
-        head_correct += inst->num_correct_heads();
-        label_correct += inst->num_correct_heads_and_labels();
-        delete inst;
+void
+Parser::test() {
+  double before = get_time();
+  const char * model_file = test_opt.model_file.c_str();
+  ifstream mfs(model_file, std::ifstream::binary);
+
+  if (!mfs) {
+    ERROR_LOG("Failed to open file [%s].", model_file);
+    return;
+  }
+
+  model = new Model;
+  if (!model->load(mfs)) {
+    ERROR_LOG("Failed to load model");
+    return;
+  }
+
+  TRACE_LOG("Number of postags        [%d]", model->num_postags());
+  TRACE_LOG("Number of deprels        [%d]", model->num_deprels());
+  TRACE_LOG("Number of features       [%d]", model->num_features());
+  TRACE_LOG("Number of dimension      [%d]", model->dim());
+  TRACE_LOG("Labeled:                         %s",
+            (model_opt.labeled ? "true" : "fales"));
+  TRACE_LOG("Decoder:                         %s",
+            model_opt.decoder_name.c_str());
+  TRACE_LOG("Dependency features:             %s",
+            (feat_opt.use_dependency ?             "true" : "false"));
+  TRACE_LOG("Dependency features unigram:     %s",
+            (feat_opt.use_dependency_unigram ?     "true" : "false"));
+  TRACE_LOG("Dependency features bigram:      %s",
+            (feat_opt.use_dependency_bigram ?      "true" : "false"));
+  TRACE_LOG("Dependency features surrounding: %s",
+            (feat_opt.use_dependency_surrounding ? "true" : "false"));
+  TRACE_LOG("Dependency features between:     %s",
+            (feat_opt.use_dependency_between ?     "true" : "false"));
+  TRACE_LOG("Sibling features:                %s",
+            (feat_opt.use_sibling ?                "true" : "false"));
+  TRACE_LOG("Sibling basic features:          %s",
+            (feat_opt.use_sibling_basic ?          "true" : "false"));
+  TRACE_LOG("Sibling linear features:         %s",
+            (feat_opt.use_sibling_linear ?         "true" : "false"));
+  TRACE_LOG("Grandchild features:             %s",
+            (feat_opt.use_grand ?                  "true" : "false"));
+  TRACE_LOG("Grandchild basic features:       %s",
+            (feat_opt.use_grand_basic ?            "true" : "false"));
+  TRACE_LOG("Grandchild linear features:      %s",
+            (feat_opt.use_grand_linear ?           "true" : "false"));
+
+  const char * test_file = test_opt.test_file.c_str();
+
+  ifstream f(test_file);
+  if (!f) {
+    ERROR_LOG("Failed to load test file %s", test_file);
+    return;
+  }
+
+  CoNLLReader reader(f);
+  CoNLLWriter writer(cout);
+
+  Instance * inst = NULL;
+
+  decoder=build_decoder();
+  cerr << get_time() - before << endl;
+  before = get_time();
+
+  int head_correct = 0;
+  int label_correct = 0;
+  int total_rels = 0;
+
+  while ((inst = reader.next())) {
+    int len = inst->size();
+    if (model_opt.labeled) {
+      inst->deprelsidx.resize(len);
+      for (int i = 1; i < len; ++ i) {
+        inst->deprelsidx[i] = model->deprels.index(inst->deprels[i].c_str());
+      }
     }
-    double after = get_time();
-    cerr << after - before << endl;
 
-    TRACE_LOG("UAS: %.4lf ( %d / %d )", 
-            (double)head_correct / total_rels, 
-            head_correct, 
-            total_rels);
+    extract_features(inst);
+    calculate_score(inst, model->param, true);
+
+    decoder->decode(inst);
 
     if (model_opt.labeled) {
-        TRACE_LOG("LAS: %.4lf ( %d / %d )", 
-                (double)label_correct / total_rels, 
-                label_correct, 
-                total_rels);
+      inst->predicted_deprels.resize(len);
+      for (int i = 1; i < len; ++ i) {
+        inst->predicted_deprels[i] = model->deprels.at(inst->predicted_deprelsidx[i]);
+      }
     }
 
-    sleep(1000000);
+    writer.write(inst);
+
+    total_rels += inst->num_rels();
+    head_correct += inst->num_correct_heads();
+    label_correct += inst->num_correct_heads_and_labels();
+    delete inst;
+  }
+  double after = get_time();
+  cerr << after - before << endl;
+
+  TRACE_LOG("UAS: %.4lf ( %d / %d )",
+      (double)head_correct / total_rels,
+      head_correct,
+      total_rels);
+
+  if (model_opt.labeled) {
+    TRACE_LOG("LAS: %.4lf ( %d / %d )",
+        (double)label_correct / total_rels,
+        label_correct,
+        total_rels);
+  }
+
+  sleep(1000000);
 }
 
+// Enumerate all the subtree in the whole tree space (without specifed tree),
+// cache the score for each subtree into inst-><type>_scores.
+void
+Parser::calculate_score(Instance * inst,
+                        const Parameters& param,
+                        bool use_avg) {
+  int len = inst->size();
+  int L = model->num_deprels();
 
-void Parser::calculate_score(Instance * inst, const Parameters& param, bool use_avg) {
-    int len = inst->size();
-    int L = model->num_deprels();
+  if (feat_opt.use_unlabeled_dependency) {
+    for (treeutils::DEPTreeSpaceIterator itx(len); !itx.end(); ++ itx) {
+      int hid = itx.hid();
+      int cid = itx.cid();
 
-    if (feat_opt.use_unlabeled_dependency) {
-        for (treeutils::DEPTreeSpaceIterator itx(len); !itx.end(); ++ itx) {
-            int hid = itx.hid();
-            int cid = itx.cid();
+      FeatureVector * fv = inst->depu_features[hid][cid];
+      inst->depu_scores[hid][cid] = 0.;
 
-            FeatureVector * fv = inst->depu_features[hid][cid];
-            inst->depu_scores[hid][cid] = 0.;
+      if (!fv) {
+        continue;
+      }
 
-            if (!fv) {
-                continue;
-            }
-
-            inst->depu_scores[hid][cid] = param.dot(fv, use_avg);
-        }
-    }   //  end if feat_opt.use_unlabeled_dependency
-
-    if (feat_opt.use_labeled_dependency) {
-         for (treeutils::DEPTreeSpaceIterator itx(len); !itx.end(); ++ itx) {
-             int hid = itx.hid();
-             int cid = itx.cid();
-             for (int l = 0; l < L; ++ l) {
-                 FeatureVector * fv = inst->depl_features[hid][cid][l];
-                 inst->depl_scores[hid][cid][l] = 0.;
-
-                 if (!fv) {
-                     continue;
-                 }
-
-                 inst->depl_scores[hid][cid][l] = param.dot(fv, use_avg);
-            }
-        }
-    }   //  end if feat_opt.use_labeled_dependency
+      inst->depu_scores[hid][cid] = param.dot(fv, use_avg);
+    }
+  }   //  end if feat_opt.use_unlabeled_dependency
+
+  if (feat_opt.use_labeled_dependency) {
+     for (treeutils::DEPTreeSpaceIterator itx(len); !itx.end(); ++ itx) {
+       int hid = itx.hid();
+       int cid = itx.cid();
+       for (int l = 0; l < L; ++ l) {
+         FeatureVector * fv = inst->depl_features[hid][cid][l];
+         inst->depl_scores[hid][cid][l] = 0.;
+
+         if (!fv) {
+           continue;
+         }
+
+         inst->depl_scores[hid][cid][l] = param.dot(fv, use_avg);
+      }
+    }
+  }   //  end if feat_opt.use_labeled_dependency
 
-    if (feat_opt.use_unlabeled_sibling) {
-        for (treeutils::SIBTreeSpaceIterator itx(len, feat_opt.use_last_sibling); !itx.end(); ++ itx) {
-            int hid = itx.hid();
-            int cid = itx.cid();
-            int sid = itx.sid();
+  if (feat_opt.use_unlabeled_sibling) {
+    for (treeutils::SIBTreeSpaceIterator itx(len, feat_opt.use_last_sibling);
+         !itx.end();
+         ++ itx) {
+      int hid = itx.hid();
+      int cid = itx.cid();
+      int sid = itx.sid();
 
-            FeatureVector * fv = inst->sibu_features[hid][cid][sid];
-            inst->sibu_scores[hid][cid][sid] = 0.;
+      FeatureVector * fv = inst->sibu_features[hid][cid][sid];
+      inst->sibu_scores[hid][cid][sid] = 0.;
 
-            if (!fv) {
-                continue;
-            }
+      if (!fv) {
+        continue;
+      }
 
-            inst->sibu_scores[hid][cid][sid] = param.dot(fv, use_avg);
+      inst->sibu_scores[hid][cid][sid] = param.dot(fv, use_avg);
+    }
+  }   //  end for if feat_opt.use_unlabeled_sibling
+
+  if (feat_opt.use_labeled_sibling) {
+    for (treeutils::SIBTreeSpaceIterator itx(len, feat_opt.use_last_sibling);
+         !itx.end();
+         ++ itx) {
+      int hid = itx.hid();
+      int cid = itx.cid();
+      int sid = itx.sid();
+
+      for (int l = 0; l < L; ++ l) {
+        FeatureVector * fv = inst->sibl_features[hid][cid][sid][l];
+        inst->sibl_scores[hid][cid][sid][l] = 0.;
+
+        if (!fv) {
+          continue;
         }
-    }   //  end for if feat_opt.use_unlabeled_sibling
-
-    if (feat_opt.use_labeled_sibling) {
-        for (treeutils::SIBTreeSpaceIterator itx(len, feat_opt.use_last_sibling); !itx.end(); ++ itx) {
-            int hid = itx.hid();
-            int cid = itx.cid();
-            int sid = itx.sid();
 
-            for (int l = 0; l < L; ++ l) {
-                FeatureVector * fv = inst->sibl_features[hid][cid][sid][l];
-                inst->sibl_scores[hid][cid][sid][l] = 0.;
-
-                if (!fv) {
-                    continue;
-                }
-
-                inst->sibl_scores[hid][cid][sid][l] = param.dot(fv, use_avg);
-            }
-        }
-    }   //  end for if feat_opt.use_labeled_sibling
+        inst->sibl_scores[hid][cid][sid][l] = param.dot(fv, use_avg);
+      }
+    }
+  }   //  end for if feat_opt.use_labeled_sibling
 
-    if (feat_opt.use_unlabeled_grand) {
-        for (treeutils::GRDTreeSpaceIterator itx(len, feat_opt.use_no_grand); !itx.end(); ++ itx) {
-            int hid = itx.hid();
-            int cid = itx.cid();
-            int gid = itx.gid();
+  if (feat_opt.use_unlabeled_grand) {
+    for (treeutils::GRDTreeSpaceIterator itx(len, feat_opt.use_no_grand);
+         !itx.end();
+         ++ itx) {
+      int hid = itx.hid();
+      int cid = itx.cid();
+      int gid = itx.gid();
 
-            FeatureVector * fv = inst->grdu_features[hid][cid][gid];
-            inst->grdu_scores[hid][cid][gid] = 0.;
+      FeatureVector * fv = inst->grdu_features[hid][cid][gid];
+      inst->grdu_scores[hid][cid][gid] = 0.;
 
-            if (!fv) {
-                continue;
-            }
+      if (!fv) {
+        continue;
+      }
 
-            inst->grdu_scores[hid][cid][gid] = param.dot(fv, use_avg);
+      inst->grdu_scores[hid][cid][gid] = param.dot(fv, use_avg);
+    }
+  }   //  end for feat_opt.use_unlabeled_grand
+
+  if (feat_opt.use_labeled_grand) {
+    for (treeutils::GRDTreeSpaceIterator itx(len, feat_opt.use_no_grand);
+         !itx.end();
+         ++ itx) {
+      int hid = itx.hid();
+      int cid = itx.cid();
+      int gid = itx.gid();
+
+      for (int l = 0; l < L; ++ l) {
+        FeatureVector * fv = inst->grdl_features[hid][cid][gid][l];
+        inst->grdl_scores[hid][cid][gid][l] = 0.;
+
+        if (!fv) {
+          continue;
         }
-    }   //  end for feat_opt.use_unlabeled_grand
-
-    if (feat_opt.use_labeled_grand) {
-        for (treeutils::GRDTreeSpaceIterator itx(len, feat_opt.use_no_grand); !itx.end(); ++ itx) {
-            int hid = itx.hid();
-            int cid = itx.cid();
-            int gid = itx.gid();
-
-            for (int l = 0; l < L; ++ l) {
-                FeatureVector * fv = inst->grdl_features[hid][cid][gid][l];
-                inst->grdl_scores[hid][cid][gid][l] = 0.;
 
-                if (!fv) {
-                    continue;
-                }
-
-                inst->grdl_scores[hid][cid][gid][l] = param.dot(fv, use_avg);
-            }
-        }
-    }   //  end for use_labeled_grand
+        inst->grdl_scores[hid][cid][gid][l] = param.dot(fv, use_avg);
+      }
+    }
+  }   //  end for use_labeled_grand
 }
 
 }   //  end for namespace parser
diff --git a/src/parser/parser.h b/src/parser/parser.h
index 1f97437c3..3468a6e2c 100644
--- a/src/parser/parser.h
+++ b/src/parser/parser.h
@@ -1,5 +1,5 @@
-#ifndef __PARSER_H__
-#define __PARSER_H__
+#ifndef __LTP_PARSER_PARSER_H__
+#define __LTP_PARSER_PARSER_H__
 
 #include <iostream>
 
@@ -25,105 +25,120 @@ class Parser{
 
 /* Parser Options */
 private:
-    bool            __TRAIN__;
-    bool            __TEST__;
+  bool      __TRAIN__;
+  bool      __TEST__;
 
 public:
-    Parser();
+  Parser();
 
-    Parser( ConfigParser& cfg );
+  Parser( ConfigParser& cfg );
 
-    ~Parser();
+  ~Parser();
 
-    bool operator! () const {
-        return _valid;
-    }
+  bool operator! () const {
+    return _valid;
+  }
 
-    void run() {
-        /* running train process */
-        if (__TRAIN__) {
-            train();
-        }
+  void run() {
+    /* running train process */
+    if (__TRAIN__) {
+      train();
+    }
 
-        /* running test process */
-        if (__TEST__) {
-            test();
-        }
+    /* running test process */
+    if (__TEST__) {
+      test();
     }
+  }
 
 private:
-    bool _valid; /* indicating if the parser is valid */
-    vector<Instance *> train_dat;
+  bool _valid; /* indicating if the parser is valid */
+  vector<Instance *> train_dat;
 
 protected:
-    Model * model;
-    Decoder * decoder;
+  Model * model;
+  Decoder * decoder;
 private:
-    void init_opt();
+  void init_opt();
 
-    bool parse_cfg(ConfigParser& cfg);
+  bool parse_cfg(ConfigParser& cfg);
 
-    bool read_instances(const char * filename, vector<Instance *>& dat);
+  bool read_instances(const char * filename, vector<Instance *>& dat);
 
-    void build_feature_space(void);
+  void build_feature_space(void);
 
-    void build_feature_space_truncate(Model * m);
+  void build_feature_space_truncate(Model * m);
 
-    void build_configuration(void);
+  void build_configuration(void);
 
-    void extract_features(vector<Instance *>& dat);
+  void extract_features(vector<Instance *>& dat);
 
-    void build_gold_features(void);
+  void build_gold_features(void);
 
-    void train(void);
+  void train(void);
 
-    void evaluate(void);
+  void evaluate(double &las,double &uas);
 
-    void test(void);
+  void test(void);
 
-    void collect_unlabeled_features_of_one_instance(Instance * inst,
-            const vector<int> & heads,
-            SparseVec & vec);
+  void collect_unlabeled_features_of_one_instance(Instance * inst,
+                                                  const vector<int> & heads,
+                                                  SparseVec & vec);
 
-    void collect_labeled_features_of_one_instance(Instance * inst,
-            const vector<int> & heads,
-            const vector<int> & deprelsidx,
-            SparseVec & vec);
+  void collect_labeled_features_of_one_instance(Instance * inst,
+                                                const vector<int> & heads,
+                                                const vector<int> & deprelsidx,
+                                                SparseVec & vec);
 
-    void collect_features_of_one_instance(Instance * inst, 
-            bool gold = false);
+  void collect_features_of_one_instance(Instance * inst,
+                                        bool gold = false);
 
-    /*
-     * perform the feature space truncation
-     *
-     *  @param[out]     new_model   the pointer to the new model
-     *  @param[in]      gid         the index of the group.
-     */
-    void copy_featurespace(Model * new_model, int gid);
+  /*
+   * perform the feature space truncation
+   *
+   *  @param[out]   new_model   the pointer to the new model
+   *  @param[in]    gid         the index of the group.
+   *  @param[in]    nr_updates  feature group updated times
+   */
+  void copy_featurespace(Model * new_model,
+                         int gid,
+                         const int * nr_updates = NULL);
 
-    /*
-     * perform the parameter truncation.
-     *
-     *  @param[in/out]  new_model   the pointer to the output model
-     *  @param[in]      gid         the index of the group.
-     */
-    void copy_parameters(Model * new_model, int gid);
+  /*
+   * perform the parameter truncation.
+   *
+   *  @param[in/out]  new_model   the pointer to the output model
+   *  @param[in]      gid         the index of the group.
+   */
+  void copy_parameters(Model * new_model, int gid);
 
-    /*
-     * perform model truncation and return a new model
-     *
-     *  @return     Model *     pointer to the new model
-     */
-    Model * truncate();
+  /*
+   * perform model truncation and return a new model
+   *
+   *  @param[in]  nr_updates  updated time of the feature
+   *  @return     Model *     pointer to the new model
+   */
+  Model * erase_rare_features(const int * nr_updates = NULL);
 
+  /*
+   * decode the group information for feature represented in sparse vector,
+   * increase their updated time
+   *
+   *  @param[in]  vec           the feature vector
+   *  @param[out] updated_time  the updated time
+   */
+  void increase_group_updated_time(const ltp::math::SparseVec & vec,
+                                   int * feature_group_updated_time);
 protected:
-    Decoder * build_decoder(void);
-    void extract_features(Instance * inst);
+  Decoder * build_decoder(void);
+  void extract_features(Instance * inst);
 
-    void calculate_score(Instance * inst, const Parameters& param, bool use_avg = false);
+  void calculate_score(Instance * inst,
+                       const Parameters & param,
+                       bool use_avg = false);
 
 };  //  end for class Parser
 }   //  end for namespace parser
 }   //  end for namespace ltp
 
-#endif  // end for __PARSER_H__
+#endif  // end for __LTP_PARSER_PARSER_H__
diff --git a/src/parser/parser_dll.cpp b/src/parser/parser_dll.cpp
index a45adc977..52178789a 100644
--- a/src/parser/parser_dll.cpp
+++ b/src/parser/parser_dll.cpp
@@ -10,91 +10,91 @@
 
 class ParserWrapper : public ltp::parser::Parser {
 public:
-    ParserWrapper() {}
-    ~ParserWrapper() {}
+  ParserWrapper() {}
+  ~ParserWrapper() {}
 
-    bool load(const char * model_file) {
-        std::ifstream mfs(model_file, std::ifstream::binary);
+  bool load(const char * model_file) {
+    std::ifstream mfs(model_file, std::ifstream::binary);
 
-        if (!mfs) {
-            return false;
-        }
+    if (!mfs) {
+      return false;
+    }
 
-        model = new ltp::parser::Model;
-        if (!model->load(mfs)) {
-            delete model;
-            return false;
-        }
+    model = new ltp::parser::Model;
+    if (!model->load(mfs)) {
+      delete model;
+      return false;
+    }
 
-//        ltp::parser::Parser::build_decoder();
+//    ltp::parser::Parser::build_decoder();
 
-        return true;
-    }
+    return true;
+  }
 
-    int parse(const std::vector<std::string> & words,
-            const std::vector<std::string>   & postags,
+  int parse(const std::vector<std::string> & words,
+            const std::vector<std::string> & postags,
             std::vector<int> & heads,
             std::vector<std::string> & deprels) {
-        if (words.size() != postags.size()) {
-            return -1;
-        }
-
-        ltp::parser::Instance * inst = new ltp::parser::Instance;
-        inst->forms.push_back( ltp::parser::ROOT_FORM );
-        inst->postags.push_back( ltp::parser::ROOT_POSTAG );
-
-        for (int i = 0; i < words.size(); ++ i) {
-            inst->forms.push_back(words[i]);
-            inst->postags.push_back(postags[i]);
-        }
-
-        ltp::parser::Parser::extract_features(inst);
-        ltp::parser::Parser::calculate_score(inst, ltp::parser::Parser::model->param);
-
-        ltp::parser::Decoder * deco;
-        deco = build_decoder();
-        deco->decode(inst);
-
-        int len = inst->size();
-        heads.resize(len - 1);
-        deprels.resize(len - 1);
-        for (int i = 1; i < len; ++ i) {
-            heads[i - 1] = inst->predicted_heads[i];
-            deprels[i - 1] = ltp::parser::Parser::model->deprels.at(
-                    inst->predicted_deprelsidx[i]);
-        }
-
-        delete inst;
-        delete deco;
-
-        return inst->size();
+    if (words.size() != postags.size()) {
+      return -1;
+    }
+
+    ltp::parser::Instance * inst = new ltp::parser::Instance;
+    inst->forms.push_back( ltp::parser::ROOT_FORM );
+    inst->postags.push_back( ltp::parser::ROOT_POSTAG );
+
+    for (int i = 0; i < words.size(); ++ i) {
+      inst->forms.push_back(words[i]);
+      inst->postags.push_back(postags[i]);
+    }
+
+    ltp::parser::Parser::extract_features(inst);
+    ltp::parser::Parser::calculate_score(inst, ltp::parser::Parser::model->param);
+
+    ltp::parser::Decoder * deco;
+    deco = build_decoder();
+    deco->decode(inst);
+
+    int len = inst->size();
+    heads.resize(len - 1);
+    deprels.resize(len - 1);
+    for (int i = 1; i < len; ++ i) {
+      heads[i - 1] = inst->predicted_heads[i];
+      deprels[i - 1] = ltp::parser::Parser::model->deprels.at(
+          inst->predicted_deprelsidx[i]);
     }
+
+    delete inst;
+    delete deco;
+
+    return inst->size();
+  }
 };
 
 void * parser_create_parser(const char * path) {
-    ParserWrapper * wrapper = new ParserWrapper();
+  ParserWrapper * wrapper = new ParserWrapper();
 
-    if (!wrapper->load(path)) {
-        return 0;
-    }
-    return reinterpret_cast<void *>(wrapper);
+  if (!wrapper->load(path)) {
+    return 0;
+  }
+  return reinterpret_cast<void *>(wrapper);
 }
 
 int parser_release_parser(void * parser) {
-    if (!parser) {
-        return -1;
-    }
-    delete reinterpret_cast<ParserWrapper *>(parser);
-    return 0;
+  if (!parser) {
+    return -1;
+  }
+  delete reinterpret_cast<ParserWrapper *>(parser);
+  return 0;
 }
 
 int parser_parse(void * parser,
-        const std::vector<std::string> & words,
-        const std::vector<std::string> & postags,
-        std::vector<int> & heads,
-        std::vector<std::string> & deprels) {
-    // std::cout << "input str = " << str << std::endl;
-    ParserWrapper * wrapper = 0;
-    wrapper = reinterpret_cast<ParserWrapper *>(parser);
-    return wrapper->parse(words, postags, heads, deprels);
+                 const std::vector<std::string> & words,
+                 const std::vector<std::string> & postags,
+                 std::vector<int> & heads,
+                 std::vector<std::string> & deprels) {
+  // std::cout << "input str = " << str << std::endl;
+  ParserWrapper * wrapper = 0;
+  wrapper = reinterpret_cast<ParserWrapper *>(parser);
+  return wrapper->parse(words, postags, heads, deprels);
 }
diff --git a/src/parser/settings.h b/src/parser/settings.h
index 10d799ec5..df7b1a1a0 100644
--- a/src/parser/settings.h
+++ b/src/parser/settings.h
@@ -1,5 +1,5 @@
-#ifndef __SETTINGS_H__
-#define __SETTINGS_H__
+#ifndef __LTP_PARSER_SETTINGS_H__
+#define __LTP_PARSER_SETTINGS_H__
 
 #include <iostream>
 
@@ -42,19 +42,19 @@ const size_t INCMP              =   1;
 const size_t SIBSP              =   2;
 
 enum {
-    DEPU,       //  Unlabeled Standard Features
-    DEPL,       //  Labeled Standard Features
-    SIBU,       //  Unlabeled Sibling Features
-    SIBL,       //  Labeled Sibling Features
-    GRDU,       //  Unlabeled Grandchild Feature
-    GRDL,       //  Labeled Grandchild Feature
-    GRDSIBU,    //  Unlabeled Grand Sibling Features
-    GRDSIBL,
-    POSU,
-    POSB,
+  DEPU,       //  Unlabeled Standard Features
+  DEPL,       //  Labeled Standard Features
+  SIBU,       //  Unlabeled Sibling Features
+  SIBL,       //  Labeled Sibling Features
+  GRDU,       //  Unlabeled Grandchild Feature
+  GRDL,       //  Labeled Grandchild Feature
+  GRDSIBU,    //  Unlabeled Grand Sibling Features
+  GRDSIBL,
+  POSU,
+  POSB,
 };
 
 }       //  end for namespace parser
 }       //  end for namespace ltp
-#endif  //  end for __SETTINGS_H__
+#endif  //  end for __LTP_PARSER_SETTINGS_H__
 
diff --git a/src/parser/treeutils.hpp b/src/parser/treeutils.hpp
index c62903f15..ebf8e3df0 100644
--- a/src/parser/treeutils.hpp
+++ b/src/parser/treeutils.hpp
@@ -1,5 +1,5 @@
-#ifndef __TREE_UTILS_HPP__
-#define __TREE_UTILS_HPP__
+#ifndef __LTP_PARSER_TREE_UTILS_HPP__
+#define __LTP_PARSER_TREE_UTILS_HPP__
 
 #include <iostream>
 #include <vector>
@@ -14,46 +14,46 @@ namespace treeutils {
 /*
  * Get children given certain heads, complexity of is O(n)
  *
- *  @param[in]  heads           the heads
+ *  @param[in]  heads       the heads
  *  @param[out] children_left   result for left children
  *  @param[out] children_right  result for right children
  */
 inline int get_children( const std::vector<int> & heads,
-        std::vector< std::list<int> > & children_left,
-        std::vector< std::list<int> > & children_right ) {
-    int ret = 0;
-    int len = heads.size();
-
-    children_left.resize(len);
-    children_right.resize(len);
-
-    // clear each element in the output vector
-    for (int i = 0; i < len; ++ i) {
-        children_left[i].clear();
-        children_right[i].clear();
-    }
+    std::vector< std::list<int> > & children_left,
+    std::vector< std::list<int> > & children_right ) {
+  int ret = 0;
+  int len = heads.size();
 
-    for (int i = 1; i < len; ++ i) {
-        int hid = heads[i];
+  children_left.resize(len);
+  children_right.resize(len);
 
-        if (i < hid) {
-            ret ++;
-            children_left[hid].push_front(i);
-        } else {
-            children_right[hid].push_back(i);
-        }
+  // clear each element in the output vector
+  for (int i = 0; i < len; ++ i) {
+    children_left[i].clear();
+    children_right[i].clear();
+  }
+
+  for (int i = 1; i < len; ++ i) {
+    int hid = heads[i];
+
+    if (i < hid) {
+      ret ++;
+      children_left[hid].push_front(i);
+    } else {
+      children_right[hid].push_back(i);
     }
+  }
 
-    return ret;
+  return ret;
 }
 
 // Generate all the tree space in dependency
 // This class is a Python `yield` like generator
-// detail for implement can refer to 
+// detail for implement can refer to
 // http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
 /*
  * dependency tree space iterator, enumerate all posibly feature
- * 2-tuple of a tree. for example, for a tree like: 
+ * 2-tuple of a tree. for example, for a tree like:
  *
  *  [0] -> ROOT; [1] -> [2]; [2] -> [0]
  *
@@ -62,51 +62,51 @@ inline int get_children( const std::vector<int> & heads,
  */
 class DEPTreeSpaceIterator {
 public:
-    DEPTreeSpaceIterator(int len) : 
-        _len(len),
-        _hid(0), 
-        _cid(0),
-        _state(0) {
-        ++ (*this);
-    }
-
-    inline int hid(void) {
-        return _hid;
-    }
-
-    inline int cid(void) {
-        return _cid;
-    }
-
-    inline bool end(void) {
-        return _hid >= _len;
-    }
-
-    void operator ++(void) {
-        switch (_state) {
-            case 0:
-                for (_hid = 0; _hid < _len; ++ _hid) {
-                    for (_cid = 0; _cid < _len; ++ _cid) {
-                        if (_hid == _cid) {
-                            continue;
-                        }
-                        _state = 1;
-                        return;
-            case 1:;
-                    }
-                }
+  DEPTreeSpaceIterator(int len) :
+    _len(len),
+    _hid(0),
+    _cid(0),
+    _state(0) {
+    ++ (*this);
+  }
+
+  inline int hid(void) {
+    return _hid;
+  }
+
+  inline int cid(void) {
+    return _cid;
+  }
+
+  inline bool end(void) {
+    return _hid >= _len;
+  }
+
+  void operator ++(void) {
+    switch (_state) {
+      case 0:
+        for (_hid = 0; _hid < _len; ++ _hid) {
+          for (_cid = 0; _cid < _len; ++ _cid) {
+            if (_hid == _cid) {
+              continue;
+            }
+            _state = 1;
+            return;
+      case 1:;
+          }
         }
     }
+  }
 private:
-    int _len;
-    int _hid;
-    int _cid;
-    int _state;
-};      //  end for DEPIterator
+  int _len;
+  int _hid;
+  int _cid;
+  int _state;
+};    //  end for DEPIterator
 
 /*
  * sibling tree space iterator, enumerate all possible feature
- * 3-tuple of a tree. for example, for a tree like: 
+ * 3-tuple of a tree. for example, for a tree like:
  *
  *  [0] -> ROOT; [1] -> [2]; [2] -> [0]; [3] -> [2]
  *
@@ -117,68 +117,68 @@ class DEPTreeSpaceIterator {
  */
 class SIBTreeSpaceIterator {
 public:
-    SIBTreeSpaceIterator(int len, bool last_sibling = true) :
-        _len(len),
-        _last_sibling(last_sibling),
-        _hid(0),
-        _cid(0),
-        _sid(0), 
-        _step(0),
-        _end(0),
-        _state(0) {
-        ++ (*this);
-    }
-
-    inline int hid() {
-        return _hid;
-    }
-
-    inline int cid() {
-        return _cid;
-    }
-
-    inline int sid() {
-        return _sid;
-    }
-
-    inline bool end() {
-        return _hid >= _len;
-    }
+  SIBTreeSpaceIterator(int len, bool last_sibling = true) :
+    _len(len),
+    _last_sibling(last_sibling),
+    _hid(0),
+    _cid(0),
+    _sid(0),
+    _step(0),
+    _end(0),
+    _state(0) {
+    ++ (*this);
+  }
+
+  inline int hid() {
+    return _hid;
+  }
+
+  inline int cid() {
+    return _cid;
+  }
+
+  inline int sid() {
+    return _sid;
+  }
+
+  inline bool end() {
+    return _hid >= _len;
+  }
+
+  void operator ++(void) {
+    switch (_state) {
+      case 0:
+        for (_hid = 0; _hid < _len; ++ _hid) {
+          for (_cid = 0; _cid < _len; ++ _cid) {
+            if (_hid == _cid) {
+              continue;
+            }
 
-    void operator ++(void) {
-        switch (_state) {
-            case 0:
-                for (_hid = 0; _hid < _len; ++ _hid) {
-                    for (_cid = 0; _cid < _len; ++ _cid) {
-                        if (_hid == _cid) {
-                            continue;
-                        }
-
-                        _step = (_hid < _cid ? 1 : -1);
-                        _end = (_last_sibling ? _cid + _step : _cid);
-                        for (_sid = _hid; _sid != _end; _sid += _step) {
-                            _state = 1;
-                            return;
-            case 1:;
-                        }
-                    }
-                }
+            _step = (_hid < _cid ? 1 : -1);
+            _end = (_last_sibling ? _cid + _step : _cid);
+            for (_sid = _hid; _sid != _end; _sid += _step) {
+              _state = 1;
+              return;
+      case 1:;
+            }
+          }
         }
     }
+  }
 private:
-    int _len;
-    int _hid;
-    int _cid;
-    int _sid;
-    int _step;
-    int _end;
-    int _state;
-    bool _last_sibling;
+  int _len;
+  int _hid;
+  int _cid;
+  int _sid;
+  int _step;
+  int _end;
+  int _state;
+  bool _last_sibling;
 };
 
 /*
  * grand tree space iterator, enumerate all possible feature
- * 3-tuple of a tree. for example, for a tree like: 
+ * 3-tuple of a tree. for example, for a tree like:
  *
  *  [0] -> ROOT; [1] -> [2]; [2] -> [0]; [3] -> [2]
  *
@@ -188,66 +188,69 @@ class SIBTreeSpaceIterator {
  */
 class GRDTreeSpaceIterator {
 public:
-    GRDTreeSpaceIterator(int len, bool no_grand = true) : 
-        _len(len), 
-        _state(0),
-        _no_grand(no_grand) {
-        ++ (*this);
-    }
-
-    inline int hid() {
-        return _hid;
-    }
-
-    inline int cid() {
-        return _cid;
-    }
-
-    inline int gid() {
-        return _gid;
-    }
-
-    bool end() {
-        return _hid >= _len;
-    }
-
-    void operator ++(void) {
-        switch(_state) {
-            case 0:
-                for (_hid = 0; _hid < _len; ++ _hid) {
-                    for (_cid = 1; _cid < _len; ++ _cid) {
-                        if (_cid == _hid) {
-                            continue;
-                        }
-                        _step = (_hid < _cid ? 1 : -1);
-                        _end = (_hid < _cid ? _len : 0);
-
-                        for (_gid = _hid; _gid != _end; _gid += _step) {
-                            if ((_gid == _hid || _gid == _cid) && !_no_grand) {
-                                continue;
-                            }
-                            _state = 1;
-                            return;
-            case 1:;
-                        }
-                    }
-                }
+  GRDTreeSpaceIterator(int len, bool no_grand = true) :
+    _hid(0),
+    _step(0),
+    _end(0),
+    _len(len),
+    _state(0),
+    _no_grand(no_grand) {
+    ++ (*this);
+  }
+
+  inline int hid() {
+    return _hid;
+  }
+
+  inline int cid() {
+    return _cid;
+  }
+
+  inline int gid() {
+    return _gid;
+  }
+
+  bool end() {
+    return _hid >= _len;
+  }
+
+  void operator ++(void) {
+    switch(_state) {
+      case 0:
+        for (_hid = 0; _hid < _len; ++ _hid) {
+          for (_cid = 1; _cid < _len; ++ _cid) {
+            if (_cid == _hid) {
+              continue;
+            }
+            _step = (_hid < _cid ? 1 : -1);
+            _end = (_hid < _cid ? _len : 0);
+
+            for (_gid = _hid; _gid != _end; _gid += _step) {
+              if ((_gid == _hid || _gid == _cid) && !_no_grand) {
+                continue;
+              }
+              _state = 1;
+              return;
+      case 1:;
+            }
+          }
         }
     }
+  }
 private:
-    int _len;
-    int _hid;
-    int _cid;
-    int _gid;
-    int _step;
-    int _end;
-    int _state;
-    bool _no_grand;
+  int _len;
+  int _hid;
+  int _cid;
+  int _gid;
+  int _step;
+  int _end;
+  int _state;
+  bool _no_grand;
 };
 
 /*
  * dependency tree iterator, enumerate all possible features
- * 2-tuple according a tree. for example, for a tree like: 
+ * 2-tuple according a tree. for example, for a tree like:
  *
  *  [0] -> ROOT; [1] -> [2]; [2] -> [0]; [3] -> [2]
  *
@@ -257,35 +260,35 @@ class GRDTreeSpaceIterator {
  */
 class DEPIterator {
 public:
-    DEPIterator(const std::vector<int> & heads) : 
-        _cid(1),
-        _len(heads.size()),
-        _heads(heads) {}
-
-    inline int hid() {
-        return _heads[_cid];
-    }
-
-    inline int cid() {
-        return _cid;
-    }
-
-    inline bool end() {
-        return _cid >= _len;
-    }
-
-    void operator ++(void) {
-        ++ _cid;
-    }
+  DEPIterator(const std::vector<int> & heads) :
+    _cid(1),
+    _len(heads.size()),
+    _heads(heads) {}
+
+  inline int hid() {
+    return _heads[_cid];
+  }
+
+  inline int cid() {
+    return _cid;
+  }
+
+  inline bool end() {
+    return _cid >= _len;
+  }
+
+  void operator ++(void) {
+    ++ _cid;
+  }
 private:
-    int _len;
-    int _cid;
-    const std::vector<int> & _heads;
+  int _len;
+  int _cid;
+  const std::vector<int> & _heads;
 };
 
 /*
  * sibling tree space iterator, enumerate all possible feature
- * 3-tuple of a tree. for example, for a tree like: 
+ * 3-tuple of a tree. for example, for a tree like:
  *
  *  [0] -> ROOT; [1] -> [0]; [2] -> [0]; [3] -> [0]
  *
@@ -295,254 +298,255 @@ class DEPIterator {
  */
 class SIBIterator {
 public:
-    SIBIterator(const std::vector<int> & heads, bool last_sibling = true) : 
-        _hid(0),
-        _state(0),
-        _last_sibling(last_sibling),
-        _len(heads.size()),
-        _heads(heads) {
+  SIBIterator(const std::vector<int> & heads, bool last_sibling = true) :
+    _hid(0),
+    _state(0),
+    _last_sibling(last_sibling),
+    _len(heads.size()),
+    _heads(heads) {
 
-        for (int dir = 0; dir < 2; ++ dir) {
-            _children[dir]  = new int *[_len];
-            _num_children[dir] = new int[_len];
+    for (int dir = 0; dir < 2; ++ dir) {
+      _children[dir]  = new int *[_len];
+      _num_children[dir] = new int[_len];
 
-            memset(_num_children[dir], 0, sizeof(int) * _len);
+      memset(_num_children[dir], 0, sizeof(int) * _len);
 
-            for (int i = 0; i < _len; ++ i) {
-                _children[dir][i]  = new int[_len];
-                _children[dir][i][_num_children[dir][i] ++] = i;
-            }
-        }
+      for (int i = 0; i < _len; ++ i) {
+        _children[dir][i]  = new int[_len];
+        _children[dir][i][_num_children[dir][i] ++] = i;
+      }
+    }
 
-        for (int i = _len - 1; i > 0; -- i) {
-            int hid = _heads[i];
-            int * children = _children[0][hid];
-            if (i < hid) {
-                children[_num_children[0][hid] ++] = i;
-            }
-        }
+    for (int i = _len - 1; i > 0; -- i) {
+      int hid = _heads[i];
+      int * children = _children[0][hid];
+      if (i < hid) {
+        children[_num_children[0][hid] ++] = i;
+      }
+    }
 
-        for (int i = 1; i < _len; ++ i) {
-            int hid = _heads[i];
-            int * children = _children[1][hid];
-            if (i > hid) {
-                children[_num_children[1][hid] ++] = i;
-            }
-        }
+    for (int i = 1; i < _len; ++ i) {
+      int hid = _heads[i];
+      int * children = _children[1][hid];
+      if (i > hid) {
+        children[_num_children[1][hid] ++] = i;
+      }
+    }
 
-        if (_last_sibling) {
-            for (int i = 0; i < _len; ++ i) {
-                for (int dir = 0; dir < 2; ++ dir) {
-                    if (_num_children[dir][i] > 1) {
-                        _children[dir][i][_num_children[dir][i]] = _children[dir][i][_num_children[dir][i] - 1];
-                        _num_children[dir][i] ++;
-                    }
-                }
-            }
+    if (_last_sibling) {
+      for (int i = 0; i < _len; ++ i) {
+        for (int dir = 0; dir < 2; ++ dir) {
+          if (_num_children[dir][i] > 1) {
+            _children[dir][i][_num_children[dir][i]] = _children[dir][i][_num_children[dir][i] - 1];
+            _num_children[dir][i] ++;
+          }
         }
+      }
+    }
 
-        ++ (*this);
+    ++ (*this);
+  }
+
+  ~SIBIterator() {
+    for (int i = 0; i < _len; ++ i) {
+      delete [](_children[0][i]);
+      delete [](_children[1][i]);
     }
 
-    ~SIBIterator() {
-        for (int i = 0; i < _len; ++ i) {
-            delete [](_children[0][i]);
-            delete [](_children[1][i]);
-        }
+    delete [](_children[0]);
+    delete [](_children[1]);
 
-        delete [](_children[0]);
-        delete [](_children[1]);
+    delete [](_num_children[0]);
+    delete [](_num_children[1]);
+  }
 
-        delete [](_num_children[0]);
-        delete [](_num_children[1]);
-    }
+  inline int hid(void) {
+    return _hid;
+  }
 
-    inline int hid(void) {
-        return _hid;
-    }
+  inline int cid(void) {
+    return _cid;
+  }
 
-    inline int cid(void) {
-        return _cid;
-    }
+  inline int sid(void) {
+    return _sid;
+  }
 
-    inline int sid(void) {
-        return _sid;
-    }
+  inline bool end(void) {
+    return _hid >= _len;
+  }
 
-    inline bool end(void) {
-        return _hid >= _len;
-    }
+  void operator ++(void) {
 
-    void operator ++(void) {
-
-        switch (_state) {
-            case 0:
-                for (_hid = 0; _hid < _len; ++ _hid) {
-                    for (_dir = 0; _dir < 2; ++ _dir) {
-                        for (_idx = 1; _idx < _num_children[_dir][_hid]; ++ _idx) {
-                            _cid = _children[_dir][_hid][_idx];
-                            _sid = _children[_dir][_hid][_idx - 1];
-                            _state = 1;
-                            return;
-            case 1:;
-                        }
-                    }
-                }
-        }
-    }
-private:
-    void debug(void) {
-        for (int i = 0; i < _len; ++ i) {
-            std::cerr << "[" << i << "] --> (";
-            for (int j = 1; j < _num_children[0][i]; ++ j) {
-                std::cerr << _children[0][i][j] << ",";
-            }
-            std::cerr << "), (";
-            for (int j = 1; j < _num_children[1][i]; ++ j) {
-                std::cerr << _children[1][i][j] << ",";
+    switch (_state) {
+      case 0:
+        for (_hid = 0; _hid < _len; ++ _hid) {
+          for (_dir = 0; _dir < 2; ++ _dir) {
+            for (_idx = 1; _idx < _num_children[_dir][_hid]; ++ _idx) {
+              _cid = _children[_dir][_hid][_idx];
+              _sid = _children[_dir][_hid][_idx - 1];
+              _state = 1;
+              return;
+      case 1:;
             }
-            std::cerr << ")" << std::endl;
+          }
         }
     }
+  }
+private:
+  void debug(void) {
+    for (int i = 0; i < _len; ++ i) {
+      std::cerr << "[" << i << "] --> (";
+      for (int j = 1; j < _num_children[0][i]; ++ j) {
+        std::cerr << _children[0][i][j] << ",";
+      }
+      std::cerr << "), (";
+      for (int j = 1; j < _num_children[1][i]; ++ j) {
+        std::cerr << _children[1][i][j] << ",";
+      }
+      std::cerr << ")" << std::endl;
+    }
+  }
 
 private:
-    int _hid;
-    int _cid;
-    int _sid;
-    int _dir;
-    int _len;
-    int _idx;
-    int _state;
-    bool _last_sibling;
-    const std::vector<int> & _heads;
-
-    int ** _children[2];
-    int *  _num_children[2];
+  int _hid;
+  int _cid;
+  int _sid;
+  int _dir;
+  int _len;
+  int _idx;
+  int _state;
+  bool _last_sibling;
+  const std::vector<int> & _heads;
+
+  int ** _children[2];
+  int *  _num_children[2];
 };
 
 class GRDIterator {
 public:
-    GRDIterator(const std::vector<int> & heads, bool no_grand = true, bool outmost_grand = true) : 
-        _hid(0),
-        _state(0),
-        _no_grand(no_grand),
-        _outmost_grand(outmost_grand),
-        _len(heads.size()),
-        _heads(heads) {
-
-        for (int dir = 0; dir < 2; ++ dir) {
-            _children[dir]  = new int *[_len];
-            _num_children[dir] = new int[_len];
-
-            memset(_num_children[dir], 0, sizeof(int) * _len);
-
-            for (int i = 0; i < _len; ++ i) {
-                _children[dir][i]  = new int[_len];
-            }
+  GRDIterator(const std::vector<int> & heads,
+              bool no_grand = true,
+              bool outmost_grand = true)
+    : _hid(0),
+      _state(0),
+      _no_grand(no_grand),
+      _outmost_grand(outmost_grand),
+      _len(heads.size()),
+      _heads(heads) {
+    for (int dir = 0; dir < 2; ++ dir) {
+      _children[dir]  = new int *[_len];
+      _num_children[dir] = new int[_len];
+
+      memset(_num_children[dir], 0, sizeof(int) * _len);
+
+      for (int i = 0; i < _len; ++ i) {
+        _children[dir][i]  = new int[_len];
+      }
+    }
+
+    for (int i = _len - 1; i > 0; -- i) {
+      int hid = _heads[i];
+      int * children = _children[1][hid];
+      if (i > hid) {
+        if (_num_children[1][hid] > 0 && outmost_grand) {
+          continue;
         }
 
-        for (int i = _len - 1; i > 0; -- i) {
-            int hid = _heads[i];
-            int * children = _children[1][hid];
-            if (i > hid) {
-                if (_num_children[1][hid] > 0 && outmost_grand) {
-                    continue;
-                }
+        children[_num_children[1][hid] ++] = i;
+      }
+    }
 
-                children[_num_children[1][hid] ++] = i;
-            }
+    for (int i = 1; i < _len; ++ i) {
+      int hid = _heads[i];
+      int * children = _children[0][hid];
+      if (i < hid) {
+        if (_num_children[0][hid] > 0 && outmost_grand) {
+          continue;
         }
 
-        for (int i = 1; i < _len; ++ i) {
-            int hid = _heads[i];
-            int * children = _children[0][hid];
-            if (i < hid) {
-                if (_num_children[0][hid] > 0 && outmost_grand) {
-                    continue;
-                }
+        children[_num_children[0][hid] ++] = i;
+      }
+    }
 
-                children[_num_children[0][hid] ++] = i;
-            }
+    if (_no_grand) {
+      for (int cid = 1; cid < _len; ++ cid) {
+        int hid = _heads[cid];
+        for (int dir = 0; dir < 2; ++ dir) {
+          if (_num_children[dir][cid] == 0) {
+            _children[dir][cid][_num_children[dir][cid] ++] = (dir ? hid : cid);
+          }
         }
+      }
+    }
 
-        if (_no_grand) {
-            for (int cid = 1; cid < _len; ++ cid) {
-                int hid = _heads[cid];
-                for (int dir = 0; dir < 2; ++ dir) {
-                    if (_num_children[dir][cid] == 0) {
-                        _children[dir][cid][_num_children[dir][cid] ++] = (dir ? hid : cid);
-                    }
-                }
-            }
-        }
+    ++ (*this);
+  }
 
-        ++ (*this);
+  ~GRDIterator() {
+    for (int i = 0; i < _len; ++ i) {
+      delete [](_children[0][i]);
+      delete [](_children[1][i]);
     }
 
-    ~GRDIterator() {
-        for (int i = 0; i < _len; ++ i) {
-            delete [](_children[0][i]);
-            delete [](_children[1][i]);
-        }
+    delete [](_children[0]);
+    delete [](_children[1]);
 
-        delete [](_children[0]);
-        delete [](_children[1]);
+    delete [](_num_children[0]);
+    delete [](_num_children[1]);
+  }
 
-        delete [](_num_children[0]);
-        delete [](_num_children[1]);
-    }
+  inline int hid(void) {
+    return _hid;
+  }
 
-    inline int hid(void) {
-        return _hid;
-    }
+  inline int cid(void) {
+    return _cid;
+  }
 
-    inline int cid(void) {
-        return _cid;
-    }
+  inline int gid(void) {
+    return _gid;
+  }
 
-    inline int gid(void) {
-        return _gid;
-    }
+  inline bool end(void) {
+    return _cid >= _len;
+  }
 
-    inline bool end(void) {
-        return _cid >= _len;
-    }
-
-    void operator ++(void) {
-        switch (_state) {
-            case 0:
-                for (_cid = 1; _cid < _len; ++ _cid) {
-                    _hid = _heads[_cid];
-                    for (_dir = 0; _dir < 2; ++ _dir) {
-                        for (_idx = 0; _idx < _num_children[_dir][_cid]; ++ _idx) {
-                            _gid = _children[_dir][_cid][_idx];
-                            _state = 1;
-                            return;
-            case 1:;
-                        }
-                    }
-                }
+  void operator ++(void) {
+    switch (_state) {
+      case 0:
+        for (_cid = 1; _cid < _len; ++ _cid) {
+          _hid = _heads[_cid];
+          for (_dir = 0; _dir < 2; ++ _dir) {
+            for (_idx = 0; _idx < _num_children[_dir][_cid]; ++ _idx) {
+              _gid = _children[_dir][_cid][_idx];
+              _state = 1;
+              return;
+      case 1:;
+            }
+          }
         }
     }
+  }
 
 private:
-    int _hid;
-    int _cid;
-    int _gid;
-    int _len;
-    int _dir;
-    int _state;
-    int _idx;
-    bool _no_grand;
-    bool _outmost_grand;
-    const std::vector<int> & _heads;
-
-    int ** _children[2];
-    int * _num_children[2];
+  int _hid;
+  int _cid;
+  int _gid;
+  int _len;
+  int _dir;
+  int _state;
+  int _idx;
+  bool _no_grand;
+  bool _outmost_grand;
+  const std::vector<int> & _heads;
+
+  int ** _children[2];
+  int * _num_children[2];
 };
 
-}       //  end for namespace treeutils
-}       //  end for namespace parser
-}       //  end for namespace ltp
+}     //  end for namespace treeutils
+}     //  end for namespace parser
+}     //  end for namespace ltp
 
-#endif  //  end for __TREE_UTILS_HPP__
+#endif  //  end for __LTP_PARSER_TREE_UTILS_HPP__
diff --git a/src/postagger/decoder.cpp b/src/postagger/decoder.cpp
index be844d117..e341030d4 100644
--- a/src/postagger/decoder.cpp
+++ b/src/postagger/decoder.cpp
@@ -3,74 +3,78 @@
 namespace ltp {
 namespace postagger {
 
-
-void Decoder::decode(Instance * inst) {
-    init_lattice(inst);
-    viterbi_decode(inst);
-    get_result(inst);
-    free_lattice();
+void
+Decoder::decode(Instance * inst) {
+  init_lattice(inst);
+  viterbi_decode(inst);
+  get_result(inst);
+  free_lattice();
 }
 
-void Decoder::init_lattice(const Instance * inst) {
-    int len = inst->size();
-    lattice.resize(len, L);
-    lattice = NULL;
+void
+Decoder::init_lattice(const Instance * inst) {
+  int len = inst->size();
+  lattice.resize(len, L);
+  lattice = NULL;
 }
 
-void Decoder::viterbi_decode(const Instance * inst) {
-    int len = inst->size();
-    for (int i = 0; i < len; ++ i) {
-        for (int l = 0; l < L; ++ l) {
-            if (i == 0) {
-                LatticeItem * item = new LatticeItem(i, l, inst->uni_scores[i][l], NULL);
-                lattice_insert(lattice[i][l], item);
-            } else {
-                for (int pl = 0; pl < L; ++ pl) {
-                    double score = 0.;
-                    const LatticeItem * prev = lattice[i-1][pl];
+void
+Decoder::viterbi_decode(const Instance * inst) {
+  int len = inst->size();
+  for (int i = 0; i < len; ++ i) {
+    for (int l = 0; l < L; ++ l) {
+      if (i == 0) {
+        LatticeItem * item = new LatticeItem(i, l, inst->uni_scores[i][l], NULL);
+        lattice_insert(lattice[i][l], item);
+      } else {
+        for (int pl = 0; pl < L; ++ pl) {
+          double score = 0.;
+          const LatticeItem * prev = lattice[i-1][pl];
 
-                    if (!prev) {
-                        continue;
-                    }
+          if (!prev) {
+            continue;
+          }
 
-                    score = inst->uni_scores[i][l] + inst->bi_scores[pl][l] + prev->score;
-                    const LatticeItem * item = new LatticeItem(i, l, score, prev);
-                    lattice_insert(lattice[i][l], item);
-                }
-            }   //  end for if i == 0
+          score = inst->uni_scores[i][l] + inst->bi_scores[pl][l] + prev->score;
+          const LatticeItem * item = new LatticeItem(i, l, score, prev);
+          lattice_insert(lattice[i][l], item);
         }
+      }   //  end for if i == 0
     }
+  }
 }
 
-void Decoder::get_result(Instance * inst) {
-    int len = inst->size();
-    const LatticeItem * best_item = NULL;
-    for (int l = 0; l < L; ++ l) {
-        if (best_item == NULL || lattice[len - 1][l]->score > best_item->score) {
-            best_item = lattice[len - 1][l];
-        }
+void
+Decoder::get_result(Instance * inst) {
+  int len = inst->size();
+  const LatticeItem * best_item = NULL;
+  for (int l = 0; l < L; ++ l) {
+    if (best_item == NULL || lattice[len - 1][l]->score > best_item->score) {
+      best_item = lattice[len - 1][l];
     }
+  }
 
-    const LatticeItem * item = best_item;
-    inst->predicted_tagsidx.resize(len);
+  const LatticeItem * item = best_item;
+  inst->predicted_tagsidx.resize(len);
 
-    while (item) {
-        inst->predicted_tagsidx[item->i] = item->l;
-        // std::cout << item->i << " " << item->l << std::endl;
-        item = item->prev;
-    }
+  while (item) {
+    inst->predicted_tagsidx[item->i] = item->l;
+    // std::cout << item->i << " " << item->l << std::endl;
+    item = item->prev;
+  }
 }
 
-void Decoder::free_lattice() {
-    int len = lattice.total_size();
-    const LatticeItem ** p = lattice.c_buf();
-    for (int i = 0; i < len; ++ i) {
-        if (p[i]) {
-            delete p[i];
-        }
+void
+Decoder::free_lattice() {
+  int len = lattice.total_size();
+  const LatticeItem ** p = lattice.c_buf();
+  for (int i = 0; i < len; ++ i) {
+    if (p[i]) {
+      delete p[i];
     }
+  }
 }
 
-}       //  end for namespace postagger
-}       //  end for namespace ltp
+}     //  end for namespace postagger
+}     //  end for namespace ltp
 
diff --git a/src/postagger/decoder.h b/src/postagger/decoder.h
index bb961cd94..46cc42658 100644
--- a/src/postagger/decoder.h
+++ b/src/postagger/decoder.h
@@ -12,53 +12,53 @@ namespace postagger {
 // data structure for lattice item
 class LatticeItem {
 public:
-    LatticeItem (int _i, int _l, double _score, const LatticeItem * _prev) : 
-        i(_i),
-        l(_l),
-        score(_score),
-        prev(_prev) {}
+  LatticeItem (int _i, int _l, double _score, const LatticeItem * _prev) 
+    : i(_i),
+      l(_l),
+      score(_score),
+      prev(_prev) {}
 
-    LatticeItem (int _l, double _score) : 
-        i(0),
-        l(_l),
-        score(_score),
-        prev(0) {}
+  LatticeItem (int _l, double _score) 
+    : i(0),
+      l(_l),
+      score(_score),
+      prev(0) {}
 
 public:
-    int                 i;
-    int                 l;
-    double              score;
-    const LatticeItem * prev;
+  int         i;
+  int         l;
+  double      score;
+  const LatticeItem * prev;
 };
 
 class Decoder {
 public:
-    Decoder (int _L) : L(_L) {}
-    void decode(Instance * inst);
+  Decoder (int _L) : L(_L) {}
+  void decode(Instance * inst);
 
 private:
-    void init_lattice(const Instance * inst);
-    void viterbi_decode(const Instance * inst);
-    void get_result(Instance * inst);
-    void free_lattice();
+  void init_lattice(const Instance * inst);
+  void viterbi_decode(const Instance * inst);
+  void get_result(Instance * inst);
+  void free_lattice();
 
 private:
-    int L;
+  int L;
 
-    math::Mat< const LatticeItem * > lattice;
+  math::Mat< const LatticeItem * > lattice;
 
-    void lattice_insert(const LatticeItem * &position, const LatticeItem * const item) {
-        if (position == NULL) {
-            position = item;
-        } else if (position->score < item->score) {
-            delete position;
-            position = item;
-        } else {
-            delete item;
-        }
+  void lattice_insert(const LatticeItem * &position, const LatticeItem * const item) {
+    if (position == NULL) {
+      position = item;
+    } else if (position->score < item->score) {
+      delete position;
+      position = item;
+    } else {
+      delete item;
     }
+  }
 };
 
-}           //  end for namespace postagger
-}           //  end for namespace ltp
-#endif      //  end for __LTP_POSTAGGER_DECODER_H__
+}       //  end for namespace postagger
+}       //  end for namespace ltp
+#endif    //  end for __LTP_POSTAGGER_DECODER_H__
diff --git a/src/postagger/extractor.cpp b/src/postagger/extractor.cpp
index c3a1ad5ca..a48a379fc 100644
--- a/src/postagger/extractor.cpp
+++ b/src/postagger/extractor.cpp
@@ -12,105 +12,105 @@ Extractor * Extractor::instance_ = 0;
 std::vector<Template *> Extractor::templates;
 
 Extractor * Extractor::extractor() {
-    if (0 == instance_) {
-        instance_ = new Extractor;
-    }
+  if (0 == instance_) {
+    instance_ = new Extractor;
+  }
 
-    return instance_;
+  return instance_;
 }
 
 int Extractor::num_templates() {
-    if (0 == instance_) {
-        instance_ = new Extractor;
-    }
+  if (0 == instance_) {
+    instance_ = new Extractor;
+  }
 
-    return templates.size();
+  return templates.size();
 }
 
 Extractor::Extractor() {
-    templates.push_back(new Template("1={c-2}"));
-    templates.push_back(new Template("2={c-1}"));
-    templates.push_back(new Template("3={c-0}"));
-    templates.push_back(new Template("4={c+1}"));
-    templates.push_back(new Template("5={c+2}"));
-    templates.push_back(new Template("6={c-1}-{c-0}"));
-    templates.push_back(new Template("7={c-0}-{c+1}"));
-    templates.push_back(new Template("8={c-1}-{c+1}"));
-    //templates.push_back(new Template("7={c-1}-{c-0}-{c+1}"));
-    //templates.push_back(new Template("9={len}"));
-    //templates.push_back(new Template("9={ch-0,0}-{ch-0,n}"));
-    // templates.push_back(new Template("10={ch-1,n}-{ch-0,0}"));
-    //templates.push_back(new Template("11={ch-0,n}-{ch+1,0}"));
-    templates.push_back(new Template("12={prefix}"));
-    templates.push_back(new Template("13={suffix}"));
-    //templates.push_back(new Template("14={ct-1}"));
-    //templates.push_back(new Template("15={ct-0}"));
-    //templates.push_back(new Template("16={ct+1}"));
-    //templates.push_back(new Template("17={dup-1}"));
-    //templates.push_back(new Template("18={dup-0}"));
-    //templates.push_back(new Template("19={dup2-2}"));
-    //templates.push_back(new Template("20={dup2-1}"));
-    //templates.push_back(new Template("21={dup2-0}"));
+  templates.push_back(new Template("1={c-2}"));
+  templates.push_back(new Template("2={c-1}"));
+  templates.push_back(new Template("3={c-0}"));
+  templates.push_back(new Template("4={c+1}"));
+  templates.push_back(new Template("5={c+2}"));
+  templates.push_back(new Template("6={c-1}-{c-0}"));
+  templates.push_back(new Template("7={c-0}-{c+1}"));
+  templates.push_back(new Template("8={c-1}-{c+1}"));
+  //templates.push_back(new Template("7={c-1}-{c-0}-{c+1}"));
+  //templates.push_back(new Template("9={len}"));
+  //templates.push_back(new Template("9={ch-0,0}-{ch-0,n}"));
+  // templates.push_back(new Template("10={ch-1,n}-{ch-0,0}"));
+  //templates.push_back(new Template("11={ch-0,n}-{ch+1,0}"));
+  templates.push_back(new Template("12={prefix}"));
+  templates.push_back(new Template("13={suffix}"));
+  //templates.push_back(new Template("14={ct-1}"));
+  //templates.push_back(new Template("15={ct-0}"));
+  //templates.push_back(new Template("16={ct+1}"));
+  //templates.push_back(new Template("17={dup-1}"));
+  //templates.push_back(new Template("18={dup-0}"));
+  //templates.push_back(new Template("19={dup2-2}"));
+  //templates.push_back(new Template("20={dup2-1}"));
+  //templates.push_back(new Template("21={dup2-0}"));
 }
 
 Extractor::~Extractor() {
-    for (int i = 0; i < templates.size(); ++ i) {
-        delete templates[i];
-    }
+  for (int i = 0; i < templates.size(); ++ i) {
+    delete templates[i];
+  }
 }
 
 int Extractor::extract1o(Instance * inst, int idx, std::vector< StringVec > & cache) {
-    int len = inst->size();
+  int len = inst->size();
 
-    if (inst->chars.size() == 0) {
-        inst->chars.resize(len);
-        for (int i = 0; i < len; ++ i) {
-            strutils::codecs::decode(inst->forms[i], inst->chars[i]);
-        }
+  if (inst->chars.size() == 0) {
+    inst->chars.resize(len);
+    for (int i = 0; i < len; ++ i) {
+      strutils::codecs::decode(inst->forms[i], inst->chars[i]);
     }
-
-    Template::Data data;
-
-    data.set( "c-2",    (idx-2 < 0 ? BOS : inst->forms[idx-2]) ); 
-    data.set( "c-1",    (idx-1 < 0 ? BOS : inst->forms[idx-1]) );
-    data.set( "c-0",    inst->forms[idx] );
-    data.set( "c+1",    (idx+1 >= len ? EOS : inst->forms[idx+1]) );
-    data.set( "c+2",    (idx+2 >= len ? EOS : inst->forms[idx+2]) );
-
-    int length = inst->forms[idx].size(); length = (length < 5 ? length : 5);
-    data.set( "len",    strutils::to_str(length));
-
-    data.set( "ch-1,n", (idx-1 < 0 ? BOC : inst->chars[idx-1][inst->chars[idx-1].size()-1]));
-    data.set( "ch-0,0", inst->chars[idx][0] );
-    data.set( "ch-0,n", inst->chars[idx][inst->chars[idx].size()-1]);
-    data.set( "ch+1,0", (idx+1 >= len ? EOC : inst->chars[idx+1][0]));
-
-    string feat;
-    feat.reserve(1024);
-
-    int N = templates.size();
-    for (int i = 0; i < N - 2; ++ i) {
-        templates[i]->render(data, feat);
-        cache[i].push_back(feat);
-    }
-
-    for (int i = N - 2; i < N; ++ i) {
-        string prefix = "";
-        string suffix = "";
-        int num_chars = inst->chars[idx].size();
-        for (int j = 0; j < num_chars && j < 3; ++ j) {
-            prefix = prefix + inst->chars[idx][j];
-            suffix = inst->chars[idx][num_chars-j-1] + suffix;
-
-            data.set( "prefix", prefix);
-            data.set( "suffix", suffix);
-
-            templates[i]->render(data, feat);
-            cache[i].push_back(feat);
-        }
+  }
+
+  Template::Data data;
+
+  data.set( "c-2",  (idx-2 < 0 ? BOS : inst->forms[idx-2]) ); 
+  data.set( "c-1",  (idx-1 < 0 ? BOS : inst->forms[idx-1]) );
+  data.set( "c-0",  inst->forms[idx] );
+  data.set( "c+1",  (idx+1 >= len ? EOS : inst->forms[idx+1]) );
+  data.set( "c+2",  (idx+2 >= len ? EOS : inst->forms[idx+2]) );
+
+  int length = inst->forms[idx].size(); length = (length < 5 ? length : 5);
+  data.set( "len",  strutils::to_str(length));
+
+  data.set( "ch-1,n", (idx-1 < 0 ? BOC : inst->chars[idx-1][inst->chars[idx-1].size()-1]));
+  data.set( "ch-0,0", inst->chars[idx][0] );
+  data.set( "ch-0,n", inst->chars[idx][inst->chars[idx].size()-1]);
+  data.set( "ch+1,0", (idx+1 >= len ? EOC : inst->chars[idx+1][0]));
+
+  string feat;
+  feat.reserve(1024);
+
+  int N = templates.size();
+  for (int i = 0; i < N - 2; ++ i) {
+    templates[i]->render(data, feat);
+    cache[i].push_back(feat);
+  }
+
+  for (int i = N - 2; i < N; ++ i) {
+    string prefix = "";
+    string suffix = "";
+    int num_chars = inst->chars[idx].size();
+    for (int j = 0; j < num_chars && j < 3; ++ j) {
+      prefix = prefix + inst->chars[idx][j];
+      suffix = inst->chars[idx][num_chars-j-1] + suffix;
+
+      data.set( "prefix", prefix);
+      data.set( "suffix", suffix);
+
+      templates[i]->render(data, feat);
+      cache[i].push_back(feat);
     }
-    return 0;
+  }
+  return 0;
 }
 
-}       //  end for namespace postagger
-}       //  end for namespace ltp
+}     //  end for namespace postagger
+}     //  end for namespace ltp
diff --git a/src/postagger/extractor.h b/src/postagger/extractor.h
index 94c144004..79b420e0b 100644
--- a/src/postagger/extractor.h
+++ b/src/postagger/extractor.h
@@ -16,18 +16,18 @@ using namespace ltp::utility;
 
 class Extractor {
 public:
-    static Extractor * extractor();
-    static int num_templates();
-    static int extract1o(Instance * inst, int idx, vector< StringVec > & cache);
+  static Extractor * extractor();
+  static int num_templates();
+  static int extract1o(Instance * inst, int idx, vector< StringVec > & cache);
 protected:
-    Extractor();
-    ~Extractor();
+  Extractor();
+  ~Extractor();
 private:
-    static Extractor * instance_;
-    static vector< Template * > templates;
+  static Extractor * instance_;
+  static vector< Template * > templates;
 };
 
-}       //  end for namespace postagger
-}       //  end for namespace ltp 
+}     //  end for namespace postagger
+}     //  end for namespace ltp 
 
 #endif  //  end for __LTP_POSTAGGER_EXTRACTOR_H__
diff --git a/src/postagger/featurespace.cpp b/src/postagger/featurespace.cpp
index e51f841b3..2537c6073 100644
--- a/src/postagger/featurespace.cpp
+++ b/src/postagger/featurespace.cpp
@@ -5,96 +5,100 @@
 namespace ltp {
 namespace postagger {
 
-FeatureSpace::FeatureSpace(int num_labels) : 
-    _num_labels(num_labels), 
+FeatureSpace::FeatureSpace(int num_labels)
+  : _num_labels(num_labels),
     _offset(0) {
-    _num_dicts = Extractor::num_templates();
-    dicts = new utility::SmartMap<int>[_num_dicts];
+  _num_dicts = Extractor::num_templates();
+  dicts = new utility::SmartMap<int>[_num_dicts];
 }
 
 FeatureSpace::~FeatureSpace(void) {
-    delete [](dicts);
+  delete [](dicts);
 }
 
 int FeatureSpace::retrieve(int tid, const char * key, bool create) {
-    int val;
-
-    if (dicts[tid].get(key, val)) {
-        return val;
-    } else {
-        if (create) {
-            val = _offset;
-            dicts[tid].set(key, val);
-            ++ _offset;
-
-            return val;
-        }
+  int val;
+
+  if (dicts[tid].get(key, val)) {
+    return val;
+  } else {
+    if (create) {
+      val = _offset;
+      dicts[tid].set(key, val);
+      ++ _offset;
+
+      return val;
     }
- 
-    return -1;
+  }
+
+  return -1;
 }
 
 int FeatureSpace::index(int tid, const char * key, int lid) {
-    int idx = retrieve(tid, key, false);
-    if (idx < 0) {
-        return -1;
-    }
+  int idx = retrieve(tid, key, false);
+  if (idx < 0) {
+    return -1;
+  }
 
-    return idx * _num_labels + lid;
+  return idx * _num_labels + lid;
 }
 
 int FeatureSpace::index(int prev_lid, int lid) {
-    return _offset * _num_labels + prev_lid * _num_labels + lid;
+  return _offset * _num_labels + prev_lid * _num_labels + lid;
+}
+
+int FeatureSpace::num_feature_groups() {
+  return _offset + _num_labels;
 }
 
 int FeatureSpace::num_features() {
-    return _offset;
+  return _offset;
 }
 
 int FeatureSpace::dim() {
-    return _offset * _num_labels + _num_labels * _num_labels;
+  return _offset * _num_labels + _num_labels * _num_labels;
 }
 
 void FeatureSpace::set_num_labels(int num_labels) {
-    _num_labels = num_labels;
+  _num_labels = num_labels;
 }
 void FeatureSpace::dump(std::ostream & ofs) {
-    char chunk[16];
-    unsigned sz = _num_dicts;
-    strncpy(chunk, "featurespace", 16);
+  char chunk[16];
+  unsigned sz = _num_dicts;
+  strncpy(chunk, "featurespace", 16);
 
-    ofs.write(chunk, 16);
-    ofs.write(reinterpret_cast<const char *>(&_offset), sizeof(int));
-    ofs.write(reinterpret_cast<const char *>(&sz), sizeof(unsigned int));
+  ofs.write(chunk, 16);
+  ofs.write(reinterpret_cast<const char *>(&_offset), sizeof(int));
+  ofs.write(reinterpret_cast<const char *>(&sz), sizeof(unsigned int));
 
-    for (int i = 0; i < _num_dicts; ++ i) {
-        dicts[i].dump(ofs);
-    }
+  for (int i = 0; i < _num_dicts; ++ i) {
+    dicts[i].dump(ofs);
+  }
 }
 
 bool FeatureSpace::load(int num_labels, std::istream & ifs) {
-    _num_labels = num_labels;
-    char chunk[16];
-    unsigned int sz;
-    ifs.read(chunk, 16);
-    if (strcmp(chunk, "featurespace")) {
-        return false;
-    }
-
-    ifs.read(reinterpret_cast<char *>(&_offset), sizeof(int));
-    ifs.read(reinterpret_cast<char *>(&sz), sizeof(unsigned int));
-
-    if (sz != _num_dicts) {
-        return false;
-    }
-
-    for (unsigned i = 0; i < sz; ++ i) {
-        if (!dicts[i].load(ifs)) {
-            return false;
-        }
+  _num_labels = num_labels;
+  char chunk[16];
+  unsigned int sz;
+  ifs.read(chunk, 16);
+  if (strcmp(chunk, "featurespace")) {
+    return false;
+  }
+
+  ifs.read(reinterpret_cast<char *>(&_offset), sizeof(int));
+  ifs.read(reinterpret_cast<char *>(&sz), sizeof(unsigned int));
+
+  if (sz != _num_dicts) {
+    return false;
+  }
+
+  for (unsigned i = 0; i < sz; ++ i) {
+    if (!dicts[i].load(ifs)) {
+      return false;
     }
+  }
 
-    return true;
+  return true;
 }
 
 }   //  end for namespace postagger
diff --git a/src/postagger/featurespace.h b/src/postagger/featurespace.h
index 72da65c3a..e89a50cba 100644
--- a/src/postagger/featurespace.h
+++ b/src/postagger/featurespace.h
@@ -11,109 +11,109 @@ namespace postagger {
 
 class FeatureSpaceIterator {
 public:
-    FeatureSpaceIterator() : 
-        _dicts(NULL),
-        _i(0),
-        _state(0) {
-        // should be careful about the empty dicts
+  FeatureSpaceIterator()
+    : _dicts(NULL),
+      _i(0),
+      _state(0) {
+    // should be careful about the empty dicts
+  }
+
+  FeatureSpaceIterator(utility::SmartMap<int> * dicts,int num_dicts)
+    : _dicts(dicts),
+      _num_dicts(num_dicts),
+      _i(0),
+      _state(0) {
+    ++ (*this);
+  }
+
+  ~FeatureSpaceIterator() {
+  }
+
+  const char * key() { return _j.key(); }
+  int id() { return (*_j.value()); }
+  int tid() { return _i; }
+
+  bool operator ==(const FeatureSpaceIterator & other) const {
+    return ((_dicts + _i) == other._dicts);
+  }
+
+  bool operator !=(const FeatureSpaceIterator & other) const {
+    return ((_dicts + _i) != other._dicts);
+  }
+
+  FeatureSpaceIterator & operator = (const FeatureSpaceIterator & other) {
+    if (this != &other) {
+      _dicts  = other._dicts;
+      _i    = other._i;
+      _state  = other._state;
     }
 
-    FeatureSpaceIterator(utility::SmartMap<int> * dicts,int num_dicts) : 
-        _dicts(dicts),
-	_num_dicts(num_dicts), 
-        _i(0), 
-        _state(0) {
-        ++ (*this);
-    }
-
-    ~FeatureSpaceIterator() {
-    }
-
-    const char * key() { return _j.key(); }
-    int id() { return (*_j.value()); }
-    int tid() { return _i; }
-
-    bool operator ==(const FeatureSpaceIterator & other) const { return ((_dicts + _i) == other._dicts); }
-    bool operator !=(const FeatureSpaceIterator & other) const { return ((_dicts + _i) != other._dicts); }
-
-    FeatureSpaceIterator & operator = (const FeatureSpaceIterator & other) {
-        if (this != &other) {
-            _dicts  = other._dicts;
-            _i      = other._i;
-            _state  = other._state;
+    return *this;
+  }
+
+  void operator ++() {
+    switch (_state) {
+      case 0:
+        for (_i = 0; _i < _num_dicts; ++ _i) {
+          for (_j = _dicts[_i].begin(); _j != _dicts[_i].end(); ++ _j) {
+            _state = 1;
+            return;
+      case 1:;
+          }
         }
-
-        return *this;
     }
+  }
 
-    void operator ++() {
-        switch (_state) {
-            case 0:
-                for (_i = 0;_i<_num_dicts ; ++ _i) {
-                    /*if (_dicts[_i].begin() == _dicts[_i].end()) {
-                        _state = 1;
-                        //return;
-			continue;
-                    }*/
-                    for (_j = _dicts[_i].begin(); _j != _dicts[_i].end(); ++ _j) {
-                        _state = 1;
-                        return;
-            case 1:;
-                    }
-                }
-        }
-    }
-
-    int _i;
-    int _state;
-    int _num_dicts;
-    utility::SmartMap<int>::const_iterator  _j;
-    utility::SmartMap<int> * _dicts;
+  int _i;
+  int _state;
+  int _num_dicts;
+  utility::SmartMap<int>::const_iterator  _j;
+  utility::SmartMap<int> * _dicts;
 };
 
 class FeatureSpace {
 public:
-    FeatureSpace(int num_labels = 1);
-    ~FeatureSpace();
-
-    int retrieve(int tid, const char * key, bool create);
-    int index(int tid, const char * key, int lid = 0);
-    int index(int prev_lid, int lid);
-    int num_features();
-    int dim();
-    void set_num_labels(int num_labeles);
-    int get_offset();
-
-    /*
-     * dump the feature space to a output stream
-     *
-     *  @param[in]  ofs     the output stream
-     */
-    void dump(std::ostream & ofs);
-
-    /*
-     * load the feature space from a input stream
-     *
-     *  @param[in]  num_labels  the number of labels
-     *  @param[in]  ifs         the input stream
-     */
-    bool load(int num_labeles, std::istream & ifs);
-
-    FeatureSpaceIterator begin() {
-        return FeatureSpaceIterator(dicts,_num_dicts);
-    }
-
-    FeatureSpaceIterator end() {
-        return FeatureSpaceIterator(dicts + _num_dicts,_num_dicts);
-    }
+  FeatureSpace(int num_labels = 1);
+  ~FeatureSpace();
+
+  int retrieve(int tid, const char * key, bool create);
+  int index(int tid, const char * key, int lid = 0);
+  int index(int prev_lid, int lid);
+  int num_features();
+  int dim();
+  void set_num_labels(int num_labeles);
+  int num_feature_groups();
+
+  /*
+   * dump the feature space to a output stream
+   *
+   *  @param[in]  ofs   the output stream
+   */
+  void dump(std::ostream & ofs);
+
+  /*
+   * load the feature space from a input stream
+   *
+   *  @param[in]  num_labels  the number of labels
+   *  @param[in]  ifs     the input stream
+   */
+  bool load(int num_labeles, std::istream & ifs);
+
+  FeatureSpaceIterator begin() {
+    return FeatureSpaceIterator(dicts,_num_dicts);
+  }
+
+  FeatureSpaceIterator end() {
+    return FeatureSpaceIterator(dicts + _num_dicts,_num_dicts);
+  }
 
 private:
-    int _offset;
-    int _num_dicts;
-    int _num_labels;
-    utility::SmartMap<int> * dicts;
+  int _offset;
+  int _num_dicts;
+  int _num_labels;
+  utility::SmartMap<int> * dicts;
 };
 
-}       //  end for namespace postagger
-}       //  end for namespace ltp
+}     //  end for namespace postagger
+}     //  end for namespace ltp
 #endif  //  end for __LTP_POSTAGGER_FEATURE_SPACE_H__
diff --git a/src/postagger/featurevec.h b/src/postagger/featurevec.h
index 81e2ee73c..38c937006 100644
--- a/src/postagger/featurevec.h
+++ b/src/postagger/featurevec.h
@@ -6,33 +6,33 @@ namespace postagger {
 
 struct FeatureVector {
 public:
-    FeatureVector () : n(0), idx(0), val(0) {
-    }
+  FeatureVector () : n(0), idx(0), val(0) {
+  }
 
-    ~FeatureVector() {
-    }
+  ~FeatureVector() {
+  }
 
-    void clear() {
-        if (idx) {
-            delete [](idx);
-            idx = 0;
-        }
+  void clear() {
+    if (idx) {
+      delete [](idx);
+      idx = 0;
+    }
 
-        if (val) {
-            delete [](val);
-            val = 0;
-        }
+    if (val) {
+      delete [](val);
+      val = 0;
     }
+  }
 
 
 public:
-    int      n;
-    int *    idx;
-    double * val;
-    int      loff;
+  int       n;
+  int *     idx;
+  double *  val;
+  int       loff;
 };
 
-}       //  end for namespace postagger
-}       //  end for namespace ltp
+}     //  end for namespace postagger
+}     //  end for namespace ltp
 
 #endif  //  end for __LTP_POSTAGGER_FEATRUE_VECTOR_H__
diff --git a/src/postagger/instance.h b/src/postagger/instance.h
index 1ebc7bb8a..acc0a4546 100644
--- a/src/postagger/instance.h
+++ b/src/postagger/instance.h
@@ -11,70 +11,69 @@ namespace postagger {
 
 class Instance {
 public:
-    Instance() {}
-
-    ~Instance() {
-        int len = 0;
-        if ((len = uni_features.total_size()) > 0) {
-            int d1 = uni_features.nrows();
-            int d2 = uni_features.ncols();
-
-            for (int i = 0; i < d1; ++ i) {
-                if (uni_features[i][0]) {
-                    uni_features[i][0]->clear();
-                }
-                for (int j = 0; j < d2; ++ j) {
-                    if (uni_features[i][j]) {
-                        delete uni_features[i][j];
-                    }
-                }
-            }
-        }
-    }
+  Instance() {}
 
-    inline size_t size() const {
-        return forms.size();
-    }
+  ~Instance() {
+    if (uni_features.total_size() > 0) {
+      int d1 = uni_features.nrows();
+      int d2 = uni_features.ncols();
 
-    int num_errors() {
-        int len = size();
-        if ((len != tagsidx.size()) || (len != predicted_tagsidx.size())) {
-            return -1;
+      for (int i = 0; i < d1; ++ i) {
+        if (uni_features[i][0]) {
+          uni_features[i][0]->clear();
         }
-
-        int ret = 0;
-        for (int i = 0; i < len; ++ i) {
-            if (tagsidx[i] != predicted_tagsidx[i]) {
-                ++ ret;
-            }
+        for (int j = 0; j < d2; ++ j) {
+          if (uni_features[i][j]) {
+            delete uni_features[i][j];
+          }
         }
+      }
+    }
+  }
+
+  inline size_t size() const {
+    return forms.size();
+  }
 
-        return ret;
+  int num_errors() {
+    int len = size();
+    if ((len != tagsidx.size()) || (len != predicted_tagsidx.size())) {
+      return -1;
     }
 
-    int num_corrected_predicted_tags() {
-        return size() - num_errors();
+    int ret = 0;
+    for (int i = 0; i < len; ++ i) {
+      if (tagsidx[i] != predicted_tagsidx[i]) {
+        ++ ret;
+      }
     }
 
+    return ret;
+  }
+
+  int num_corrected_predicted_tags() {
+    return size() - num_errors();
+  }
+
 public:
-    std::vector< std::string > raw_forms;
-    std::vector< std::string > forms;
-    std::vector< std::string > tags;
-    std::vector< int >         tagsidx;
-    std::vector< std::string > predicted_tags;
-    std::vector< int >         predicted_tagsidx;
+  std::vector< std::string >  raw_forms;
+  std::vector< std::string >  forms;
+  std::vector< std::string >  tags;
+  std::vector< int >          tagsidx;
+  std::vector< std::string >  predicted_tags;
+  std::vector< int >          predicted_tagsidx;
 
-    math::SparseVec             features;                   /*< the gold features */
-    math::SparseVec             predicted_features;         /*< the predicted features */
+  math::SparseVec             features;           /*< the gold features */
+  math::SparseVec             predicted_features; /*< the predicted features */
 
-    math::Mat< FeatureVector *> uni_features;
-    math::Mat< double > uni_scores;
-    math::Mat< double > bi_scores;
+  math::Mat< FeatureVector *> uni_features;
+  math::Mat< double > uni_scores;
+  math::Mat< double > bi_scores;
 
-    std::vector< std::vector< std::string> > chars;
+  std::vector< std::vector< std::string> > chars;
 };
 
-}       //  end for namespace postagger
-}       //  end for namespace ltp
+}     //  end for namespace postagger
+}     //  end for namespace ltp
 
 #endif  //  end for __LTP_POSTAGGER_INSTANCE_H__
diff --git a/src/postagger/model.cpp b/src/postagger/model.cpp
index 92f94ce9a..2eb510635 100644
--- a/src/postagger/model.cpp
+++ b/src/postagger/model.cpp
@@ -10,64 +10,64 @@ Model::~Model() {
 }
 
 void Model::save(std::ostream & ofs) {
-    // write a signature into the file
-    char chunk[16] = {'o','t','c','w','s', '\0'};
-    ofs.write(chunk, 16);
+  // write a signature into the file
+  char chunk[16] = {'o','t','p','o','s', '\0'};
+  ofs.write(chunk, 16);
 
-    int off = ofs.tellp();
+  int off = ofs.tellp();
 
-    unsigned labels_offset      = 0;
-    unsigned feature_offset     = 0;
-    unsigned parameter_offset   = 0;
+  unsigned labels_offset    = 0;
+  unsigned feature_offset   = 0;
+  unsigned parameter_offset = 0;
 
-    write_uint(ofs, 0); //  the label offset
-    write_uint(ofs, 0); //  the features offset
-    write_uint(ofs, 0); //  the parameter offset
+  write_uint(ofs, 0); //  the label offset
+  write_uint(ofs, 0); //  the features offset
+  write_uint(ofs, 0); //  the parameter offset
 
-    labels_offset = ofs.tellp();
-    labels.dump(ofs);
+  labels_offset = ofs.tellp();
+  labels.dump(ofs);
 
-    feature_offset = ofs.tellp();
-    space.dump(ofs);
+  feature_offset = ofs.tellp();
+  space.dump(ofs);
 
-    parameter_offset = ofs.tellp();
-    param.dump(ofs);
+  parameter_offset = ofs.tellp();
+  param.dump(ofs);
 
-    ofs.seekp(off);
-    write_uint(ofs, labels_offset);
-    write_uint(ofs, feature_offset);
-    write_uint(ofs, parameter_offset);
+  ofs.seekp(off);
+  write_uint(ofs, labels_offset);
+  write_uint(ofs, feature_offset);
+  write_uint(ofs, parameter_offset);
 }
 
 bool Model::load(std::istream & ifs) {
-    char chunk[16];
-    ifs.read(chunk, 16);
+  char chunk[16];
+  ifs.read(chunk, 16);
 
-    if (strcmp(chunk, "otcws")) {
-        return false;
-    }
+  if (strcmp(chunk, "otpos")) {
+    return false;
+  }
 
-    unsigned labels_offset = read_uint(ifs);
-    unsigned feature_offset = read_uint(ifs);
-    unsigned parameter_offset = read_uint(ifs);
+  unsigned labels_offset    = read_uint(ifs);
+  unsigned feature_offset   = read_uint(ifs);
+  unsigned parameter_offset = read_uint(ifs);
 
-    ifs.seekg(labels_offset);
-    if (!labels.load(ifs)) {
-        return false;
-    }
+  ifs.seekg(labels_offset);
+  if (!labels.load(ifs)) {
+    return false;
+  }
 
-    ifs.seekg(feature_offset);
-    if (!space.load(labels.size(), ifs)) {
-        return false;
-    }
+  ifs.seekg(feature_offset);
+  if (!space.load(labels.size(), ifs)) {
+    return false;
+  }
 
-    ifs.seekg(parameter_offset);
-    if (!param.load(ifs)) {
-        return false;
-    }
+  ifs.seekg(parameter_offset);
+  if (!param.load(ifs)) {
+    return false;
+  }
 
-    return true;
+  return true;
 }
 
-}       //  end for namespace postagger
-}       //  end for namespace ltp
+}     //  end for namespace postagger
+}     //  end for namespace ltp
diff --git a/src/postagger/model.h b/src/postagger/model.h
index a1a7ed4b4..fac743909 100644
--- a/src/postagger/model.h
+++ b/src/postagger/model.h
@@ -13,49 +13,49 @@ using namespace ltp::utility;
 
 class Model {
 public:
-    Model();
-    ~Model();
-
-    /*
-     * get number of labels;
-     *
-     *  @return     int     the number of labels
-     */
-    inline int num_labels(void) {
-        return labels.size();
-    }
-
-    /*
-     * save the model to a output stream
-     *
-     *  @param[out] ofs     the output stream
-     */
-    void save(std::ostream & ofs);
-
-    /*
-     * load the model from an input stream
-     *
-     *  @param[in]  ifs     the input stream
-     */
-    bool load(std::istream & ifs);
+  Model();
+  ~Model();
+
+  /*
+   * get number of labels;
+   *
+   *  @return   int   the number of labels
+   */
+  inline int num_labels(void) {
+    return labels.size();
+  }
+
+  /*
+   * save the model to a output stream
+   *
+   *  @param[out] ofs   the output stream
+   */
+  void save(std::ostream & ofs);
+
+  /*
+   * load the model from an input stream
+   *
+   *  @param[in]  ifs   the input stream
+   */
+  bool load(std::istream & ifs);
 public:
-    IndexableSmartMap   labels;
-    FeatureSpace        space;
-    Parameters          param;
+  IndexableSmartMap   labels;
+  FeatureSpace        space;
+  Parameters          param;
 
 private:
-    void write_uint(std::ostream & out, unsigned int val) {
-        out.write(reinterpret_cast<const char *>(&val), sizeof(unsigned int));
-    }
-
-    unsigned int read_uint(std::istream & in) {
-        char p[4];
-        in.read(reinterpret_cast<char*>(p), sizeof(unsigned int));
-        return *reinterpret_cast<const unsigned int*>(p);
-    }
+  void write_uint(std::ostream & out, unsigned int val) {
+    out.write(reinterpret_cast<const char *>(&val), sizeof(unsigned int));
+  }
+
+  unsigned int read_uint(std::istream & in) {
+    char p[4];
+    in.read(reinterpret_cast<char*>(p), sizeof(unsigned int));
+    return *reinterpret_cast<const unsigned int*>(p);
+  }
 };
 
-}       //  end for namespace postagger
-}       //  end for namespace ltp
+}     //  end for namespace postagger
+}     //  end for namespace ltp
 
 #endif  //  end for __LTP_POSTAGGER_MODEL_H__
diff --git a/src/postagger/options.h b/src/postagger/options.h
index 4942c4cd2..9befcd40b 100644
--- a/src/postagger/options.h
+++ b/src/postagger/options.h
@@ -7,25 +7,26 @@ namespace ltp {
 namespace postagger {
 
 struct ModelOptions {
-    std::string     model_file;
+  std::string   model_file;
 };
 
 struct TrainOptions {
-    std::string     train_file;
-    std::string     holdout_file;
-    std::string     model_name;
-    std::string     algorithm;
-    int             max_iter;
-    int             display_interval;
+  std::string   train_file;
+  std::string   holdout_file;
+  std::string   model_name;
+  std::string   algorithm;
+  int           max_iter;
+  int           display_interval;
+  int           rare_feature_threshold;
 };
 
 struct TestOptions {
-    std::string     test_file;
-    std::string     model_file;
+  std::string   test_file;
+  std::string   model_file;
 };
 
 struct DumpOptions {
-    std::string     model_file;
+  std::string   model_file;
 };
 
 extern ModelOptions model_opt;
@@ -33,7 +34,7 @@ extern TrainOptions train_opt;
 extern TestOptions  test_opt;
 extern DumpOptions  dump_opt;
 
-}           //  end for namespace postagger
-}           //  end for namespace ltp
+}       //  end for namespace postagger
+}       //  end for namespace ltp
 
-#endif      //  end for __LTP_POSTAGGER_OPTIONS_H__
+#endif    //  end for __LTP_POSTAGGER_OPTIONS_H__
diff --git a/src/postagger/otpos.cpp b/src/postagger/otpos.cpp
index 157776b48..35d80cd45 100644
--- a/src/postagger/otpos.cpp
+++ b/src/postagger/otpos.cpp
@@ -7,26 +7,28 @@ using namespace ltp::utility;
 using namespace ltp::postagger;
 
 void usage(void) {
-    std::cerr << "otpos - Training and testing suite for Part of Speech Tagging" << std::endl;
-    std::cerr << "Copyright (C) 2012-2013 HIT-SCIR" << std::endl;
-    std::cerr << std::endl;
-    std::cerr << "usage: ./otpos <config_file>" << std::endl;
-    std::cerr << std::endl;
+  std::cerr << "otpos - Training and testing suite for Part of Speech Tagging"
+            << std::endl;
+  std::cerr << "Copyright (C) 2012-2014 HIT-SCIR" << std::endl;
+  std::cerr << std::endl;
+  std::cerr << "usage: ./otpos <config_file>" << std::endl;
+  std::cerr << std::endl;
 }
 
 int main(int argc, const char * argv[]) {
-    if (argc < 2) {
-        return -1;
-    }
+  if (argc < 2) {
+    usage();
+    return -1;
+  }
 
-    ConfigParser cfg(argv[1]);
+  ConfigParser cfg(argv[1]);
 
-    if (!cfg) {
-        ERROR_LOG("Failed to parse config file.");
-        return -1;
-    }
+  if (!cfg) {
+    ERROR_LOG("Failed to parse config file.");
+    return -1;
+  }
 
-    Postagger engine(cfg);
-    engine.run();
-    return 0;
+  Postagger engine(cfg);
+  engine.run();
+  return 0;
 }
diff --git a/src/postagger/parameter.h b/src/postagger/parameter.h
index 0a2f00adb..1d968d379 100644
--- a/src/postagger/parameter.h
+++ b/src/postagger/parameter.h
@@ -12,141 +12,141 @@ using namespace ltp::math;
 
 class Parameters {
 public:
-    int _dim;
-    double * _W;
-    double * _W_sum;
-    int *    _W_time;
-
-    Parameters() :
-        _dim(0),
-        _W(0),
-        _W_sum(0),
-        _W_time(0) {}
-
-    ~Parameters() {
-        dealloc();
+  int _dim;
+  double * _W;
+  double * _W_sum;
+  int *    _W_time;
+
+  Parameters()
+    : _dim(0),
+      _W(0),
+      _W_sum(0),
+      _W_time(0) {}
+
+  ~Parameters() {
+    dealloc();
+  }
+
+  void realloc(int dim) {
+    dealloc();
+    _dim = dim;
+
+    if (dim > 0) {
+      _W = new double[dim];
+      _W_sum = new double[dim];
+      _W_time = new int[dim];
     }
 
-    void realloc(int dim) {
-        dealloc();
-        _dim = dim;
-
-        if (dim > 0) {
-            _W = new double[dim];
-            _W_sum = new double[dim];
-            _W_time = new int[dim];
-        }
-
-        for (int i = 0; i < dim; ++ i) {
-            _W[i] = 0;
-            _W_sum[i] = 0;
-            _W_time[i] = 0;
-        }
+    for (int i = 0; i < dim; ++ i) {
+      _W[i] = 0;
+      _W_sum[i] = 0;
+      _W_time[i] = 0;
     }
-
-    void dealloc() {
-        if (_W && _W == _W_sum) {
-            delete [](_W);
-            _W = 0;
-            _W_sum = 0;
-        } else {
-            if (_W) {
-                delete [](_W);
-                _W = 0;
-            }
-            if (_W_sum) {
-                delete [](_W_sum);
-                _W_sum = 0;
-            }
-        }
-
-        if (_W_time) {
-            delete [](_W_time);
-            _W_time = 0;
-        }
+  }
+
+  void dealloc() {
+    if (_W && _W == _W_sum) {
+      delete [](_W);
+      _W = 0;
+      _W_sum = 0;
+    } else {
+      if (_W) {
+        delete [](_W);
+        _W = 0;
+      }
+      if (_W_sum) {
+        delete [](_W_sum);
+        _W_sum = 0;
+      }
     }
 
-    void add(const SparseVec & vec, int now, double scale = 1.) {
-        for (SparseVec::const_iterator itx = vec.begin();
-                itx != vec.end();
-                itx ++) {
-            int idx = itx->first;
-            int elapsed = now - _W_time[idx];
-            double upd = scale * itx->second;
-            double cur_val = _W[idx];
-
-            _W[idx]         = cur_val + upd;
-            _W_sum[idx]    += elapsed * cur_val + upd;
-            _W_time[idx]    = now;
-        }
+    if (_W_time) {
+      delete [](_W_time);
+      _W_time = 0;
     }
-
-    double dot(const SparseVec & vec, bool use_avg = false) const {
-        const double * const p = (use_avg ? _W_sum : _W);
-        double ret = 0.;
-        for (SparseVec::const_iterator itx = vec.begin();
-                itx != vec.end();
-                ++ itx) {
-            ret += p[itx->first] * itx->second;
-        }
-        return ret;
+  }
+
+  void add(const SparseVec & vec, int now, double scale = 1.) {
+    for (SparseVec::const_iterator itx = vec.begin();
+        itx != vec.end();
+        ++ itx) {
+      int idx = itx->first;
+      int elapsed = now - _W_time[idx];
+      double upd = scale * itx->second;
+      double cur_val = _W[idx];
+
+      _W[idx]     = cur_val + upd;
+      _W_sum[idx]  += elapsed * cur_val + upd;
+      _W_time[idx]  = now;
     }
-
-    double dot(const FeatureVector * vec, bool use_avg = false) const {
-        const double * const p = (use_avg ? _W_sum : _W);
-        double ret = 0.;
-        for (int i = 0; i < vec->n; ++ i) {
-            if (vec->val) {
-                ret += p[vec->idx[i] + vec->loff] * vec->val[i];
-            } else {
-                ret += p[vec->idx[i] + vec->loff];
-            }
-        }
-        return ret;
+  }
+
+  double dot(const SparseVec & vec, bool use_avg = false) const {
+    const double * const p = (use_avg ? _W_sum : _W);
+    double ret = 0.;
+    for (SparseVec::const_iterator itx = vec.begin();
+        itx != vec.end();
+        ++ itx) {
+      ret += p[itx->first] * itx->second;
     }
-
-    double dot(const int idx, bool use_avg = false) const {
-        const double * const p = (use_avg ? _W_sum : _W);
-        return p[idx];
+    return ret;
+  }
+
+  double dot(const FeatureVector * vec, bool use_avg = false) const {
+    const double * const p = (use_avg ? _W_sum : _W);
+    double ret = 0.;
+    for (int i = 0; i < vec->n; ++ i) {
+      if (vec->val) {
+        ret += p[vec->idx[i] + vec->loff] * vec->val[i];
+      } else {
+        ret += p[vec->idx[i] + vec->loff];
+      }
     }
-
-    void flush(int now) {
-        for(int i = 0; i < _dim; ++i) {
-            _W_sum[i] += (now - _W_time[i]) * _W[i];
-            _W_time[i] = now;
-        }
+    return ret;
+  }
+
+  double dot(const int idx, bool use_avg = false) const {
+    const double * const p = (use_avg ? _W_sum : _W);
+    return p[idx];
+  }
+
+  void flush(int now) {
+    for(int i = 0; i < _dim; ++i) {
+      _W_sum[i] += (now - _W_time[i]) * _W[i];
+      _W_time[i] = now;
+    }
+  }
+
+  void dump(std::ostream & out, bool use_avg = true) {
+    const double * p = (use_avg ? _W_sum : _W);
+    char chunk[16] = {'p', 'a', 'r', 'a', 'm', 0};
+    out.write(chunk, 16);
+    out.write(reinterpret_cast<const char *>(&_dim), sizeof(int));
+    if (_dim > 0) {
+      out.write(reinterpret_cast<const char *>(p), sizeof(double) * _dim);
     }
+  }
 
-    void dump(std::ostream & out, bool use_avg = true) {
-        const double * p = (use_avg ? _W_sum : _W);
-        char chunk[16] = {'p', 'a', 'r', 'a', 'm', 0};
-        out.write(chunk, 16);
-        out.write(reinterpret_cast<const char *>(&_dim), sizeof(int));
-        if (_dim > 0) {
-            out.write(reinterpret_cast<const char *>(p), sizeof(double) * _dim);
-        }
+  bool load(std::istream & in) {
+    char chunk[16];
+    in.read(chunk, 16);
+    if (strcmp(chunk, "param")) {
+      return false;
     }
 
-    bool load(std::istream & in) {
-        char chunk[16];
-        in.read(chunk, 16);
-        if (strcmp(chunk, "param")) {
-            return false;
-        }
-
-        in.read(reinterpret_cast<char *>(&_dim), sizeof(int));
-        if (_dim > 0) {
-            _W = new double[_dim];
-            in.read(reinterpret_cast<char *>(_W), sizeof(double) * _dim);
-            _W_sum = _W;
-        }
-
-        return true;
+    in.read(reinterpret_cast<char *>(&_dim), sizeof(int));
+    if (_dim > 0) {
+      _W = new double[_dim];
+      in.read(reinterpret_cast<char *>(_W), sizeof(double) * _dim);
+      _W_sum = _W;
     }
+
+    return true;
+  }
 };
 
-}       //  end for namespace segmentor
-}       //  end for namespace ltp
+}     //  end for namespace postagger
+}     //  end for namespace ltp
 
-#endif  //  end for __LTP_SEGMENTOR_PARAMETER_H__
+#endif  //  end for __LTP_POSTAGGER_PARAMETER_H__
 
diff --git a/src/postagger/postagger.cpp b/src/postagger/postagger.cpp
index 606429a04..8f944e113 100644
--- a/src/postagger/postagger.cpp
+++ b/src/postagger/postagger.cpp
@@ -10,652 +10,741 @@
 
 #include <iostream>
 #include <fstream>
+#include <iomanip>
 
 #if _WIN32
 #include <Windows.h>
 #define sleep Sleep
-#endif    //    end for _WIN32
+#endif  //  end for _WIN32
 
 namespace ltp {
 namespace postagger {
 
-Postagger::Postagger() : 
-    model(0),
-    decoder(0) {
+Postagger::Postagger()
+  : model(0),
+    decoder(0),
+    __TRAIN__(false),
+    __TEST__(false),
+    __DUMP__(false) {
 }
 
-Postagger::Postagger(ltp::utility::ConfigParser & cfg) :
-    model(0), 
-    decoder(0) {
-    parse_cfg(cfg);
+Postagger::Postagger(ltp::utility::ConfigParser & cfg)
+  : model(0),
+    decoder(0),
+    __TRAIN__(false),
+    __TEST__(false),
+    __DUMP__(false) {
+  parse_cfg(cfg);
 }
 
 Postagger::~Postagger() {
-    if (model) {
-        delete model;
-    }
+  if (model) {
+    delete model;
+  }
 
-    if (decoder) {
-        delete decoder;
-    }
+  if (decoder) {
+    delete decoder;
+  }
 }
 
 void Postagger::run(void) {
-    if (__TRAIN__) {
-        train();
-    }
+  if (__TRAIN__) {
+    train();
+  }
 
-    if (__TEST__) {
-        test();
-    }
+  if (__TEST__) {
+    test();
+  }
 
-    if (__DUMP__) {
-        dump();
+  if (__DUMP__) {
+    dump();
+  }
+
+  for (int i = 0; i < train_dat.size(); ++ i) {
+    if (train_dat[i]) {
+      delete train_dat[i];
     }
+  }
 }
 
-bool Postagger::parse_cfg(ltp::utility::ConfigParser & cfg) {
-    std::string strbuf;
-    int         intbuf;
 
-    __TRAIN__ = false;
+bool
+Postagger::parse_cfg(ltp::utility::ConfigParser & cfg) {
+  std::string strbuf;
+  int         intbuf;
 
-    train_opt.train_file    = "";
-    train_opt.holdout_file  = "";
-    train_opt.algorithm     = "pa";
-    train_opt.model_name    = "";
-    train_opt.max_iter      = 10;
-    train_opt.display_interval = 5000;
+  __TRAIN__ = false;
 
-    if (cfg.has_section("train")) {
-        TRACE_LOG("Training mode specified.");
-        __TRAIN__ = true;
+  train_opt.train_file             = "";
+  train_opt.holdout_file           = "";
+  train_opt.algorithm              = "pa";
+  train_opt.model_name             = "";
+  train_opt.max_iter               = 10;
+  train_opt.display_interval       = 5000;
+  train_opt.rare_feature_threshold = 0;
 
-        if (cfg.get("train", "train-file", strbuf)) {
-            train_opt.train_file = strbuf;
-        } else {
-            ERROR_LOG("train-file config item is not found.");
-            return false;
-        }
+  if (cfg.has_section("train")) {
+    TRACE_LOG("Training mode specified.");
+    __TRAIN__ = true;
 
-        if (cfg.get("train", "holdout-file", strbuf)) {
-            train_opt.holdout_file = strbuf;
-        } else {
-            ERROR_LOG("holdout-file config item is not found.");
-            return false;
-        }
+    if (cfg.get("train", "train-file", strbuf)) {
+      train_opt.train_file = strbuf;
+    } else {
+      ERROR_LOG("train-file config item is not found.");
+      return false;
+    }
 
-        if (cfg.get("train", "algorithm", strbuf)) {
-            train_opt.algorithm = strbuf;
-        } else {
-            WARNING_LOG("algorithm is not configed, [PA] is set as default");
-        }
+    if (cfg.get("train", "holdout-file", strbuf)) {
+      train_opt.holdout_file = strbuf;
+    } else {
+      ERROR_LOG("holdout-file config item is not found.");
+      return false;
+    }
 
-        train_opt.model_name = train_opt.train_file + "." + train_opt.algorithm;
-        if (cfg.get("train", "model-name", strbuf)) {
-            train_opt.model_name = strbuf;
-        } else {
-            WARNING_LOG("model name is not configed, [%s] is set as default",
-                    train_opt.model_name.c_str());
-        }
+    if (cfg.get("train", "algorithm", strbuf)) {
+      train_opt.algorithm = strbuf;
+    } else {
+      WARNING_LOG("algorithm is not configed, [PA] is set as default");
+    }
 
-        if (cfg.get_integer("train", "max-iter", intbuf)) {
-            train_opt.max_iter = intbuf;
-        } else {
-            WARNING_LOG("max-iter is not configed, [10] is set as default.");
-        }
+    train_opt.model_name = train_opt.train_file + "." + train_opt.algorithm;
+    if (cfg.get("train", "model-name", strbuf)) {
+      train_opt.model_name = strbuf;
+    } else {
+      WARNING_LOG("model name is not configed, [%s] is set as default",
+          train_opt.model_name.c_str());
+    }
+
+    if (cfg.get_integer("train", "max-iter", intbuf)) {
+      train_opt.max_iter = intbuf;
+    } else {
+      WARNING_LOG("max-iter is not configed, [10] is set as default.");
     }
 
-    __TEST__ = false;
+    if (cfg.get("train", "rare-feature-threshold", strbuf)) {
+      train_opt.rare_feature_threshold = atoi(strbuf.c_str());
+    } else {
+      WARNING_LOG("min_update is not configed, 10 is set as default");
+    }
+  }
 
-    test_opt.test_file = "";
-    test_opt.model_file = "";
+  __TEST__ = false;
 
-    if (cfg.has_section("test")) {
-        __TEST__ = true;
+  test_opt.test_file = "";
+  test_opt.model_file = "";
 
-        if (cfg.get("test", "test-file", strbuf)) {
-            test_opt.test_file = strbuf;
-        } else {
-            ERROR_LOG("test-file config item is not set.");
-            return false;
-        }
+  if (cfg.has_section("test")) {
+    __TEST__ = true;
 
-        if (cfg.get("test", "model-file", strbuf)) {
-            test_opt.model_file = strbuf;
-        } else {
-            ERROR_LOG("model-file is not configed. ");
-            return false;
-        }
+    if (cfg.get("test", "test-file", strbuf)) {
+      test_opt.test_file = strbuf;
+    } else {
+      ERROR_LOG("test-file config item is not set.");
+      return false;
     }
 
-    __DUMP__ = false;
-    dump_opt.model_file = "";
+    if (cfg.get("test", "model-file", strbuf)) {
+      test_opt.model_file = strbuf;
+    } else {
+      ERROR_LOG("model-file is not configed. ");
+      return false;
+    }
+  }
 
-    if (cfg.has_section("dump")) {
-        __DUMP__ = true;
+  __DUMP__ = false;
+  dump_opt.model_file = "";
 
-        if (cfg.get("dump", "model-file", strbuf)) {
-            dump_opt.model_file = strbuf;
-        } else {
-            ERROR_LOG("model-file is not configed. ");
-            return false;
-        }
+  if (cfg.has_section("dump")) {
+    __DUMP__ = true;
+
+    if (cfg.get("dump", "model-file", strbuf)) {
+      dump_opt.model_file = strbuf;
+    } else {
+      ERROR_LOG("model-file is not configed. ");
+      return false;
     }
+  }
 
-    return true;
+  return true;
 }
 
-bool Postagger::read_instance(const char * train_file) {
-    std::ifstream ifs(train_file);
+bool
+Postagger::read_instance(const char * train_file) {
+  std::ifstream ifs(train_file);
 
-    if (!ifs) {
-        return false;
-    }
+  if (!ifs) {
+    return false;
+  }
 
-    PostaggerReader reader(ifs, true);
-    train_dat.clear();
+  PostaggerReader reader(ifs, true);
+  train_dat.clear();
 
-    Instance * inst = NULL;
+  Instance * inst = NULL;
 
-    while ((inst = reader.next())) {
-        train_dat.push_back(inst);
-    }
+  while ((inst = reader.next())) {
+    train_dat.push_back(inst);
+  }
 
-    return true;
+  return true;
 }
 
+void
+Postagger::build_configuration(void) {
+  // model->labels.push( __dummy__ );
+  for (int i = 0; i < train_dat.size(); ++ i) {
+    Instance * inst = train_dat[i];
+    int len = inst->size();
 
-void Postagger::build_configuration(void) {
-    // model->labels.push( __dummy__ );
-    for (int i = 0; i < train_dat.size(); ++ i) {
-        Instance * inst = train_dat[i];
-        int len = inst->size();
-
-        inst->tagsidx.resize(len);
-        for (int j = 0; j < len; ++ j) {
-            inst->tagsidx[j] = model->labels.push( inst->tags[j] );
-        }
+    inst->tagsidx.resize(len);
+    for (int j = 0; j < len; ++ j) {
+      inst->tagsidx[j] = model->labels.push( inst->tags[j] );
     }
+  }
 }
 
-void Postagger::build_labels(Instance * inst, std::vector<std::string> & tags) {
-    int len = inst->size();
-    if (inst->predicted_tagsidx.size() != len) {
-        return;
-    }
+void
+Postagger::build_labels(Instance * inst, std::vector<std::string> & tags) {
+  int len = inst->size();
+  if (inst->predicted_tagsidx.size() != len) {
+    return;
+  }
 
-    tags.resize(len);
-    for (int i = 0; i < len; ++ i) {
-        tags[i] = model->labels.at(inst->predicted_tagsidx[i]);
-    }
+  tags.resize(len);
+  for (int i = 0; i < len; ++ i) {
+    tags[i] = model->labels.at(inst->predicted_tagsidx[i]);
+  }
 }
 
-void Postagger::extract_features(Instance * inst, bool create) {
-    const int N = Extractor::num_templates();
-    const int L = model->num_labels();
+void
+Postagger::extract_features(Instance * inst, bool create) {
+  const int N = Extractor::num_templates();
+  const int L = model->num_labels();
 
-    vector< StringVec > cache;
-    vector< int > cache_again;
+  vector< StringVec > cache;
+  vector< int > cache_again;
 
-    cache.resize(N);
-    int len = inst->size();
+  cache.resize(N);
+  int len = inst->size();
 
-    // allocate the uni_features
-    inst->uni_features.resize(len, L);  inst->uni_features = 0;
-    inst->uni_scores.resize(len, L);    inst->uni_scores = NEG_INF;
-    inst->bi_scores.resize(L, L);       inst->bi_scores = NEG_INF;
+  // allocate the uni_features
+  inst->uni_features.resize(len, L);  inst->uni_features = 0;
+  inst->uni_scores.resize(len, L);    inst->uni_scores = NEG_INF;
+  inst->bi_scores.resize(L, L);       inst->bi_scores = NEG_INF;
 
-    for (int pos = 0; pos < len; ++ pos) {
-        for (int n = 0; n < N; ++ n) {
-            cache[n].clear();
-        }
-        cache_again.clear();
-
-        Extractor::extract1o(inst, pos, cache);
-
-        for (int tid = 0; tid < cache.size(); ++ tid) {
-            for (int itx = 0; itx < cache[tid].size(); ++ itx) {
-                if (create) {
-                    model->space.retrieve(tid, cache[tid][itx], true);
-                }
-
-                int idx = model->space.index(tid, cache[tid][itx]);
-                // std::cout << "key: " << cache[tid][itx] << " " << idx << std::endl;
-                if (idx >= 0) {
-                    cache_again.push_back(idx);
-                }
-            }
+  for (int pos = 0; pos < len; ++ pos) {
+    for (int n = 0; n < N; ++ n) {
+      cache[n].clear();
+    }
+    cache_again.clear();
+
+    Extractor::extract1o(inst, pos, cache);
+
+    for (int tid = 0; tid < cache.size(); ++ tid) {
+      for (int itx = 0; itx < cache[tid].size(); ++ itx) {
+        if (create) {
+          model->space.retrieve(tid, cache[tid][itx], true);
         }
 
-        int num_feat = cache_again.size();
-
-        if (num_feat > 0) {
-            int l = 0;
-            int * idx = new int[num_feat];
-            for (int j = 0; j < num_feat; ++ j) {
-                idx[j] = cache_again[j];
-            }
-
-            inst->uni_features[pos][l] = new FeatureVector;
-            inst->uni_features[pos][l]->n = num_feat;
-            inst->uni_features[pos][l]->val = 0;
-            inst->uni_features[pos][l]->loff = 0;
-            inst->uni_features[pos][l]->idx = idx;
-
-            for (l = 1; l < L; ++ l) {
-                inst->uni_features[pos][l] = new FeatureVector;
-                inst->uni_features[pos][l]->n = num_feat;
-                inst->uni_features[pos][l]->idx = idx;
-                inst->uni_features[pos][l]->val = 0;
-                inst->uni_features[pos][l]->loff = l;
-            }
+        int idx = model->space.index(tid, cache[tid][itx]);
+        // std::cout << "key: " << cache[tid][itx] << " " << idx << std::endl;
+        if (idx >= 0) {
+          cache_again.push_back(idx);
         }
+      }
+    }
+
+    int num_feat = cache_again.size();
+
+    if (num_feat > 0) {
+      int l = 0;
+      int * idx = new int[num_feat];
+      for (int j = 0; j < num_feat; ++ j) {
+        idx[j] = cache_again[j];
+      }
+
+      inst->uni_features[pos][l] = new FeatureVector;
+      inst->uni_features[pos][l]->n = num_feat;
+      inst->uni_features[pos][l]->val = 0;
+      inst->uni_features[pos][l]->loff = 0;
+      inst->uni_features[pos][l]->idx = idx;
+
+      for (l = 1; l < L; ++ l) {
+        inst->uni_features[pos][l] = new FeatureVector;
+        inst->uni_features[pos][l]->n = num_feat;
+        inst->uni_features[pos][l]->idx = idx;
+        inst->uni_features[pos][l]->val = 0;
+        inst->uni_features[pos][l]->loff = l;
+      }
     }
+  }
 
 }
 
-void Postagger::build_feature_space(void) {
-    // build feature space, it a wrapper for
-    // featurespace.build_feature_space
-    int N = Extractor::num_templates();
-    int L = model->num_labels();
-    model->space.set_num_labels(L);
-
-    for (int i = 0; i < train_dat.size(); ++ i) {
-        extract_features(train_dat[i], true);
-        if ((i + 1) % train_opt.display_interval == 0) {
-            TRACE_LOG("[%d] instances is extracted.", (i+1));
-        }
+void
+Postagger::build_feature_space(void) {
+  // build feature space, it a wrapper for featurespace.build_feature_space
+  Extractor::num_templates();
+  int L = model->num_labels();
+  model->space.set_num_labels(L);
+
+  for (int i = 0; i < train_dat.size(); ++ i) {
+    extract_features(train_dat[i], true);
+    if ((i + 1) % train_opt.display_interval == 0) {
+      TRACE_LOG("[%d] instances is extracted.", (i+1));
     }
+  }
 
-    TRACE_LOG("[%d] instances is extracted.", train_dat.size());
+  TRACE_LOG("[%d] instances is extracted.", train_dat.size());
 }
 
-void Postagger::calculate_scores(Instance * inst, bool use_avg) {
-    int len = inst->size();
-    int L = model->num_labels();
-    for (int i = 0; i < len; ++ i) {
-        for (int l = 0; l < L; ++ l) {
-            FeatureVector * fv = inst->uni_features[i][l];
-            if (!fv) {
-                continue;
-            }
+void
+Postagger::calculate_scores(Instance * inst, bool use_avg) {
+  int len = inst->size();
+  int L = model->num_labels();
+  for (int i = 0; i < len; ++ i) {
+    for (int l = 0; l < L; ++ l) {
+      FeatureVector * fv = inst->uni_features[i][l];
+      if (!fv) {
+        continue;
+      }
 
-            inst->uni_scores[i][l] = model->param.dot(inst->uni_features[i][l], use_avg);
-        }
+      inst->uni_scores[i][l] = model->param.dot(inst->uni_features[i][l], use_avg);
     }
+  }
 
-    for (int pl = 0; pl < L; ++ pl) {
-        for (int l = 0; l < L; ++ l) {
-            int idx = model->space.index(pl, l);
-            inst->bi_scores[pl][l] = model->param.dot(idx, use_avg);
-        }
+  for (int pl = 0; pl < L; ++ pl) {
+    for (int l = 0; l < L; ++ l) {
+      int idx = model->space.index(pl, l);
+      inst->bi_scores[pl][l] = model->param.dot(idx, use_avg);
     }
+  }
 }
 
-void Postagger::collect_features(Instance * inst, const std::vector<int> & tagsidx, math::SparseVec & vec) {
-    int len = inst->size();
+void
+Postagger::collect_features(Instance * inst,
+                            const std::vector<int> & tagsidx,
+                            math::SparseVec & vec) {
+  int len = inst->size();
 
-    vec.zero();
-    for (int i = 0; i < len; ++ i) {
-        int l = tagsidx[i];
-        const FeatureVector * fv = inst->uni_features[i][l];
+  vec.zero();
+  for (int i = 0; i < len; ++ i) {
+    int l = tagsidx[i];
+    const FeatureVector * fv = inst->uni_features[i][l];
 
-        if (!fv) {
-            continue;
-        }
+    if (!fv) {
+      continue;
+    }
 
-        vec.add(fv->idx, fv->val, fv->n, fv->loff, 1.);
+    vec.add(fv->idx, fv->val, fv->n, fv->loff, 1.);
 
-        if (i > 0) {
-            int pl = tagsidx[i-1];
-            int idx = model->space.index(pl, l);
-            vec.add(idx, 1.);
-        }
+    if (i > 0) {
+      int pl = tagsidx[i-1];
+      int idx = model->space.index(pl, l);
+      vec.add(idx, 1.);
     }
+  }
 }
 
-Model * Postagger::truncate(void) {
-    Model * new_model = new Model;
-    // copy the label indexable map to the new model
-    for (int i = 0; i < model->labels.size(); ++ i) {
-        const char * key = model->labels.at(i);
-        new_model->labels.push(key);
-    }
-    TRACE_LOG("building labels map is done");
-
-    int L = new_model->num_labels();
-    new_model->space.set_num_labels(L);
-
-    // iterate over the feature space and see if the parameter value equals to zero
-
-    for (FeatureSpaceIterator itx = model->space.begin();
-            itx != model->space.end();
-            ++ itx) {
-        const char * key = itx.key();
-        int tid = itx.tid();
-        int id = model->space.index(tid, key);
-        bool flag = false;
-
-        for (int l = 0; l < L; ++ l) {
-            double p = model->param.dot(id + l);
-            if (p != 0.) {
-                flag = true;
-            }
-        }
+void
+Postagger::increase_group_updated_time(const math::SparseVec & vec,
+                                       int * feature_group_updated_time) {
+  int L = model->num_labels();
+  for (math::SparseVec::const_iterator itx = vec.begin();
+      itx != vec.end();
+      ++ itx) {
 
-        if (!flag) {
-            continue;
-        }
-
-        new_model->space.retrieve(tid, key, true);
+    int idx = itx->first;
+    if (itx->second != 0.0) {
+      ++ feature_group_updated_time[idx / L];
     }
+  }
+}
 
-    TRACE_LOG("Scanning old features space, building new feature space is done");
-    new_model->param.realloc(new_model->space.dim());
-    TRACE_LOG("Parameter dimension of new model is [%d]", new_model->space.dim());
 
-    for (FeatureSpaceIterator itx = new_model->space.begin();
-            itx != new_model->space.end();
-            ++ itx) {
-        const char * key = itx.key();
-        int tid = itx.tid();
+Model *
+Postagger::erase_rare_features(int * feature_group_updated_time) {
+  Model * new_model = new Model;
+  // copy the label indexable map to the new model
+  for (int i = 0; i < model->labels.size(); ++ i) {
+    const char * key = model->labels.at(i);
+    new_model->labels.push(key);
+  }
+  TRACE_LOG("building labels map is done");
 
-        int old_id = model->space.index(tid, key);
-        int new_id = new_model->space.index(tid, key);
+  int L = new_model->num_labels();
+  new_model->space.set_num_labels(L);
 
-        for (int l = 0; l < L; ++ l) {
-            // pay attention to this place, use average should be set true
-            // some dirty code
-            new_model->param._W[new_id + l] = model->param._W[old_id + l];
-            new_model->param._W_sum[new_id + l] = model->param._W_sum[old_id + l];
-            new_model->param._W_time[new_id + l] = model->param._W_time[old_id + l];
-        }
+  for (FeatureSpaceIterator itx = model->space.begin();
+      itx != model->space.end();
+      ++ itx) {
+    const char * key = itx.key();
+    int tid = itx.tid();
+    int id = model->space.index(tid, key);
+    bool flag = false;
+
+    for (int l = 0; l < L; ++ l) {
+      double p = model->param.dot(id + l);
+      if (p != 0.) {
+        flag = true;
+      }
     }
 
-    for (int pl = 0; pl < L; ++ pl) {
-        for (int l = 0; l < L; ++ l) {
-            int old_id = model->space.index(pl, l);
-            int new_id = new_model->space.index(pl, l);
+    if (!flag) {
+      continue;
+    }
 
-            new_model->param._W[new_id] = model->param._W[old_id];
-            new_model->param._W_sum[new_id] = model->param._W_sum[old_id];
-            new_model->param._W_time[new_id] = model->param._W_time[old_id];
-        }
+    int idx = model->space.retrieve(tid, key, false);
+    if (feature_group_updated_time
+        && (feature_group_updated_time[idx] < train_opt.rare_feature_threshold)) {
+      continue;
     }
-    TRACE_LOG("Building new model is done");
 
-    return new_model;
-}
+    new_model->space.retrieve(tid, key, true);
+  }
+
+  TRACE_LOG("Scanning old features space, building new feature space is done");
+  new_model->param.realloc(new_model->space.dim());
+  TRACE_LOG("Parameter dimension of new model is [%d]", new_model->space.dim());
 
-void Postagger::train(void) {
-    const char * train_file = train_opt.train_file.c_str();
+  for (FeatureSpaceIterator itx = new_model->space.begin();
+      itx != new_model->space.end();
+      ++ itx) {
+    const char * key = itx.key();
 
-    // read in training instance
-    if (!read_instance(train_file)) {
-        ERROR_LOG("Training file doesn't exist.");
+    int tid = itx.tid();
+
+    int old_id = model->space.index(tid, key);
+    int new_id = new_model->space.index(tid, key);
+
+    for (int l = 0; l < L; ++ l) {
+      // pay attention to this place, use average should be set true
+      // some dirty code
+      new_model->param._W[new_id + l]      = model->param._W[old_id + l];
+      new_model->param._W_sum[new_id + l]  = model->param._W_sum[old_id + l];
+      new_model->param._W_time[new_id + l] = model->param._W_time[old_id + l];
     }
+  }
 
-    TRACE_LOG("Read in [%d] instances.", train_dat.size());
+  for (int pl = 0; pl < L; ++ pl) {
+    for (int l = 0; l < L; ++ l) {
+      int old_id = model->space.index(pl, l);
+      int new_id = new_model->space.index(pl, l);
 
-    model = new Model;
-    // build tag dictionary, map string tag to index
-    TRACE_LOG("Start build configuration");
-    build_configuration();
-    TRACE_LOG("Build configuration is done.");
-    TRACE_LOG("Number of labels: [%d]", model->labels.size());
+      new_model->param._W[new_id]      = model->param._W[old_id];
+      new_model->param._W_sum[new_id]  = model->param._W_sum[old_id];
+      new_model->param._W_time[new_id] = model->param._W_time[old_id];
+    }
+  }
+  TRACE_LOG("Building new model is done");
 
-    // build feature space from the training instance
-    TRACE_LOG("Start building feature space.");
-    build_feature_space();
-    TRACE_LOG("Building feature space is done.");
-    TRACE_LOG("Number of features: [%d]", model->space.num_features());
+  return new_model;
+}
 
-    model->param.realloc(model->space.dim());
-    TRACE_LOG("Allocate [%d] dimensition parameter.", model->space.dim());
+void
+Postagger::train(void) {
+  const char * train_file = train_opt.train_file.c_str();
 
-    PostaggerWriter writer(cout);
+  // read in training instance
+  if (!read_instance(train_file)) {
+    ERROR_LOG("Training file doesn't exist.");
+  }
 
-    if (train_opt.algorithm == "mira") {
-        // use mira algorithm
-        /*kbest_decoder = new KBestDecoder(L);
+  TRACE_LOG("Read in [%d] instances.", train_dat.size());
 
-        for (int iter = 0; iter < train_opt.max_iter; ++ iter) {
-            for (int i = 0; i < train_dat.size(); ++ i) {
-                extract_features(train_dat[i]);
-                calculate_scores(train_dat[i]);
+  model = new Model;
+  // build tag dictionary, map string tag to index
+  TRACE_LOG("Start build configuration");
+  build_configuration();
+  TRACE_LOG("Build configuration is done.");
+  TRACE_LOG("Number of labels: [%d]", model->labels.size());
 
-                KBestDecoder::KBestDecodeResult result;
-                kbest_decoder->decode(train_dat[i], result);
-            }
-        }*/
-    } else {
-        // use pa or average perceptron algorithm
-        decoder = new Decoder(model->num_labels());
-        TRACE_LOG("Allocated plain decoder");
-
-        for (int iter = 0; iter < train_opt.max_iter; ++ iter) {
-            TRACE_LOG("Training iteraition [%d]", (iter + 1));
-            for (int i = 0; i < train_dat.size(); ++ i) {
-                // extract_features(train_dat[i]);
-
-                Instance * inst = train_dat[i];
-                calculate_scores(inst, false);
-                decoder->decode(inst);
-
-                if (inst->features.dim() == 0) {
-                    collect_features(inst, inst->tagsidx, inst->features);
-                }
-                collect_features(inst, inst->predicted_tagsidx, inst->predicted_features);
-
-                // writer.debug(inst, true);
-
-                if (train_opt.algorithm == "pa") {
-                    SparseVec update_features;
-                    update_features.zero();
-                    update_features.add(train_dat[i]->features, 1.);
-                    update_features.add(train_dat[i]->predicted_features, -1.);
-
-                    double error = train_dat[i]->num_errors();
-                    double score = model->param.dot(update_features, false);
-                    double norm = update_features.L2();
-
-                    double step = 0.;
-                    if (norm < EPS) {
-                       step = 0;
-                    } else {
-                        step = (error - score) / norm;
-                    }
-
-                    model->param.add(update_features,
-                            iter * train_dat.size() + i + 1,
-                            step);
-                } else if (train_opt.algorithm == "ap") {
-                    SparseVec update_features;
-                    update_features.zero();
-                    update_features.add(train_dat[i]->features, 1.);
-                    update_features.add(train_dat[i]->predicted_features, -1.);
-
-                    model->param.add(update_features,
-                            iter * train_dat.size() + i + 1,
-                            1.);
-                }
-
-                if ((i+1) % train_opt.display_interval == 0) {
-                    TRACE_LOG("[%d] instances is trained.", i+1);
-                }
-            }
-            TRACE_LOG("[%d] instances is trained.", train_dat.size());
-
-            model->param.flush( train_dat.size() * (iter + 1) );
-            Model * new_model = truncate();
-            swap(model, new_model);
-            evaluate();
-
-            std::string saved_model_file = (train_opt.model_name + "." + strutils::to_str(iter) + ".model");
-            std::ofstream ofs(saved_model_file.c_str(), std::ofstream::binary);
-
-            swap(model, new_model);
-            new_model->save(ofs);
-            delete new_model;
-            // model->save(ofs);
-
-            TRACE_LOG("Model for iteration [%d] is saved to [%s]",
-                    iter + 1,
-                    saved_model_file.c_str());
-        }
-    }
-}
+  // build feature space from the training instance
+  TRACE_LOG("Start building feature space.");
+  build_feature_space();
+  TRACE_LOG("Building feature space is done.");
+  TRACE_LOG("Number of features: [%d]", model->space.num_features());
 
-void Postagger::evaluate(void) {
-    const char * holdout_file = train_opt.holdout_file.c_str();
+  model->param.realloc(model->space.dim());
+  TRACE_LOG("Allocate [%d] dimensition parameter.", model->space.dim());
 
-    ifstream ifs(holdout_file);
+  int nr_feature_groups = model->space.num_feature_groups();
+  int * feature_group_updated_time = NULL;
 
-    if (!ifs) {
-        ERROR_LOG("Failed to open holdout file.");
-        return;
+  if (train_opt.rare_feature_threshold > 0) {
+    feature_group_updated_time = new int[nr_feature_groups];
+    for (int i = 0; i < nr_feature_groups; ++ i) {
+      feature_group_updated_time[i] = 0;
     }
+  }
 
-    PostaggerReader reader(ifs, true);
-    Instance * inst = NULL;
+  TRACE_LOG("Allocate [%d] update counters", nr_feature_groups);
 
-    int num_recalled_tags = 0;
-    int num_tags = 0;
+  PostaggerWriter writer(cout);
 
-    while ((inst = reader.next())) {
-        int len = inst->size();
-        inst->tagsidx.resize(len);
-        for (int i = 0; i < len; ++ i) {
-            inst->tagsidx[i] = model->labels.index(inst->tags[i]);
-        }
+  if (train_opt.algorithm == "mira") {
+    // use mira algorithm
+    // not implemented
+  } else {
+    // use pa or average perceptron algorithm
+    decoder = new Decoder(model->num_labels());
+    TRACE_LOG("Allocated plain decoder");
+
+    int best_iteration = -1;
+    double best_p = -1.;
+
+    for (int iter = 0; iter < train_opt.max_iter; ++ iter) {
+      TRACE_LOG("Training iteraition [%d]", (iter + 1));
+      for (int i = 0; i < train_dat.size(); ++ i) {
+        // extract_features(train_dat[i]);
 
-        extract_features(inst, false);
-        calculate_scores(inst, true);
+        Instance * inst = train_dat[i];
+        calculate_scores(inst, false);
         decoder->decode(inst);
 
-        num_recalled_tags += inst->num_corrected_predicted_tags();
-        num_tags += inst->size();
+        if (inst->features.dim() == 0) {
+          collect_features(inst, inst->tagsidx, inst->features);
+        }
+        collect_features(inst, inst->predicted_tagsidx, inst->predicted_features);
+
+        if (train_opt.algorithm == "pa") {
+          SparseVec update_features;
+          update_features.zero();
+          update_features.add(train_dat[i]->features, 1.);
+          update_features.add(train_dat[i]->predicted_features, -1.);
+
+          if (feature_group_updated_time) {
+            increase_group_updated_time(update_features,
+                                        feature_group_updated_time);
+          }
+
+          double error = train_dat[i]->num_errors();
+          double score = model->param.dot(update_features, false);
+          double norm = update_features.L2();
+
+          double step = 0.;
+          if (norm < EPS) {
+            step = 0;
+          } else {
+            step = (error - score) / norm;
+          }
+
+          model->param.add(update_features,
+                           iter * train_dat.size() + i + 1,
+                           step);
+
+        } else if (train_opt.algorithm == "ap") {
+          SparseVec update_features;
+          update_features.zero();
+          update_features.add(train_dat[i]->features, 1.);
+          update_features.add(train_dat[i]->predicted_features, -1.);
+
+          if (feature_group_updated_time) {
+            increase_group_updated_time(update_features,
+                                        feature_group_updated_time);
+          }
+          model->param.add(update_features,
+                           iter * train_dat.size() + i + 1,
+                           1.);
+        }
 
-        delete inst;
-    }
+        if ((i+1) % train_opt.display_interval == 0) {
+          TRACE_LOG("[%d] instances is trained.", i+1);
+        }
+      }
+      TRACE_LOG("[%d] instances is trained.", train_dat.size());
 
-    double p = (double)num_recalled_tags / num_tags;
+      model->param.flush( train_dat.size() * (iter + 1) );
 
-    TRACE_LOG("P: %lf ( %d / %d )", p, num_recalled_tags, num_tags);
-    return;
-}
+      Model * new_model = NULL;
+
+      new_model = erase_rare_features(feature_group_updated_time);
+      swap(model, new_model);
 
-void Postagger::test(void) {
-    const char * model_file = test_opt.model_file.c_str();
-    ifstream mfs(model_file, std::ifstream::binary);
+      double p;
+      evaluate(p);
 
-    if (!mfs) {
-        ERROR_LOG("Failed to load model");
-        return;
+      if(p > best_p){
+        best_p = p;
+        best_iteration = iter;
+      }
+
+      std::string saved_model_file = (train_opt.model_name
+                                      + "."
+                                      + strutils::to_str(iter)
+                                      + ".model");
+      std::ofstream ofs(saved_model_file.c_str(), std::ofstream::binary);
+
+      swap(model, new_model);
+      new_model->save(ofs);
+      delete new_model;
+
+      TRACE_LOG("Model for iteration [%d] is saved to [%s]",
+                iter + 1,
+                saved_model_file.c_str());
     }
 
-    model = new Model;
-    if (!model->load(mfs)) {
-        ERROR_LOG("Failed to load model");
-        return;
+    if (feature_group_updated_time) {
+      delete [](feature_group_updated_time);
     }
 
-    TRACE_LOG("Number of labels                 [%d]", model->num_labels());
-    TRACE_LOG("Number of features               [%d]", model->space.num_features());
-    TRACE_LOG("Number of dimension              [%d]", model->space.dim());
+    TRACE_LOG("Best result (iteration = %d) : P = %lf",
+              best_iteration,
+              best_p);
+  }
+}
 
-    const char * test_file = test_opt.test_file.c_str();
+void
+Postagger::evaluate(double &p) {
+  const char * holdout_file = train_opt.holdout_file.c_str();
 
-    ifstream ifs(test_file);
+  ifstream ifs(holdout_file);
 
-    if (!ifs) {
-        ERROR_LOG("Failed to open holdout file.");
-        return;
+  if (!ifs) {
+    ERROR_LOG("Failed to open holdout file.");
+    return;
+  }
+
+  PostaggerReader reader(ifs, true);
+  Instance * inst = NULL;
+
+  int num_recalled_tags = 0;
+  int num_tags = 0;
+
+  while ((inst = reader.next())) {
+    int len = inst->size();
+    inst->tagsidx.resize(len);
+    for (int i = 0; i < len; ++ i) {
+      inst->tagsidx[i] = model->labels.index(inst->tags[i]);
     }
 
-    decoder = new Decoder(model->num_labels());
-    PostaggerReader reader(ifs, true);
-    PostaggerWriter writer(cout);
-    Instance * inst = NULL;
+    extract_features(inst, false);
+    calculate_scores(inst, true);
+    decoder->decode(inst);
 
-    int num_recalled_tags = 0;
-    int num_tags = 0;
+    num_recalled_tags += inst->num_corrected_predicted_tags();
+    num_tags += inst->size();
 
-    double before = get_time();
+    delete inst;
+  }
 
-    while ((inst = reader.next())) {
-        int len = inst->size();
-        inst->tagsidx.resize(len);
-        for (int i = 0; i < len; ++ i) {
-            inst->tagsidx[i] = model->labels.index(inst->tags[i]);
-        }
+  p = (double)num_recalled_tags / num_tags;
 
-        extract_features(inst);
-        calculate_scores(inst, true);
-        decoder->decode(inst);
+  TRACE_LOG("P: %lf ( %d / %d )", p, num_recalled_tags, num_tags);
+  return;
+}
 
-        build_labels(inst, inst->predicted_tags);
-        writer.write(inst);
-        num_recalled_tags += inst->num_corrected_predicted_tags();
-        num_tags += inst->size();
+void
+Postagger::test(void) {
+  const char * model_file = test_opt.model_file.c_str();
+  ifstream mfs(model_file, std::ifstream::binary);
 
-        delete inst;
-    }
+  if (!mfs) {
+    ERROR_LOG("Failed to load model");
+    return;
+  }
 
-    double after = get_time();
+  model = new Model;
+  if (!model->load(mfs)) {
+    ERROR_LOG("Failed to load model");
+    return;
+  }
+
+  TRACE_LOG("Number of labels     [%d]", model->num_labels());
+  TRACE_LOG("Number of features   [%d]", model->space.num_features());
+  TRACE_LOG("Number of dimension  [%d]", model->space.dim());
 
-    double p = (double)num_recalled_tags / num_tags;
+  const char * test_file = test_opt.test_file.c_str();
 
-    TRACE_LOG("P: %lf ( %d / %d )", p, num_recalled_tags, num_tags);
-    TRACE_LOG("Eclipse time %lf", after - before);
+  ifstream ifs(test_file);
 
-    sleep(1000000);
+  if (!ifs) {
+    ERROR_LOG("Failed to open holdout file.");
     return;
-}
+  }
 
-void Postagger::dump() {
-    // load model
-    const char * model_file = dump_opt.model_file.c_str();
-    ifstream mfs(model_file, std::ifstream::binary);
+  decoder = new Decoder(model->num_labels());
+  PostaggerReader reader(ifs, true);
+  PostaggerWriter writer(cout);
+  Instance * inst = NULL;
 
-    if (!mfs) {
-        ERROR_LOG("Failed to load model");
-        return;
-    }
+  int num_recalled_tags = 0;
+  int num_tags = 0;
 
-    model = new Model;
-    if (!model->load(mfs)) {
-        ERROR_LOG("Failed to load model");
-        return;
+  double before = get_time();
+
+  while ((inst = reader.next())) {
+    int len = inst->size();
+    inst->tagsidx.resize(len);
+    for (int i = 0; i < len; ++ i) {
+      inst->tagsidx[i] = model->labels.index(inst->tags[i]);
     }
 
-    int L = model->num_labels();
-    TRACE_LOG("Number of labels                 [%d]", model->num_labels());
-    TRACE_LOG("Number of features               [%d]", model->space.num_features());
-    TRACE_LOG("Number of dimension              [%d]", model->space.dim());
+    extract_features(inst);
+    calculate_scores(inst, true);
+    decoder->decode(inst);
+
+    build_labels(inst, inst->predicted_tags);
+    writer.write(inst);
+    num_recalled_tags += inst->num_corrected_predicted_tags();
+    num_tags += inst->size();
 
-    for (FeatureSpaceIterator itx = model->space.begin(); itx != model->space.end(); ++ itx) {
-        const char * key = itx.key();
-        int tid = itx.tid();
-        int id = model->space.index(tid, key);
+    delete inst;
+  }
 
-        for (int l = 0; l < L; ++ l) {
-            std::cout << key << " ( " << id + l << " ) "
-                << " --> "
-                << model->param.dot(id + l)
+  double after = get_time();
+
+  double p = (double)num_recalled_tags / num_tags;
+
+  TRACE_LOG("P: %lf ( %d / %d )", p, num_recalled_tags, num_tags);
+  TRACE_LOG("Eclipse time %lf", after - before);
+
+  sleep(1000000);
+  return;
+}
+
+void
+Postagger::dump() {
+  // load model
+  const char * model_file = dump_opt.model_file.c_str();
+  ifstream mfs(model_file, std::ifstream::binary);
+
+  if (!mfs) {
+    ERROR_LOG("Failed to load model");
+    return;
+  }
+
+  model = new Model;
+  if (!model->load(mfs)) {
+    ERROR_LOG("Failed to load model");
+    return;
+  }
+
+  int L = model->num_labels();
+  TRACE_LOG("Number of labels         [%d]", model->num_labels());
+  TRACE_LOG("Number of features       [%d]", model->space.num_features());
+  TRACE_LOG("Number of dimension      [%d]", model->space.dim());
+
+  for (FeatureSpaceIterator itx = model->space.begin();
+       itx != model->space.end();
+       ++ itx) {
+    const char * key = itx.key();
+    int tid = itx.tid();
+    int id = model->space.index(tid, key);
+
+    for (int l = 0; l < L; ++ l) {
+      std::cout << key << " ( " << id + l << " ) "
+                << " --> " << model->param.dot(id + l)
                 << std::endl;
-        }
     }
+  }
 
-    for (int pl = 0; pl < L; ++ pl) {
-        for (int l = 0; l < L; ++ l) {
-            int id = model->space.index(pl, l);
-            std::cout << pl << " --> " << l << " " << model->param.dot(id) << std::endl;
-        }
+  for (int pl = 0; pl < L; ++ pl) {
+    for (int l = 0; l < L; ++ l) {
+      int id = model->space.index(pl, l);
+      std::cout << pl << " --> " << l << " " << model->param.dot(id) << std::endl;
     }
+  }
 }
 
-}       //  end for namespace postagger
-}       //  end for namespace ltp
+}     //  end for namespace postagger
+}     //  end for namespace ltp
diff --git a/src/postagger/postagger.h b/src/postagger/postagger.h
index 396f0ebac..2e62136c9 100644
--- a/src/postagger/postagger.h
+++ b/src/postagger/postagger.h
@@ -10,113 +10,124 @@ namespace postagger {
 
 class Postagger {
 public:
-    Postagger();
-    Postagger(ltp::utility::ConfigParser & cfg);
-    ~Postagger();
+  Postagger();
+  Postagger(ltp::utility::ConfigParser & cfg);
+  ~Postagger();
 
-    /*
-     * main function of running postagging.
-     */
-    void run();
+  /*
+   * main function of running postagging.
+   */
+  void run();
 
 private:
-    bool parse_cfg(ltp::utility::ConfigParser & cfg);
-
-    /*
-     * read instance from the file, and store the instances
-     * in train data.
-     *
-     *  @param[in]  file_name   the file name
-     */
-    bool read_instance( const char * file_name );
-
-    /*
-     * build postags dictionary
-     */
-    void build_configuration(void);
-
-    /*
-     * build the feature space
-     */
-    void build_feature_space(void);
-
-    /*
-     * the training process
-     */
-    void train(void);
-
-    /*
-     * the evaluating process
-     */
-    void evaluate(void);
-
-    /*
-     * the testing process
-     */
-    void test(void);
-
-    /*
-     * the dump model process
-     */
-    void dump(void);
-
-    /*
-     * do feature trauncation on the model. create a model duplation
-     * on the model and return their
-     *
-     *  @return Model the duplication of the model
-     */
-    Model * truncate(void);
+  bool parse_cfg(ltp::utility::ConfigParser & cfg);
+
+  /*
+   * read instance from the file, and store the instances
+   * in train data.
+   *
+   *  @param[in]  file_name   the file name
+   */
+  bool read_instance( const char * file_name );
+
+  /*
+   * build postags dictionary
+   */
+  void build_configuration(void);
+
+  /*
+   * build the feature space
+   */
+  void build_feature_space(void);
+
+  /*
+   * the training process
+   */
+  void train(void);
+
+  /*
+   * the evaluating process
+   */
+  void evaluate(double &p);
+
+  /*
+   * the testing process
+   */
+  void test(void);
+
+  /*
+   * the dump model process
+   */
+  void dump(void);
+
+  /*
+   * do feature trauncation on the model. create a model duplation
+   * on the model and return their
+   *
+   *  @param[in]  feature_group_updated_times   the updated time of feature
+   *                                            group
+   *  @return     Model                         the duplication of the model
+   */
+  Model * erase_rare_features(int * feature_group_updated_times = 0);
 protected:
-    /*
-     * build labels string for the instance
-     *
-     *  @param[in]  inst        the instance
-     *  @param[out] tags        the list of tags string
-     */
-    void build_labels(Instance * inst, std::vector<std::string> & tags);
-
-    /*
-     * extract feature from the instance. If create handler is configured,
-     *
-     *  @param[in]  inst        the instance
-     *  @param[in]  create      use to specify create process
-     */
-    void extract_features(Instance * inst, bool create = false);
-
-    /*
-     * cache all the score for the certain instance.
-     *
-     *  @param[in/out]  inst    the instance
-     *  @param[in]      use_avg use to specify use average parameter
-     */
-    void calculate_scores(Instance * inst, bool use_avg);
-
-    /*
-     * collect feature when given the tags index
-     *
-     *  @param[in]      inst    the instance
-     *  @param[in]      tagsidx the tags index
-     *  @param[out]     vec     the output sparse vector
-     */
-    void collect_features(Instance * inst, 
-            const std::vector<int> & tagsidx, 
-            ltp::math::SparseVec & vec);
-
+  /*
+   * build labels string for the instance
+   *
+   *  @param[in]  inst    the instance
+   *  @param[out] tags    the list of tags string
+   */
+  void build_labels(Instance * inst, std::vector<std::string> & tags);
+
+  /*
+   * extract feature from the instance. If create handler is configured,
+   *
+   *  @param[in]  inst    the instance
+   *  @param[in]  create    use to specify create process
+   */
+  void extract_features(Instance * inst, bool create = false);
+
+  /*
+   * cache all the score for the certain instance.
+   *
+   *  @param[in/out]  inst  the instance
+   *  @param[in]    use_avg use to specify use average parameter
+   */
+  void calculate_scores(Instance * inst, bool use_avg);
+
+  /*
+   * collect feature when given the tags index
+   *
+   *  @param[in]    inst  the instance
+   *  @param[in]    tagsidx the tags index
+   *  @param[out]   vec   the output sparse vector
+   */
+  void collect_features(Instance * inst,
+                        const std::vector<int> & tagsidx,
+                        ltp::math::SparseVec & vec);
+
+  /*
+   * decode the group information for feature represented in sparse vector,
+   * increase their updated time
+   *
+   *  @param[in]  vec           the feature vector
+   *  @param[out] updated_time  the updated time
+   */
+  void increase_group_updated_time(const ltp::math::SparseVec & vec,
+                                   int * feature_group_updated_time);
 private:
-    bool    __TRAIN__;
-    bool    __TEST__;
-    bool    __DUMP__;
+  bool  __TRAIN__;
+  bool  __TEST__;
+  bool  __DUMP__;
 
 private:
-    std::vector< Instance * > train_dat;
+  std::vector< Instance * > train_dat;
 
 protected:
-    Model * model;
-    Decoder * decoder;
+  Model * model;
+  Decoder * decoder;
 };
 
-}       //  end for namespace postagger
-}       //  end for namespace ltp
+}     //  end for namespace postagger
+}     //  end for namespace ltp
 
 #endif  //  end for __LTP_POSTAGGER_SEGMENTOR_H__
diff --git a/src/postagger/postaggerio.h b/src/postagger/postaggerio.h
index 498cf6f0d..05e5454cb 100644
--- a/src/postagger/postaggerio.h
+++ b/src/postagger/postaggerio.h
@@ -12,51 +12,51 @@ namespace postagger {
 
 class PostaggerReader {
 public:
-    PostaggerReader(istream & _ifs, bool _train = false) : 
-        ifs(_ifs),
-        train(_train) {}
+  PostaggerReader(istream & _ifs, bool _train = false)
+    : ifs(_ifs),
+      train(_train) {}
 
-    Instance * next() {
-        if (ifs.eof()) {
-            return 0;
-        }
+  Instance * next() {
+    if (ifs.eof()) {
+      return 0;
+    }
 
-        Instance * inst = new Instance;
-        std::string  line;
+    Instance * inst = new Instance;
+    std::string  line;
 
-        std::getline(ifs, line);
-        strutils::chomp(line);
+    std::getline(ifs, line);
+    strutils::chomp(line);
 
-        if (line.size() == 0) {
-            delete inst;
-            return 0;
-        }
+    if (line.size() == 0) {
+      delete inst;
+      return 0;
+    }
 
-        std::vector<std::string> words = split(line);
+    std::vector<std::string> words = split(line);
 
-        for (int i = 0; i < words.size(); ++ i) {
-            if (train) {
-                std::vector<std::string> sep = strutils::rsplit_by_sep(words[i], "_", 1);
-                if (sep.size() == 2) {
-                    inst->raw_forms.push_back(sep[0]);
-                    inst->forms.push_back(strutils::chartypes::sbc2dbc_x(sep[0]));
-                    inst->tags.push_back(sep[1]);
-                } else {
-                    std::cerr << words[i] << std::endl;
-                    delete inst;
-                    return 0;
-                }
-            } else {
-                inst->raw_forms.push_back(words[i]);
-                inst->forms.push_back(strutils::chartypes::sbc2dbc_x(words[i]));
-            }
+    for (int i = 0; i < words.size(); ++ i) {
+      if (train) {
+        std::vector<std::string> sep = strutils::rsplit_by_sep(words[i], "_", 1);
+        if (sep.size() == 2) {
+          inst->raw_forms.push_back(sep[0]);
+          inst->forms.push_back(strutils::chartypes::sbc2dbc_x(sep[0]));
+          inst->tags.push_back(sep[1]);
+        } else {
+          std::cerr << words[i] << std::endl;
+          delete inst;
+          return 0;
         }
-
-        return inst;
+      } else {
+        inst->raw_forms.push_back(words[i]);
+        inst->forms.push_back(strutils::chartypes::sbc2dbc_x(words[i]));
+      }
     }
+
+    return inst;
+  }
 private:
-    istream &   ifs;
-    int         train;
+  istream & ifs;
+  int       train;
 };
 
 /*
@@ -64,30 +64,30 @@ class PostaggerReader {
  */
 class PostaggerWriter {
 public:
-    PostaggerWriter(std::ostream & _ofs) : ofs(_ofs) {}
-
-    void write(const Instance * inst) {
-        int len = inst->size();
-        if (inst->predicted_tags.size() != len) {
-            return;
-        }
+  PostaggerWriter(std::ostream & _ofs) : ofs(_ofs) {}
 
-        for (int i = 0; i < len; ++ i) {
-            ofs << inst->raw_forms[i] << "/" << inst->predicted_tags[i];
-            if (i + 1 < len ) {
-                ofs << "\t";
-            } else {
-                ofs << std::endl;
-            }
-        }
+  void write(const Instance * inst) {
+    int len = inst->size();
+    if (inst->predicted_tags.size() != len) {
+      return;
     }
 
-    void debug(const Instance * inst, bool show_feat = false) {
+    for (int i = 0; i < len; ++ i) {
+      ofs << inst->raw_forms[i] << "/" << inst->predicted_tags[i];
+      if (i + 1 < len ) {
+        ofs << "\t";
+      } else {
+        ofs << std::endl;
+      }
     }
+  }
+
+  void debug(const Instance * inst, bool show_feat = false) {
+  }
 private:
-    std::ostream & ofs;
+  std::ostream & ofs;
 };
 
-}           //  end for namespace postagger
-}           //  end for namespace ltp
-#endif      //  end for __LTP_POSTAGGER_IO_H__
+}       //  end for namespace postagger
+}       //  end for namespace ltp
+#endif    //  end for __LTP_POSTAGGER_IO_H__
diff --git a/src/segmentor/decoder.cpp b/src/segmentor/decoder.cpp
index 07b3c5d1b..369e8218a 100644
--- a/src/segmentor/decoder.cpp
+++ b/src/segmentor/decoder.cpp
@@ -5,104 +5,104 @@ namespace segmentor {
 
 
 void Decoder::decode(Instance * inst) {
-    init_lattice(inst);
-    viterbi_decode(inst);
-    get_result(inst);
-    free_lattice();
+  init_lattice(inst);
+  viterbi_decode(inst);
+  get_result(inst);
+  free_lattice();
 }
 
 void Decoder::init_lattice(const Instance * inst) {
-    int len = inst->size();
-    lattice.resize(len, L);
-    lattice = NULL;
+  int len = inst->size();
+  lattice.resize(len, L);
+  lattice = NULL;
 }
 
 void Decoder::viterbi_decode(const Instance * inst) {
-    int len = inst->size();
-    for (int i = 0; i < len; ++ i) {
-        for (int l = 0; l < L; ++ l) {
-            if (false == base.legal_emit(inst->chartypes[i], l)) {
-                continue;
-            }
-
-            if (i == 0) {
-                LatticeItem * item = new LatticeItem(i, l, inst->uni_scores[i][l], NULL);
-                lattice_insert(lattice[i][l], item);
-            } else {
-                for (int pl = 0; pl < L; ++ pl) {
-                    if (false == base.legal_trans(pl, l)) {
-                        continue;
-                    }
-
-                    double score = 0.;
-                    const LatticeItem * prev = lattice[i-1][pl];
-
-                    if (!prev) {
-                        continue;
-                    }
-
-                    // std::cout << i << " " << pl << " " << l << std::endl;
-                    score = inst->uni_scores[i][l] + inst->bi_scores[pl][l] + prev->score;
-                    const LatticeItem * item = new LatticeItem(i, l, score, prev);
-                    lattice_insert(lattice[i][l], item);
-                }
-            }   //  end for if i == 0
+  int len = inst->size();
+  for (int i = 0; i < len; ++ i) {
+    for (int l = 0; l < L; ++ l) {
+      if (false == base.legal_emit(inst->chartypes[i], l)) {
+        continue;
+      }
+
+      if (i == 0) {
+        LatticeItem * item = new LatticeItem(i, l, inst->uni_scores[i][l], NULL);
+        lattice_insert(lattice[i][l], item);
+      } else {
+        for (int pl = 0; pl < L; ++ pl) {
+          if (false == base.legal_trans(pl, l)) {
+            continue;
+          }
+
+          double score = 0.;
+          const LatticeItem * prev = lattice[i-1][pl];
+
+          if (!prev) {
+            continue;
+          }
+
+          // std::cout << i << " " << pl << " " << l << std::endl;
+          score = inst->uni_scores[i][l] + inst->bi_scores[pl][l] + prev->score;
+          const LatticeItem * item = new LatticeItem(i, l, score, prev);
+          lattice_insert(lattice[i][l], item);
         }
+      }   //  end for if i == 0
     }
+  }
 }
 
 void Decoder::get_result(Instance * inst) {
-    int len = inst->size();
-    const LatticeItem * best_item = NULL;
-    for (int l = 0; l < L; ++ l) {
-        if (!lattice[len-1][l]) {
-            continue;
-        }
-        if (best_item == NULL || (lattice[len-1][l]->score > best_item->score)) {
-            best_item = lattice[len - 1][l];
-        }
+  int len = inst->size();
+  const LatticeItem * best_item = NULL;
+  for (int l = 0; l < L; ++ l) {
+    if (!lattice[len-1][l]) {
+      continue;
     }
+    if (best_item == NULL || (lattice[len-1][l]->score > best_item->score)) {
+      best_item = lattice[len - 1][l];
+    }
+  }
 
-    const LatticeItem * item = best_item;
-    inst->predicted_tagsidx.resize(len);
+  const LatticeItem * item = best_item;
+  inst->predicted_tagsidx.resize(len);
 
-    while (item) {
-        inst->predicted_tagsidx[item->i] = item->l;
-        // std::cout << item->i << " " << item->l << std::endl;
-        item = item->prev;
-    }
+  while (item) {
+    inst->predicted_tagsidx[item->i] = item->l;
+    // std::cout << item->i << " " << item->l << std::endl;
+    item = item->prev;
+  }
 }
 
 void Decoder::free_lattice() {
-    for (int i = 0; i < lattice.nrows(); ++ i) {
-        for (int j = 0; j < lattice.ncols(); ++ j) {
-            if (lattice[i][j]) delete lattice[i][j];
-        }
+  for (int i = 0; i < lattice.nrows(); ++ i) {
+    for (int j = 0; j < lattice.ncols(); ++ j) {
+      if (lattice[i][j]) delete lattice[i][j];
     }
+  }
 }
 
 /*void KBestDecoder::decode(Instance * inst, KBestDecodeResult & result) {
-    init_lattice(inst);
-    kbest_viterbi_decode(inst);
-    get_result(result);
-    free_lattice();
+  init_lattice(inst);
+  kbest_viterbi_decode(inst);
+  get_result(result);
+  free_lattice();
 }
 
 void KBestDecoder::init_lattice(const Instance * inst) {
-    int len = inst->len();
-    lattice.resize(len, L);
+  int len = inst->len();
+  lattice.resize(len, L);
 
-    for (int i = 0; i < len; ++ i) {
-        for (int l = 0; l < L; ++ l) {
-            lattice[i][l] = new KHeap<LatticeItem>(k);
-        }
+  for (int i = 0; i < len; ++ i) {
+    for (int l = 0; l < L; ++ l) {
+      lattice[i][l] = new KHeap<LatticeItem>(k);
     }
+  }
 }
 
 void KBestDecoder::kbest_viterbi_decode(const Instance * inst) {
 }*/
 
 
-}       //  end for namespace segmentor
-}       //  end for namespace ltp
+}     //  end for namespace segmentor
+}     //  end for namespace ltp
 
diff --git a/src/segmentor/decoder.h b/src/segmentor/decoder.h
index 747f6bd59..c5a920322 100644
--- a/src/segmentor/decoder.h
+++ b/src/segmentor/decoder.h
@@ -13,75 +13,78 @@ namespace segmentor {
 // data structure for lattice item
 class LatticeItem {
 public:
-    LatticeItem (int _i, int _l, double _score, const LatticeItem * _prev) : 
-        i(_i),
-        l(_l),
-        score(_score),
-        prev(_prev) {}
-
-    LatticeItem (int _l, double _score) : 
-        i(0),
-        l(_l),
-        score(_score),
-        prev(0) {}
+  LatticeItem (int _i, int _l, double _score, const LatticeItem * _prev) :
+    i(_i),
+    l(_l),
+    score(_score),
+    prev(_prev) {}
+
+  LatticeItem (int _l, double _score) :
+    i(0),
+    l(_l),
+    score(_score),
+    prev(0) {}
 
 public:
-    int                 i;
-    int                 l;
-    double              score;
-    const LatticeItem * prev;
+  int         i;
+  int         l;
+  double        score;
+  const LatticeItem * prev;
 };
 
 class Decoder {
 public:
-    Decoder (int _L, rulebase::RuleBase & _base) : L(_L), base(_base) {}
-    void decode(Instance * inst);
+  Decoder (int _L, rulebase::RuleBase & _base) : L(_L), base(_base) {}
+  void decode(Instance * inst);
 
 private:
-    void init_lattice(const Instance * inst);
-    void viterbi_decode(const Instance * inst);
-    void get_result(Instance * inst);
-    void free_lattice();
+  void init_lattice(const Instance * inst);
+  void viterbi_decode(const Instance * inst);
+  void get_result(Instance * inst);
+  void free_lattice();
 
 private:
-    int L;
-
-    math::Mat< const LatticeItem * > lattice;
-    rulebase::RuleBase base;
-
-    void lattice_insert(const LatticeItem * &position, const LatticeItem * const item) {
-        if (position == NULL) {
-            position = item;
-        } else if (position->score < item->score) {
-            delete position;
-            position = item;
-        } else {
-            delete item;
-        }
+  int L;
+
+  math::Mat< const LatticeItem * > lattice;
+  rulebase::RuleBase base;
+
+  void lattice_insert(const LatticeItem * &position,
+                      const LatticeItem * const item) {
+    if (position == NULL) {
+      position = item;
+    } else if (position->score < item->score) {
+      delete position;
+      position = item;
+    } else {
+      delete item;
     }
+  }
 };
 
-// maintain kest best list of 
-/*class KBestDecoder {
+// Source code for k-best decoding, it's not implemented.
+/*
+class KBestDecoder {
 public:
-    typedef std::vector< std::vector<int> > KBestDecodeResult;
+  typedef std::vector< std::vector<int> > KBestDecodeResult;
 
 public:
-    KBestDecoder (int _L) : L(_L) {}
+  KBestDecoder (int _L) : L(_L) {}
 
-    void decode(Instance * inst, KBestDecodeResult & result);
+  void decode(Instance * inst, KBestDecodeResult & result);
 private:
-    void init_lattice(const Instance * inst);
-    void kbest_viterbi_decode(const Instance * inst);
-    void get_result(KBestDecodeResult & result);
-    void free_lattice();
+  void init_lattice(const Instance * inst);
+  void kbest_viterbi_decode(const Instance * inst);
+  void get_result(KBestDecodeResult & result);
+  void free_lattice();
 
 private:
-    int L;
+  int L;
 
-    Mat< KHeap< const LatticeItem * > > lattice;
-};*/
+  Mat< KHeap< const LatticeItem * > > lattice;
+};
+*/
 
-}           //  end for namespace segmentor
-}           //  end for namespace ltp
-#endif      //  end for __LTP_SEGMENTOR_DECODER_H__
+}       //  end for namespace segmentor
+}       //  end for namespace ltp
+#endif    //  end for __LTP_SEGMENTOR_DECODER_H__
diff --git a/src/segmentor/extractor.cpp b/src/segmentor/extractor.cpp
index eef00e893..6fc7ee054 100644
--- a/src/segmentor/extractor.cpp
+++ b/src/segmentor/extractor.cpp
@@ -11,90 +11,90 @@ Extractor * Extractor::instance_ = 0;
 std::vector<Template *> Extractor::templates;
 
 Extractor * Extractor::extractor() {
-    if (0 == instance_) {
-        instance_ = new Extractor;
-    }
+  if (0 == instance_) {
+    instance_ = new Extractor;
+  }
 
-    return instance_;
+  return instance_;
 }
 
 int Extractor::num_templates() {
-    if (0 == instance_) {
-        instance_ = new Extractor;
-    }
+  if (0 == instance_) {
+    instance_ = new Extractor;
+  }
 
-    return templates.size();
+  return templates.size();
 }
 
 Extractor::Extractor() {
-    templates.push_back(new Template("1={c-2}"));
-    templates.push_back(new Template("2={c-1}"));
-    templates.push_back(new Template("3={c-0}"));
-    templates.push_back(new Template("4={c+1}"));
-    templates.push_back(new Template("5={c+2}"));
-    templates.push_back(new Template("6={c-2}-{c-1}"));
-    templates.push_back(new Template("7={c-1}-{c-0}"));
-    templates.push_back(new Template("8={c-0}-{c+1}"));
-    templates.push_back(new Template("9={c+1}-{c+2}"));
-    //templates.push_back(new Template("10={c-2}-{c-0}"));
-    //templates.push_back(new Template("11={c-1}-{c+1}"));
-    //templates.push_back(new Template("12={c-0}-{c+2}"));
-    //templates.push_back(new Template("13={c-1}-{c-0}-{c+1}"));
-    templates.push_back(new Template("14={ct-1}"));
-    templates.push_back(new Template("15={ct-0}"));
-    templates.push_back(new Template("16={ct+1}"));
-    templates.push_back(new Template("17={lex1}"));
-    templates.push_back(new Template("18={lex2}"));
-    templates.push_back(new Template("19={lex3}"));
-    //templates.push_back(new Template("17={dup-1}"));
-    //templates.push_back(new Template("18={dup-0}"));
-    //templates.push_back(new Template("19={dup2-2}"));
-    //templates.push_back(new Template("20={dup2-1}"));
-    //templates.push_back(new Template("21={dup2-0}"));
+  templates.push_back(new Template("1={c-2}"));
+  templates.push_back(new Template("2={c-1}"));
+  templates.push_back(new Template("3={c-0}"));
+  templates.push_back(new Template("4={c+1}"));
+  templates.push_back(new Template("5={c+2}"));
+  templates.push_back(new Template("6={c-2}-{c-1}"));
+  templates.push_back(new Template("7={c-1}-{c-0}"));
+  templates.push_back(new Template("8={c-0}-{c+1}"));
+  templates.push_back(new Template("9={c+1}-{c+2}"));
+  //templates.push_back(new Template("10={c-2}-{c-0}"));
+  //templates.push_back(new Template("11={c-1}-{c+1}"));
+  //templates.push_back(new Template("12={c-0}-{c+2}"));
+  //templates.push_back(new Template("13={c-1}-{c-0}-{c+1}"));
+  templates.push_back(new Template("14={ct-1}"));
+  templates.push_back(new Template("15={ct-0}"));
+  templates.push_back(new Template("16={ct+1}"));
+  templates.push_back(new Template("17={lex1}"));
+  templates.push_back(new Template("18={lex2}"));
+  templates.push_back(new Template("19={lex3}"));
+  //templates.push_back(new Template("17={dup-1}"));
+  //templates.push_back(new Template("18={dup-0}"));
+  //templates.push_back(new Template("19={dup2-2}"));
+  //templates.push_back(new Template("20={dup2-1}"));
+  //templates.push_back(new Template("21={dup2-0}"));
 }
 
 Extractor::~Extractor() {
-    for (int i = 0; i < templates.size(); ++ i) {
-        delete templates[i];
-    }
+  for (int i = 0; i < templates.size(); ++ i) {
+    delete templates[i];
+  }
 }
 
 int Extractor::extract1o(Instance * inst, int idx, std::vector< StringVec > & cache) {
-    int len = inst->size();
+  int len = inst->size();
 
-    Template::Data data;
+  Template::Data data;
 
 #define EQU(x, y) (inst->forms[(x)] == inst->forms[(y)])
 #define TYPE(x) (strutils::to_str(inst->chartypes[(x)]&0x07))
 
-    data.set( "c-2",    (idx-2 < 0 ? BOS : inst->forms[idx-2]) );
-    data.set( "c-1",    (idx-1 < 0 ? BOS : inst->forms[idx-1]) );
-    data.set( "c-0",    inst->forms[idx] );
-    data.set( "c+1",    (idx+1 >= len ? EOS : inst->forms[idx+1]) );
-    data.set( "c+2",    (idx+2 >= len ? EOS : inst->forms[idx+2]) );
-    data.set( "ct-1",   (idx-1 < 0 ? BOT : TYPE(idx-1)) );
-    data.set( "ct-0",   TYPE(idx) );
-    data.set( "ct+1",   (idx+1 >= len ? EOT : TYPE(idx+1)) );
-    // data.set( "dup-1",  (idx-1 > 0 && EQU(idx-1, idx) ? "1" : "0") );
-    // data.set( "dup-0",  (idx+1 < len && EQU(idx, idx+1) ? "1" : "0") );
-    // data.set( "dup2-2", (idx-2 > 0 && EQU(idx-2, idx) ? "1" : "0") );
-    // data.set( "dup2-1", (idx-1 > 0 && idx+1 < len && EQU(idx-1, idx+1) ? "1" : "0") );
-    // data.set( "dup2-0", (idx+2 < len && EQU(idx, idx+2) ? "1" : "0") );
-    data.set( "lex1",   strutils::to_str(inst->lexicon_match_state[idx] & 0x0f));
-    data.set( "lex2",   strutils::to_str((inst->lexicon_match_state[idx]>>4) & 0x0f));
-    data.set( "lex3",   strutils::to_str((inst->lexicon_match_state[idx]>>8) & 0x0f));
+  data.set( "c-2",  (idx-2 < 0 ? BOS : inst->forms[idx-2]) );
+  data.set( "c-1",  (idx-1 < 0 ? BOS : inst->forms[idx-1]) );
+  data.set( "c-0",  inst->forms[idx] );
+  data.set( "c+1",  (idx+1 >= len ? EOS : inst->forms[idx+1]) );
+  data.set( "c+2",  (idx+2 >= len ? EOS : inst->forms[idx+2]) );
+  data.set( "ct-1",   (idx-1 < 0 ? BOT : TYPE(idx-1)) );
+  data.set( "ct-0",   TYPE(idx) );
+  data.set( "ct+1",   (idx+1 >= len ? EOT : TYPE(idx+1)) );
+  // data.set( "dup-1",  (idx-1 > 0 && EQU(idx-1, idx) ? "1" : "0") );
+  // data.set( "dup-0",  (idx+1 < len && EQU(idx, idx+1) ? "1" : "0") );
+  // data.set( "dup2-2", (idx-2 > 0 && EQU(idx-2, idx) ? "1" : "0") );
+  // data.set( "dup2-1", (idx-1 > 0 && idx+1 < len && EQU(idx-1, idx+1) ? "1" : "0") );
+  // data.set( "dup2-0", (idx+2 < len && EQU(idx, idx+2) ? "1" : "0") );
+  data.set( "lex1",   strutils::to_str(inst->lexicon_match_state[idx] & 0x0f));
+  data.set( "lex2",   strutils::to_str((inst->lexicon_match_state[idx]>>4) & 0x0f));
+  data.set( "lex3",   strutils::to_str((inst->lexicon_match_state[idx]>>8) & 0x0f));
 
 #undef TYPE
 #undef EQU
 
-    string feat;
-    feat.reserve(1024);
-    for (int i = 0; i < templates.size(); ++ i) {
-        templates[i]->render(data, feat);
-        cache[i].push_back(feat);
-    }
-    return 0;
+  string feat;
+  feat.reserve(1024);
+  for (int i = 0; i < templates.size(); ++ i) {
+    templates[i]->render(data, feat);
+    cache[i].push_back(feat);
+  }
+  return 0;
 }
 
-}       //  end for namespace segmentor
-}       //  end for namespace ltp
+}     //  end for namespace segmentor
+}     //  end for namespace ltp
diff --git a/src/segmentor/extractor.h b/src/segmentor/extractor.h
index e3b49a7d0..f6f85f31f 100644
--- a/src/segmentor/extractor.h
+++ b/src/segmentor/extractor.h
@@ -16,18 +16,18 @@ using namespace ltp::utility;
 
 class Extractor {
 public:
-    static Extractor * extractor();
-    static int num_templates();
-    static int extract1o(Instance * inst, int idx, vector< StringVec > & cache);
+  static Extractor * extractor();
+  static int num_templates();
+  static int extract1o(Instance * inst, int idx, vector< StringVec > & cache);
 protected:
-    Extractor();
-    ~Extractor();
+  Extractor();
+  ~Extractor();
 private:
-    static Extractor * instance_;
-    static vector< Template * > templates;
+  static Extractor * instance_;
+  static vector< Template * > templates;
 };
 
-}       //  end for namespace segmentor
-}       //  end for namespace ltp 
+}     //  end for namespace segmentor
+}     //  end for namespace ltp 
 
 #endif  //  end for __LTP_SEGMENTOR_EXTRACTOR_H__
diff --git a/src/segmentor/featurespace.cpp b/src/segmentor/featurespace.cpp
index d60d5a6d4..a50e8123d 100644
--- a/src/segmentor/featurespace.cpp
+++ b/src/segmentor/featurespace.cpp
@@ -5,99 +5,113 @@
 namespace ltp {
 namespace segmentor {
 
-FeatureSpace::FeatureSpace(int num_labels) : 
-    _num_labels(num_labels), 
+FeatureSpace::FeatureSpace(int num_labels)
+  : _num_labels(num_labels),
     _offset(0) {
 
-    // allocate dictionary according to number of templates
-    _num_dicts = Extractor::num_templates();
+  // allocate dictionary according to number of templates
+  _num_dicts = Extractor::num_templates();
 
-    dicts = new utility::SmartMap<int>[ _num_dicts ];
+  dicts = new utility::SmartMap<int>[ _num_dicts ];
 }
 
 FeatureSpace::~FeatureSpace(void) {
-    delete [](dicts);
+  delete [](dicts);
 }
 
-int FeatureSpace::retrieve(int tid, const char * key, bool create) {
-    int val;
+int
+FeatureSpace::retrieve(int tid, const char * key, bool create) {
+  int val;
 
-    if (dicts[tid].get(key, val)) {
-        return val;
-    } else {
-        if (create) {
-            val = _offset;
-            dicts[tid].set(key, val);
-            ++ _offset;
+  if (dicts[tid].get(key, val)) {
+    return val;
+  } else {
+    if (create) {
+      val = _offset;
+      dicts[tid].set(key, val);
+      ++ _offset;
 
-            return val;
-        }
+      return val;
     }
- 
-    return -1;
+  }
+
+  return -1;
 }
 
-int FeatureSpace::index(int tid, const char * key, int lid) {
-    int idx = retrieve(tid, key, false);
-    if (idx < 0) {
-        return -1;
-    }
+int
+FeatureSpace::index(int tid, const char * key, int lid) {
+  int idx = retrieve(tid, key, false);
+  if (idx < 0) {
+    return -1;
+  }
 
-    return idx * _num_labels + lid;
+  return idx * _num_labels + lid;
 }
 
-int FeatureSpace::index(int prev_lid, int lid) {
-    return _offset * _num_labels + prev_lid * _num_labels + lid;
+int
+FeatureSpace::index(int prev_lid, int lid) {
+  return _offset * _num_labels + prev_lid * _num_labels + lid;
 }
 
-int FeatureSpace::num_features() {
-    return _offset;
+int
+FeatureSpace::num_features() {
+  return _offset;
 }
 
-int FeatureSpace::dim() {
-    return _offset * _num_labels + _num_labels * _num_labels;
+int
+FeatureSpace::dim() {
+  return _offset * _num_labels + _num_labels * _num_labels;
 }
 
-void FeatureSpace::set_num_labels(int num_labels) {
-    _num_labels = num_labels;
+int
+FeatureSpace::num_feature_groups() {
+  return _offset + _num_labels;
 }
-void FeatureSpace::dump(std::ostream & ofs) {
-    char chunk[16];
-    unsigned sz = _num_dicts;
-    strncpy(chunk, "featurespace", 16);
-
-    ofs.write(chunk, 16);
-    ofs.write(reinterpret_cast<const char *>(&_offset), sizeof(int));
-    ofs.write(reinterpret_cast<const char *>(&sz), sizeof(unsigned int));
 
-    for (int i = 0; i < _num_dicts; ++ i) {
-        dicts[i].dump(ofs);
-    }
+void
+FeatureSpace::set_num_labels(int num_labels) {
+  _num_labels = num_labels;
 }
 
-bool FeatureSpace::load(int num_labels, std::istream & ifs) {
-    _num_labels = num_labels;
-    char chunk[16];
-    unsigned int sz;
-    ifs.read(chunk, 16);
-    if (strcmp(chunk, "featurespace")) {
-        return false;
-    }
+void
+FeatureSpace::dump(std::ostream & ofs) {
+  char chunk[16];
+  unsigned sz = _num_dicts;
+  strncpy(chunk, "featurespace", 16);
 
-    ifs.read(reinterpret_cast<char *>(&_offset), sizeof(int));
-    ifs.read(reinterpret_cast<char *>(&sz), sizeof(unsigned int));
+  ofs.write(chunk, 16);
+  ofs.write(reinterpret_cast<const char *>(&_offset), sizeof(int));
+  ofs.write(reinterpret_cast<const char *>(&sz), sizeof(unsigned int));
 
-    if (sz != _num_dicts) {
-        return false;
-    }
+  for (int i = 0; i < _num_dicts; ++ i) {
+    dicts[i].dump(ofs);
+  }
+}
 
-    for (unsigned i = 0; i < sz; ++ i) {
-        if (!dicts[i].load(ifs)) {
-            return false;
-        }
+bool
+FeatureSpace::load(int num_labels, std::istream & ifs) {
+  _num_labels = num_labels;
+  char chunk[16];
+  unsigned int sz;
+  ifs.read(chunk, 16);
+  if (strcmp(chunk, "featurespace")) {
+    return false;
+  }
+
+  ifs.read(reinterpret_cast<char *>(&_offset), sizeof(int));
+  ifs.read(reinterpret_cast<char *>(&sz), sizeof(unsigned int));
+
+  if (sz != _num_dicts) {
+    return false;
+  }
+
+  for (unsigned i = 0; i < sz; ++ i) {
+    if (!dicts[i].load(ifs)) {
+      return false;
     }
+  }
 
-    return true;
+  return true;
 }
 
 }   //  end for namespace segmentor
diff --git a/src/segmentor/featurespace.h b/src/segmentor/featurespace.h
index 9e4bcbecc..b351d6fcc 100644
--- a/src/segmentor/featurespace.h
+++ b/src/segmentor/featurespace.h
@@ -11,108 +11,108 @@ namespace segmentor {
 
 class FeatureSpaceIterator {
 public:
-    FeatureSpaceIterator() : 
-        _dicts(NULL),
-        _i(0),
-        _state(0) {
-        // should be careful about the empty dicts
+  FeatureSpaceIterator()
+    : _dicts(NULL),
+      _i(0),
+      _state(0) {
+    // should be careful about the empty dicts
+  }
+
+  FeatureSpaceIterator(utility::SmartMap<int> * dicts, int num_dicts)
+    : _dicts(dicts),
+      _num_dicts(num_dicts),
+      _i(0),
+      _state(0) {
+    ++ (*this);
+  }
+
+  ~FeatureSpaceIterator() {
+  }
+
+  const char * key() { return _j.key(); }
+  int id() { return (*_j.value()); }
+  int tid() { return _i; }
+
+  bool operator ==(const FeatureSpaceIterator & other) const {
+    return ((_dicts + _i) == other._dicts);
+  }
+
+  bool operator !=(const FeatureSpaceIterator & other) const {
+    return ((_dicts + _i) != other._dicts);
+  }
+
+  FeatureSpaceIterator & operator = (const FeatureSpaceIterator & other) {
+    if (this != &other) {
+      _dicts  = other._dicts;
+      _i      = other._i;
+      _state  = other._state;
     }
 
-    FeatureSpaceIterator(utility::SmartMap<int> * dicts,int num_dicts) : 
-        _dicts(dicts), 
-	_num_dicts(num_dicts),
-        _i(0), 
-        _state(0) {
-        ++ (*this);
-    }
-
-    ~FeatureSpaceIterator() {
-    }
-
-    const char * key() { return _j.key(); }
-    int id() { return (*_j.value()); }
-    int tid() { return _i; }
-
-    bool operator ==(const FeatureSpaceIterator & other) const { return ((_dicts + _i) == other._dicts); }
-    bool operator !=(const FeatureSpaceIterator & other) const { return ((_dicts + _i) != other._dicts); }
-
-    FeatureSpaceIterator & operator = (const FeatureSpaceIterator & other) {
-        if (this != &other) {
-            _dicts  = other._dicts;
-            _i      = other._i;
-            _state  = other._state;
+    return *this;
+  }
+
+  void operator ++() {
+    switch (_state) {
+      case 0:
+        for (_i = 0; _i < _num_dicts; ++ _i) {
+          for (_j = _dicts[_i].begin(); _j != _dicts[_i].end(); ++ _j) {
+            _state = 1;
+            return;
+      case 1:;
+          }
         }
-
-        return *this;
     }
+  }
 
-    void operator ++() {
-        switch (_state) {
-            case 0:
-                for (_i = 0;_i<_num_dicts ; ++ _i) {
-                   /* if (_dicts[_i].begin() == _dicts[_i].end()) {
-                        _state = 1;
-                        return;
-                    }*/
-                    for (_j = _dicts[_i].begin(); _j != _dicts[_i].end(); ++ _j) {
-                        _state = 1;
-                        return;
-            case 1:;
-                    }
-                }
-        }
-    }
-
-    int _i;
-    int _state;
-    int _num_dicts;
-    utility::SmartMap<int>::const_iterator  _j;
-    utility::SmartMap<int> * _dicts;
+  int _i;
+  int _state;
+  int _num_dicts;
+  utility::SmartMap<int>::const_iterator  _j;
+  utility::SmartMap<int> * _dicts;
 };
 
 class FeatureSpace {
 public:
-    FeatureSpace(int num_labels = 1);
-    ~FeatureSpace();
-
-    int retrieve(int tid, const char * key, bool create);
-    int index(int tid, const char * key, int lid = 0);
-    int index(int prev_lid, int lid);
-    int num_features();
-    int id_label_to_id(int idx);
-    int dim();
-    int get_offset();
-    void set_num_labels(int num_labeles);
-
-    /*
-     * dump the feature space to a output stream
-     *
-     *  @param[in]  ofs     the output stream
-     */
-    void dump(std::ostream & ofs);
-
-    /*
-     * load the feature space from a input stream
-     *
-     *  @param[in]  num_labels  the number of labels
-     *  @param[in]  ifs         the input stream
-     */
-    bool load(int num_labeles, std::istream & ifs);
-
-    FeatureSpaceIterator begin() {
-        return FeatureSpaceIterator(dicts,_num_dicts);
-    }
-
-    FeatureSpaceIterator end() {
-        return FeatureSpaceIterator(dicts + _num_dicts,_num_dicts);
-    }
+  FeatureSpace(int num_labels = 1);
+  ~FeatureSpace();
+
+  int retrieve(int tid, const char * key, bool create);
+  int index(int tid, const char * key, int lid = 0);
+  int index(int prev_lid, int lid);
+  int num_features();
+  int dim();
+  int num_feature_groups();
+  void set_num_labels(int num_labeles);
+
+  /*
+   * dump the feature space to a output stream
+   *
+   *  @param[in]  ofs   the output stream
+   */
+  void dump(std::ostream & ofs);
+
+  /*
+   * load the feature space from a input stream
+   *
+   *  @param[in]  num_labels  the number of labels
+   *  @param[in]  ifs     the input stream
+   */
+  bool load(int num_labeles, std::istream & ifs);
+
+  FeatureSpaceIterator begin() {
+    return FeatureSpaceIterator(dicts, _num_dicts);
+  }
+
+  FeatureSpaceIterator end() {
+    return FeatureSpaceIterator(dicts + _num_dicts, _num_dicts);
+  }
 private:
-    int _offset;
-    int _num_labels;
-    int _num_dicts;
-    utility::SmartMap<int> * dicts;
+  int _offset;
+  int _num_labels;
+  int _num_dicts;
+  utility::SmartMap<int> * dicts;
 };
 
-}       //  end for namespace segmentor
-}       //  end for namespace ltp
+}     //  end for namespace segmentor
+}     //  end for namespace ltp
 #endif  //  end for __LTP_SEGMENTOR_FEATURE_SPACE_H__
diff --git a/src/segmentor/featurevec.h b/src/segmentor/featurevec.h
index 42ab69fdc..a0fdbbff0 100644
--- a/src/segmentor/featurevec.h
+++ b/src/segmentor/featurevec.h
@@ -6,32 +6,32 @@ namespace segmentor {
 
 struct FeatureVector {
 public:
-    FeatureVector () : n(0), idx(0), val(0) {
-    }
+  FeatureVector () : n(0), idx(0), val(0), loff(0) {
+  }
 
-    ~FeatureVector() {
-    }
+  ~FeatureVector() {
+  }
 
-    void clear() {
-        if (idx) {
-            delete [](idx);
-            idx = 0;
-        }
+  void clear() {
+    if (idx) {
+      delete [](idx);
+      idx = 0;
+    }
 
-        if (val) {
-            delete [](val);
-            val = 0;
-        }
+    if (val) {
+      delete [](val);
+      val = 0;
     }
+  }
 
 public:
-    int      n;
-    int *    idx;
-    double * val;
-    int      loff;
+  int       n;
+  int *     idx;
+  double *  val;
+  int       loff;
 };
 
-}       //  end for namespace segmentor
-}       //  end for namespace ltp
+}     //  end for namespace segmentor
+}     //  end for namespace ltp
 
 #endif  //  end for __LTP_SEGMENTOR_FEATRUE_VECTOR_H__
diff --git a/src/segmentor/instance.h b/src/segmentor/instance.h
index 47fbdc480..08ad00d83 100644
--- a/src/segmentor/instance.h
+++ b/src/segmentor/instance.h
@@ -11,129 +11,128 @@ namespace segmentor {
 
 class Instance {
 public:
-    Instance() {}
+  Instance() {}
 
-    ~Instance() {
-        cleanup();
+  ~Instance() {
+    cleanup();
+  }
+
+  inline size_t size() const {
+    return forms.size();
+  }
+
+  int num_errors() {
+    int len = size();
+    if ((len != tagsidx.size()) || (len != predicted_tagsidx.size())) {
+      return -1;
     }
 
-    inline size_t size() const {
-        return forms.size();
+    int ret = 0;
+    for (int i = 0; i < len; ++ i) {
+      if (tagsidx[i] != predicted_tagsidx[i]) {
+        ++ ret;
+      }
     }
 
-    int num_errors() {
-        int len = size();
-        if ((len != tagsidx.size()) || (len != predicted_tagsidx.size())) {
-            return -1;
-        }
+    return ret;
+  }
 
-        int ret = 0;
-        for (int i = 0; i < len; ++ i) {
-            if (tagsidx[i] != predicted_tagsidx[i]) {
-                ++ ret;
-            }
-        }
+  int num_predicted_words() {
+    return predicted_words.size();
+  }
 
-        return ret;
-    }
+  int num_gold_words() {
+    return words.size();
+  }
 
-    int num_predicted_words() {
-        return predicted_words.size();
-    }
+  int num_recalled_words() {
+    int len = 0;
+    int ret = 0;
+    int gold_len = 0, predicted_len = 0;
 
-    int num_gold_words() {
-        return words.size();
+    for (int i = 0; i < words.size(); ++ i) {
+      len += words[i].size();
     }
 
-    int num_recalled_words() {
-        int len = 0;
-        int ret = 0;
-        int gold_len = 0, predicted_len = 0;
-
-        for (int i = 0; i < words.size(); ++ i) {
-            len += words[i].size();
+    for (int i = 0, j = 0; i < words.size() && j < predicted_words.size(); ) {
+      if (words[i] == predicted_words[j]) {
+        ++ ret;
+        gold_len += words[i].size();
+        predicted_len += predicted_words[j].size();
+
+        ++ i;
+        ++ j;
+      } else {
+        gold_len += words[i].size();
+        predicted_len += predicted_words[j].size();
+
+        ++ i;
+        ++ j;
+
+        while (gold_len < len && predicted_len < len) {
+          if (gold_len < predicted_len) {
+            gold_len += words[i].size();
+            ++ i;
+          } else if (gold_len > predicted_len) {
+            predicted_len += predicted_words[j].size();
+            ++ j;
+          } else {
+            break;
+          }
         }
+      }
+    }
 
-        for (int i = 0, j = 0; i < words.size() && j < predicted_words.size(); ) {
-            if (words[i] == predicted_words[j]) {
-                ++ ret;
-                gold_len += words[i].size();
-                predicted_len += predicted_words[j].size();
-
-                ++ i;
-                ++ j;
-            } else {
-                gold_len += words[i].size();
-                predicted_len += predicted_words[j].size();
-
-                ++ i;
-                ++ j;
-
-                while (gold_len < len && predicted_len < len) {
-                    if (gold_len < predicted_len) {
-                        gold_len += words[i].size();
-                        ++ i;
-                    } else if (gold_len > predicted_len) {
-                        predicted_len += predicted_words[j].size();
-                        ++ j;
-                    } else {
-                        break;
-                    }
-                }
-            }
-        }
+    return ret;
+  }
 
-        return ret;
-    }
+  int cleanup() {
+    if (uni_features.total_size() > 0) {
+      int d1 = uni_features.nrows();
+      int d2 = uni_features.ncols();
 
-    int cleanup() {
-        int len = 0;
-        if ((len = uni_features.total_size()) > 0) {
-            int d1 = uni_features.nrows();
-            int d2 = uni_features.ncols();
-
-            for (int i = 0; i < d1; ++ i) {
-                if (uni_features[i][0]) {
-                    uni_features[i][0]->clear();
-                }
-                for (int j = 0; j < d2; ++ j) {
-                    if (uni_features[i][j]) {
-                        delete uni_features[i][j];
-                    }
-                }
-            }
+      for (int i = 0; i < d1; ++ i) {
+        if (uni_features[i][0]) {
+          uni_features[i][0]->clear();
         }
+        for (int j = 0; j < d2; ++ j) {
+          if (uni_features[i][j]) {
+            delete uni_features[i][j];
+          }
+        }
+      }
+    }
 
-        uni_features.dealloc();
-        uni_scores.dealloc();
-        bi_scores.dealloc();
+    uni_features.dealloc();
+    uni_scores.dealloc();
+    bi_scores.dealloc();
 
-        features.zero();
-        predicted_features.zero();
+    features.zero();
+    predicted_features.zero();
 
-		return 0;
-    }
+    return 0;
+  }
 public:
-    std::vector< std::string >  raw_forms;
-    std::vector< std::string >  forms;
-    std::vector< int >          chartypes;
-    std::vector< std::string >  tags;
-    std::vector< int >          tagsidx;
-    std::vector< std::string >  predicted_tags;
-    std::vector< int >          predicted_tagsidx;
-    std::vector< std::string >  words;
-    std::vector< std::string >  predicted_words;
-    std::vector< int >          lexicon_match_state;
-
-    math::SparseVec             features;                   /*< the gold features */
-    math::SparseVec             predicted_features;         /*< the predicted features */
-
-    math::Mat< FeatureVector *> uni_features;
-    math::Mat< double >         uni_scores;
-    math::Mat< double >         bi_scores;
+  std::vector< std::string >  raw_forms;
+  std::vector< std::string >  forms;
+  std::vector< int >          chartypes;
+  std::vector< std::string >  tags;
+  std::vector< int >          tagsidx;
+  std::vector< std::string >  predicted_tags;
+  std::vector< int >          predicted_tagsidx;
+  std::vector< std::string >  words;
+  std::vector< std::string >  predicted_words;
+  std::vector< int >          lexicon_match_state;
+
+  math::SparseVec       features;           /*< the gold features */
+  math::SparseVec       predicted_features; /*< the predicted features */
+
+  math::Mat< FeatureVector *> uni_features;
+  math::Mat< double > uni_scores;
+  math::Mat< double > bi_scores;
 };
 
-}       //  end for namespace segmentor
-}       //  end for namespace ltp
+}     //  end for namespace segmentor
+}     //  end for namespace ltp
 
 #endif  //  end for __LTP_SEGENTOR_INSTANCE_H__
diff --git a/src/segmentor/model.cpp b/src/segmentor/model.cpp
index 902272aa7..054eae5f0 100644
--- a/src/segmentor/model.cpp
+++ b/src/segmentor/model.cpp
@@ -9,77 +9,79 @@ Model::Model() {
 Model::~Model() {
 }
 
-void Model::save(std::ostream & ofs) {
-    // write a signature into the file
-    char chunk[16] = {'o','t','c','w','s', '\0'};
-    ofs.write(chunk, 16);
+void
+Model::save(std::ostream & ofs) {
+  // write a signature into the file
+  char chunk[16] = {'o','t','c','w','s', '\0'};
+  ofs.write(chunk, 16);
 
-    int off = ofs.tellp();
+  int off = ofs.tellp();
 
-    unsigned labels_offset      = 0;
-    unsigned lexicon_offset     = 0;
-    unsigned feature_offset     = 0;
-    unsigned parameter_offset   = 0;
+  unsigned labels_offset    = 0;
+  unsigned lexicon_offset   = 0;
+  unsigned feature_offset   = 0;
+  unsigned parameter_offset   = 0;
 
-    write_uint(ofs, 0); //  the label offset
-    write_uint(ofs, 0); //  the internal lexicon offset
-    write_uint(ofs, 0); //  the features offset
-    write_uint(ofs, 0); //  the parameter offset
+  write_uint(ofs, 0); //  the label offset
+  write_uint(ofs, 0); //  the internal lexicon offset
+  write_uint(ofs, 0); //  the features offset
+  write_uint(ofs, 0); //  the parameter offset
 
-    labels_offset = ofs.tellp();
-    labels.dump(ofs);
+  labels_offset = ofs.tellp();
+  labels.dump(ofs);
 
-    lexicon_offset = ofs.tellp();
-    internal_lexicon.dump(ofs);
+  lexicon_offset = ofs.tellp();
+  internal_lexicon.dump(ofs);
 
-    feature_offset = ofs.tellp();
-    space.dump(ofs);
+  feature_offset = ofs.tellp();
+  space.dump(ofs);
 
-    parameter_offset = ofs.tellp();
-    param.dump(ofs);
+  parameter_offset = ofs.tellp();
+  param.dump(ofs);
 
-    ofs.seekp(off);
-    write_uint(ofs, labels_offset);
-    write_uint(ofs, lexicon_offset);
-    write_uint(ofs, feature_offset);
-    write_uint(ofs, parameter_offset);
+  ofs.seekp(off);
+  write_uint(ofs, labels_offset);
+  write_uint(ofs, lexicon_offset);
+  write_uint(ofs, feature_offset);
+  write_uint(ofs, parameter_offset);
 }
 
-bool Model::load(std::istream & ifs) {
-    char chunk[16];
-    ifs.read(chunk, 16);
-
-    if (strcmp(chunk, "otcws")) {
-        return false;
-    }
-
-    unsigned labels_offset    = read_uint(ifs);
-    unsigned lexicon_offset   = read_uint(ifs);
-    unsigned feature_offset   = read_uint(ifs);
-    unsigned parameter_offset = read_uint(ifs);
-
-    ifs.seekg(labels_offset);
-    if (!labels.load(ifs)) {
-        return false;
-    }
-
-    ifs.seekg(lexicon_offset);
-    if (!internal_lexicon.load(ifs)) {
-        return false;
-    }
-
-    ifs.seekg(feature_offset);
-    if (!space.load(labels.size(), ifs)) {
-        return false;
-    }
-
-    ifs.seekg(parameter_offset);
-    if (!param.load(ifs)) {
-        return false;
-    }
-
-    return true;
+bool
+Model::load(std::istream & ifs) {
+  char chunk[16];
+  ifs.read(chunk, 16);
+
+  if (strcmp(chunk, "otcws")) {
+    return false;
+  }
+
+  unsigned labels_offset  = read_uint(ifs);
+  unsigned lexicon_offset   = read_uint(ifs);
+  unsigned feature_offset   = read_uint(ifs);
+  unsigned parameter_offset = read_uint(ifs);
+
+  ifs.seekg(labels_offset);
+  if (!labels.load(ifs)) {
+    return false;
+  }
+
+  ifs.seekg(lexicon_offset);
+  if (!internal_lexicon.load(ifs)) {
+    return false;
+  }
+
+  ifs.seekg(feature_offset);
+  if (!space.load(labels.size(), ifs)) {
+    return false;
+  }
+
+  ifs.seekg(parameter_offset);
+  if (!param.load(ifs)) {
+    return false;
+  }
+
+  return true;
 }
 
-}       //  end for namespace segmentor
-}       //  end for namespace ltp
+}     //  end for namespace segmentor
+}     //  end for namespace ltp
diff --git a/src/segmentor/model.h b/src/segmentor/model.h
index 29b0e3fe1..3824f1f07 100644
--- a/src/segmentor/model.h
+++ b/src/segmentor/model.h
@@ -13,51 +13,53 @@ using namespace ltp::utility;
 
 class Model {
 public:
-    Model();
-    ~Model();
-
-    /*
-     * get number of labels;
-     *
-     *  @return     int     the number of labels
-     */
-    inline int num_labels(void) {
-        return labels.size();
-    }
-
-    /*
-     * save the model to a output stream
-     *
-     *  @param[out] ofs     the output stream
-     */
-    void save(std::ostream & ofs);
-
-    /*
-     * load the model from an input stream
-     *
-     *  @param[in]  ifs     the input stream
-     */
-    bool load(std::istream & ifs);
+  Model();
+  ~Model();
+
+  /*
+   * get number of labels;
+   *
+   *  @return   int   the number of labels
+   */
+  inline int num_labels(void) {
+    return labels.size();
+  }
+
+  /*
+   * save the model to a output stream
+   *
+   *  @param[out] ofs   the output stream
+   */
+  void save(std::ostream & ofs);
+
+  /*
+   * load the model from an input stream
+   *
+   *  @param[in]  ifs   the input stream
+   */
+  bool load(std::istream & ifs);
+
 public:
-    IndexableSmartMap   labels;
-    FeatureSpace        space;
-    Parameters          param;
+  IndexableSmartMap labels;
+  FeatureSpace      space;
+  Parameters        param;
+
+  SmartMap<bool>    internal_lexicon;
+  SmartMap<bool>    external_lexicon;
 
-    SmartMap<bool>      internal_lexicon;
-    SmartMap<bool>      external_lexicon;
 private:
-    void write_uint(std::ostream & out, unsigned int val) {
-        out.write(reinterpret_cast<const char *>(&val), sizeof(unsigned int));
-    }
-
-    unsigned int read_uint(std::istream & in) {
-        char p[4];
-        in.read(reinterpret_cast<char*>(p), sizeof(unsigned int));
-        return *reinterpret_cast<const unsigned int*>(p);
-    }
+  void write_uint(std::ostream & out, unsigned int val) {
+    out.write(reinterpret_cast<const char *>(&val), sizeof(unsigned int));
+  }
+
+  unsigned int read_uint(std::istream & in) {
+    char p[4];
+    in.read(reinterpret_cast<char*>(p), sizeof(unsigned int));
+    return *reinterpret_cast<const unsigned int*>(p);
+  }
 };
 
-}       //  end for namespace segmentor
-}       //  end for namespace ltp
+}     //  end for namespace segmentor
+}     //  end for namespace ltp
 
 #endif  //  end for __LTP_SEGMENTOR_MODEL_H__
diff --git a/src/segmentor/options.h b/src/segmentor/options.h
index ec92e3c12..298f4200b 100644
--- a/src/segmentor/options.h
+++ b/src/segmentor/options.h
@@ -7,26 +7,27 @@ namespace ltp {
 namespace segmentor {
 
 struct ModelOptions {
-    std::string     model_file;
+  std::string   model_file;
 };
 
 struct TrainOptions {
-    std::string     train_file;
-    std::string     holdout_file;
-    std::string     model_name;
-    std::string     algorithm;
-    int             max_iter;
-    int             display_interval;
+  std::string       train_file;
+  std::string       holdout_file;
+  std::string       model_name;
+  std::string       algorithm;
+  int               max_iter;
+  int               display_interval;
+  int               rare_feature_threshold;
 };
 
 struct TestOptions {
-    std::string     test_file;
-    std::string     model_file;
-    std::string     lexicon_file;
+  std::string       test_file;
+  std::string       model_file;
+  std::string       lexicon_file;
 };
 
 struct DumpOptions {
-    std::string     model_file;
+  std::string       model_file;
 };
 
 extern ModelOptions model_opt;
@@ -34,7 +35,7 @@ extern TrainOptions train_opt;
 extern TestOptions  test_opt;
 extern DumpOptions  dump_opt;
 
-}           //  end for namespace segmentor
-}           //  end for namespace ltp
+}       //  end for namespace segmentor
+}       //  end for namespace ltp
 
-#endif      //  end for __LTP_SEGMENTOR_OPTIONS_H__
+#endif    //  end for __LTP_SEGMENTOR_OPTIONS_H__
diff --git a/src/segmentor/otcws.cpp b/src/segmentor/otcws.cpp
index 7f3aa28c9..beef25ba0 100644
--- a/src/segmentor/otcws.cpp
+++ b/src/segmentor/otcws.cpp
@@ -7,27 +7,28 @@ using namespace ltp::utility;
 using namespace ltp::segmentor;
 
 void usage(void) {
-    std::cerr << "otcws - Training and testing suite for Chinese Word segmentation" << std::endl;
-    std::cerr << "Copyright (C) 2012-2013 HIT-SCIR" << std::endl;
-    std::cerr << std::endl;
-    std::cerr << "usage: ./otcws <config_file>" << std::endl;
-    std::cerr << std::endl;
+  std::cerr << "otcws - Training and testing suite for Chinese Word segmentation"
+            << std::endl;
+  std::cerr << "Copyright (C) 2012-2014 HIT-SCIR" << std::endl;
+  std::cerr << std::endl;
+  std::cerr << "usage: ./otcws <config_file>" << std::endl;
+  std::cerr << std::endl;
 }
 
 int main(int argc, const char * argv[]) {
-    if (argc < 2 || (argv[1][0] == '-' && argv[1][1] == 'h')) {
-        usage();
-        return -1;
-    }
+  if (argc < 2 || (argv[1][0] == '-' && argv[1][1] == 'h')) {
+    usage();
+    return -1;
+  }
 
-    ConfigParser cfg(argv[1]);
+  ConfigParser cfg(argv[1]);
 
-    if (!cfg) {
-        ERROR_LOG("Failed to parse config file.");
-        return -1;
-    }
+  if (!cfg) {
+    ERROR_LOG("Failed to parse config file.");
+    return -1;
+  }
 
-    Segmentor segmentor(cfg);
-    segmentor.run();
-    return 0;
+  Segmentor segmentor(cfg);
+  segmentor.run();
+  return 0;
 }
diff --git a/src/segmentor/parameter.h b/src/segmentor/parameter.h
index a3fbb5a44..6a76da3bc 100644
--- a/src/segmentor/parameter.h
+++ b/src/segmentor/parameter.h
@@ -12,151 +12,151 @@ using namespace ltp::math;
 
 class Parameters {
 public:
-    int _dim;
-    double * _W;
-    double * _W_sum;
-    int *    _W_time;
-
-    Parameters() :
-        _dim(0),
-        _W(0),
-        _W_sum(0),
-        _W_time(0) {}
-
-    ~Parameters() {
-        dealloc();
+  int _dim;
+  double * _W;
+  double * _W_sum;
+  int *    _W_time;
+
+  Parameters() :
+    _dim(0),
+    _W(0),
+    _W_sum(0),
+    _W_time(0) {}
+
+  ~Parameters() {
+    dealloc();
+  }
+
+  void realloc(int dim) {
+    dealloc();
+    _dim = dim;
+
+    if (dim > 0) {
+      _W = new double[dim];
+      _W_sum = new double[dim];
+      _W_time = new int[dim];
     }
 
-    void realloc(int dim) {
-        dealloc();
-        _dim = dim;
-
-        if (dim > 0) {
-            _W = new double[dim];
-            _W_sum = new double[dim];
-            _W_time = new int[dim];
-        }
-
-        for (int i = 0; i < dim; ++ i) {
-            _W[i] = 0;
-            _W_sum[i] = 0;
-            _W_time[i] = 0;
-        }
+    for (int i = 0; i < dim; ++ i) {
+      _W[i] = 0;
+      _W_sum[i] = 0;
+      _W_time[i] = 0;
     }
-
-    void dealloc() {
-        if (_W && _W == _W_sum) {
-            delete [](_W);
-            _W = 0;
-            _W_sum = 0;
-        } else {
-            if (_W) {
-                delete [](_W);
-                _W = 0;
-            }
-            if (_W_sum) {
-                delete [](_W_sum);
-                _W_sum = 0;
-            }
-        }
-
-        if (_W_time) {
-            delete [](_W_time);
-            _W_time = 0;
-        }
+  }
+
+  void dealloc() {
+    if (_W && _W == _W_sum) {
+      delete [](_W);
+      _W = 0;
+      _W_sum = 0;
+    } else {
+      if (_W) {
+        delete [](_W);
+        _W = 0;
+      }
+      if (_W_sum) {
+        delete [](_W_sum);
+        _W_sum = 0;
+      }
     }
 
-    void add(int idx, int now, double scale = 1.) {
-        int elapsed = now - _W_time[idx];
-        double upd = scale;
-        double cur_val = _W[idx];
-
-        _W[idx]         = cur_val + upd;
-        _W_sum[idx]    += elapsed * cur_val + upd;
-        _W_time[idx]    = now;
+    if (_W_time) {
+      delete [](_W_time);
+      _W_time = 0;
     }
-
-    void add(const SparseVec & vec, int now, double scale = 1.) {
-        for (SparseVec::const_iterator itx = vec.begin();
-                itx != vec.end();
-                itx ++) {
-            int idx = itx->first;
-            int elapsed = now - _W_time[idx];
-            double upd = scale * itx->second;
-            double cur_val = _W[idx];
-
-            _W[idx]         = cur_val + upd;
-            _W_sum[idx]    += elapsed * cur_val + upd;
-            _W_time[idx]    = now;
-        }
+  }
+
+  void add(int idx, int now, double scale = 1.) {
+    int elapsed = now - _W_time[idx];
+    double upd = scale;
+    double cur_val = _W[idx];
+
+    _W[idx]       = cur_val + upd;
+    _W_sum[idx]   += elapsed * cur_val + upd;
+    _W_time[idx]  = now;
+  }
+
+  void add(const SparseVec & vec, int now, double scale = 1.) {
+    for (SparseVec::const_iterator itx = vec.begin();
+        itx != vec.end();
+        ++ itx) {
+      int idx = itx->first;
+      int elapsed = now - _W_time[idx];
+      double upd = scale * itx->second;
+      double cur_val = _W[idx];
+
+      _W[idx]       = cur_val + upd;
+      _W_sum[idx]   += elapsed * cur_val + upd;
+      _W_time[idx]  = now;
     }
-
-    double dot(const SparseVec & vec, bool use_avg = false) const {
-        const double * const p = (use_avg ? _W_sum : _W);
-        double ret = 0.;
-        for (SparseVec::const_iterator itx = vec.begin();
-                itx != vec.end();
-                ++ itx) {
-            ret += p[itx->first] * itx->second;
-        }
-        return ret;
+  }
+
+  double dot(const SparseVec & vec, bool use_avg = false) const {
+    const double * const p = (use_avg ? _W_sum : _W);
+    double ret = 0.;
+    for (SparseVec::const_iterator itx = vec.begin();
+        itx != vec.end();
+        ++ itx) {
+      ret += p[itx->first] * itx->second;
     }
-
-    double dot(const FeatureVector * vec, bool use_avg = false) const {
-        const double * const p = (use_avg ? _W_sum : _W);
-        double ret = 0.;
-        for (int i = 0; i < vec->n; ++ i) {
-            if (vec->val) {
-                ret += p[vec->idx[i] + vec->loff] * vec->val[i];
-            } else {
-                ret += p[vec->idx[i] + vec->loff];
-            }
-        }
-        return ret;
+    return ret;
+  }
+
+  double dot(const FeatureVector * vec, bool use_avg = false) const {
+    const double * const p = (use_avg ? _W_sum : _W);
+    double ret = 0.;
+    for (int i = 0; i < vec->n; ++ i) {
+      if (vec->val) {
+        ret += p[vec->idx[i] + vec->loff] * vec->val[i];
+      } else {
+        ret += p[vec->idx[i] + vec->loff];
+      }
     }
-
-    double dot(const int idx, bool use_avg = false) const {
-        const double * const p = (use_avg ? _W_sum : _W);
-        return p[idx];
+    return ret;
+  }
+
+  double dot(const int idx, bool use_avg = false) const {
+    const double * const p = (use_avg ? _W_sum : _W);
+    return p[idx];
+  }
+
+  void flush(int now) {
+    for(int i = 0; i < _dim; ++i) {
+      _W_sum[i]  += (now - _W_time[i]) * _W[i];
+      _W_time[i] = now;
     }
-
-    void flush(int now) {
-        for(int i = 0; i < _dim; ++i) {
-            _W_sum[i] += (now - _W_time[i]) * _W[i];
-            _W_time[i] = now;
-        }
+  }
+
+  void dump(std::ostream & out, bool use_avg = true) {
+    const double * p = (use_avg ? _W_sum : _W);
+    char chunk[16] = {'p', 'a', 'r', 'a', 'm', 0};
+    out.write(chunk, 16);
+    out.write(reinterpret_cast<const char *>(&_dim), sizeof(int));
+    if (_dim > 0) {
+      out.write(reinterpret_cast<const char *>(p), sizeof(double) * _dim);
     }
+  }
 
-    void dump(std::ostream & out, bool use_avg = true) {
-        const double * p = (use_avg ? _W_sum : _W);
-        char chunk[16] = {'p', 'a', 'r', 'a', 'm', 0};
-        out.write(chunk, 16);
-        out.write(reinterpret_cast<const char *>(&_dim), sizeof(int));
-        if (_dim > 0) {
-            out.write(reinterpret_cast<const char *>(p), sizeof(double) * _dim);
-        }
+  bool load(std::istream & in) {
+    char chunk[16];
+    in.read(chunk, 16);
+    if (strcmp(chunk, "param")) {
+      return false;
     }
 
-    bool load(std::istream & in) {
-        char chunk[16];
-        in.read(chunk, 16);
-        if (strcmp(chunk, "param")) {
-            return false;
-        }
-
-        in.read(reinterpret_cast<char *>(&_dim), sizeof(int));
-        if (_dim > 0) {
-            _W = new double[_dim];
-            in.read(reinterpret_cast<char *>(_W), sizeof(double) * _dim);
-            _W_sum = _W;
-        }
-
-        return true;
+    in.read(reinterpret_cast<char *>(&_dim), sizeof(int));
+    if (_dim > 0) {
+      _W = new double[_dim];
+      in.read(reinterpret_cast<char *>(_W), sizeof(double) * _dim);
+      _W_sum = _W;
     }
+
+    return true;
+  }
 };
 
-}       //  end for namespace segmentor
-}       //  end for namespace ltp
+}     //  end for namespace segmentor
+}     //  end for namespace ltp
 
 #endif  //  end for __LTP_SEGMENTOR_PARAMETER_H__
 
diff --git a/src/segmentor/rulebase.h b/src/segmentor/rulebase.h
index a635f9d50..3786748f2 100644
--- a/src/segmentor/rulebase.h
+++ b/src/segmentor/rulebase.h
@@ -28,224 +28,224 @@ const int CHAR_URI = strutils::chartypes::CHAR_PUNC+2;
 
 const unsigned HAVE_SPACE_ON_LEFT  = (1<<3);
 const unsigned HAVE_SPACE_ON_RIGHT = (1<<4);
-const unsigned HAVE_ENG_ON_LEFT    = (1<<5);
+const unsigned HAVE_ENG_ON_LEFT  = (1<<5);
 const unsigned HAVE_ENG_ON_RIGHT   = (1<<6);
-const unsigned HAVE_URI_ON_LEFT    = (1<<7);
+const unsigned HAVE_URI_ON_LEFT  = (1<<7);
 const unsigned HAVE_URI_ON_RIGHT   = (1<<8);
 
 static boost::regex engpattern("(([A-Za-z]+)([\\-'\\.][A-Za-z]+)*)");
 static boost::regex uripattern("((https?|ftp|file)"
-        "://[-A-Za-z0-9+&@#/%?=~_|!:,.;]*[-A-Za-z0-9+&@#/%=~_|])");
+    "://[-A-Za-z0-9+&@#/%?=~_|!:,.;]*[-A-Za-z0-9+&@#/%=~_|])");
 
 static bool flags_clear_check(int * flags, int left, int right) {
-    for (int i = left; i < right; ++ i) {
-        if (flags[i]) return false;
-    }
-    return true;
+  for (int i = left; i < right; ++ i) {
+    if (flags[i]) return false;
+  }
+  return true;
 }
 
 static void flags_color(int * flags, int left, int right, int color) {
-    for (int i = left; i < right; ++ i) {
-        flags[i] = color;
-    }
+  for (int i = left; i < right; ++ i) {
+    flags[i] = color;
+  }
 }
 
 inline int preprocess(const std::string & sentence,
-        std::vector<std::string> & raw_forms,
-        std::vector<std::string> & forms,
-        std::vector<int> & chartypes) {
+    std::vector<std::string> & raw_forms,
+    std::vector<std::string> & forms,
+    std::vector<int> & chartypes) {
 
-    std::string sent = ltp::strutils::chomp(sentence);
-    // std::cerr << sent << std::endl;
+  std::string sent = ltp::strutils::chomp(sentence);
+  // std::cerr << sent << std::endl;
 
-    int len = sent.size();
-    if (0 == len) {
-        return 0;
-    }
+  int len = sent.size();
+  if (0 == len) {
+    return 0;
+  }
+
+  std::string::const_iterator start, end;
+  boost::match_results<std::string::const_iterator> what;
+
+  int ret = 0;
+  int * flags = new int[len];
 
-    std::string::const_iterator start, end;
-    boost::match_results<std::string::const_iterator> what;
+  for (int i = 0; i < len; ++ i) {
+    flags[i] = 0;
+  }
 
-    int ret = 0;
-    int * flags = new int[len];
+  start = sent.begin();
+  end = sent.end();
 
-    for (int i = 0; i < len; ++ i) {
-        flags[i] = 0;
+  while (boost::regex_search(start, end, what, uripattern, boost::match_default)) {
+    int left = what[0].first - sent.begin();
+    int right = what[0].second - sent.begin();
+
+    if (flags_clear_check(flags, left, right)) {
+      flags[left] = URI_BEG;
+      flags_color(flags, left+1, right, URI_MID);
     }
 
-    start = sent.begin();
-    end = sent.end();
+    start = what[0].second;
+  }
 
-    while (boost::regex_search(start, end, what, uripattern, boost::match_default)) {
-        int left = what[0].first - sent.begin();
-        int right = what[0].second - sent.begin();
+  start = sent.begin();
+  end   = sent.end();
 
-        if (flags_clear_check(flags, left, right)) {
-            flags[left] = URI_BEG;
-            flags_color(flags, left+1, right, URI_MID);
-        }
+  while (boost::regex_search(start, end, what, engpattern, boost::match_default)) {
+    int left = what[0].first - sent.begin();
+    int right = what[0].second - sent.begin();
 
-        start = what[0].second;
+    if (flags_clear_check(flags, left, right)) {
+      flags[left] = ENG_BEG;
+      flags_color(flags, left+1, right, ENG_MID);
     }
 
-    start = sent.begin();
-    end   = sent.end();
+    start = what[0].second;
+  }
+
+  std::string form = "";
+  unsigned left  = 0;
 
-    while (boost::regex_search(start, end, what, engpattern, boost::match_default)) {
-        int left = what[0].first - sent.begin();
-        int right = what[0].second - sent.begin();
+  for (int i = 0; i < len; ) {
+    int flag = 0;
+    if ((flag = flags[i])) {
+      form = "";
 
-        if (flags_clear_check(flags, left, right)) {
-            flags[left] = ENG_BEG;
-            flags_color(flags, left+1, right, ENG_MID);
+      for (; i<len && flags[i]; ++ i) {
+        form += sent[i];
+      }
+      raw_forms.push_back(form);
+
+      if (flag == ENG_BEG) {
+        forms.push_back( __eng__ );
+        if (chartypes.size() > 0) {
+          chartypes.back() |= HAVE_ENG_ON_RIGHT;
         }
 
-        start = what[0].second;
-    }
+        chartypes.push_back(CHAR_ENG);
+        chartypes.back() |= left;
+        left = HAVE_ENG_ON_LEFT;
+      } else if (flag == URI_BEG) {
+        forms.push_back( __uri__ );
+        if (chartypes.size() > 0) {
+          chartypes.back() |= HAVE_URI_ON_RIGHT;
+        }
 
-    std::string form = "";
-    unsigned left  = 0;
-
-    for (int i = 0; i < len; ) {
-        int flag = 0;
-        if ((flag = flags[i])) {
-            form = "";
-
-            for (; i<len && flags[i]; ++ i) {
-                form += sent[i];
-            }
-            raw_forms.push_back(form);
-
-            if (flag == ENG_BEG) {
-                forms.push_back( __eng__ );
-                if (chartypes.size() > 0) {
-                    chartypes.back() |= HAVE_ENG_ON_RIGHT;
-                }
-
-                chartypes.push_back(CHAR_ENG);
-                chartypes.back() |= left;
-                left = HAVE_ENG_ON_LEFT;
-            } else if (flag == URI_BEG) {
-                forms.push_back( __uri__ );
-                if (chartypes.size() > 0) {
-                    chartypes.back() |= HAVE_URI_ON_RIGHT;
-                }
-
-                chartypes.push_back(CHAR_URI);
-                chartypes.back() |= left;
-                left = HAVE_URI_ON_LEFT;
-            }
-            ++ ret;
+        chartypes.push_back(CHAR_URI);
+        chartypes.back() |= left;
+        left = HAVE_URI_ON_LEFT;
+      }
+      ++ ret;
+    } else {
+      if ((sent[i]&0x80)==0) {
+        if ((sent[i] != ' ') && (sent[i] != '\t')) {
+          raw_forms.push_back(sent.substr(i, 1));
+          chartypes.push_back(strutils::chartypes::chartype(raw_forms.back()));
+          forms.push_back("");
+          strutils::chartypes::sbc2dbc(raw_forms.back(), forms.back());
+          chartypes.back() |= left;
+          left = 0;
         } else {
-            if ((sent[i]&0x80)==0) {
-                if ((sent[i] != ' ') && (sent[i] != '\t')) {
-                    raw_forms.push_back(sent.substr(i, 1));
-                    chartypes.push_back(strutils::chartypes::chartype(raw_forms.back()));
-                    forms.push_back("");
-                    strutils::chartypes::sbc2dbc(raw_forms.back(), forms.back());
-                    chartypes.back() |= left;
-                    left = 0;
-                } else {
-                    left = HAVE_SPACE_ON_LEFT;
-                    if (chartypes.size()>0) {
-                        chartypes.back() |= HAVE_SPACE_ON_RIGHT;
-                    }
-                }
-                ++ i;
-            } else if ((sent[i]&0xE0)==0xC0) {
-                raw_forms.push_back(sent.substr(i, 2));
-                chartypes.push_back(strutils::chartypes::chartype(raw_forms.back()));
-                forms.push_back("");
-                strutils::chartypes::sbc2dbc(raw_forms.back(), forms.back());
-                chartypes.back() |= left;
-                left = 0;
-                i += 2;
-            } else if ((sent[i]&0xF0)==0xE0) {
-                raw_forms.push_back(sent.substr(i, 3));
-                chartypes.push_back(strutils::chartypes::chartype(raw_forms.back()));
-                forms.push_back("");
-                strutils::chartypes::sbc2dbc(raw_forms.back(), forms.back());
-                chartypes.back() |= left;
-                i += 3;
-            } else if ((sent[i]&0xF8)==0xF0) {
-                raw_forms.push_back(sent.substr(i, 4));
-                chartypes.push_back(strutils::chartypes::chartype(raw_forms.back()));
-                forms.push_back("");
-                strutils::chartypes::sbc2dbc(raw_forms.back(), forms.back());
-                chartypes.back() |= left;
-                i += 4;
-            } else {
-                delete [](flags);
-                return -1;
-            }
-
-            ++ ret;
+          left = HAVE_SPACE_ON_LEFT;
+          if (chartypes.size()>0) {
+            chartypes.back() |= HAVE_SPACE_ON_RIGHT;
+          }
         }
+        ++ i;
+      } else if ((sent[i]&0xE0)==0xC0) {
+        raw_forms.push_back(sent.substr(i, 2));
+        chartypes.push_back(strutils::chartypes::chartype(raw_forms.back()));
+        forms.push_back("");
+        strutils::chartypes::sbc2dbc(raw_forms.back(), forms.back());
+        chartypes.back() |= left;
+        left = 0;
+        i += 2;
+      } else if ((sent[i]&0xF0)==0xE0) {
+        raw_forms.push_back(sent.substr(i, 3));
+        chartypes.push_back(strutils::chartypes::chartype(raw_forms.back()));
+        forms.push_back("");
+        strutils::chartypes::sbc2dbc(raw_forms.back(), forms.back());
+        chartypes.back() |= left;
+        i += 3;
+      } else if ((sent[i]&0xF8)==0xF0) {
+        raw_forms.push_back(sent.substr(i, 4));
+        chartypes.push_back(strutils::chartypes::chartype(raw_forms.back()));
+        forms.push_back("");
+        strutils::chartypes::sbc2dbc(raw_forms.back(), forms.back());
+        chartypes.back() |= left;
+        i += 4;
+      } else {
+        delete [](flags);
+        return -1;
+      }
+
+      ++ ret;
     }
+  }
 
-    delete [](flags);
-    return ret;
+  delete [](flags);
+  return ret;
 }
 
 class RuleBase {
 public:
-    RuleBase(utility::IndexableSmartMap & labels, int style = 4) {
-        // only 4 tag style is supported
-        if (style == 4) {
-            __trans__ = 0;
-            __s_idx__ = labels.index( __s__ );
-            __b_idx__ = labels.index( __b__ );
-            __i_idx__ = labels.index( __i__ );
-            __e_idx__ = labels.index( __e__ );
-
-            if (__s_idx__>=0 && __b_idx__>=0 && __i_idx__>=0 && __e_idx__>=0) {
-                __trans__ |= (1<<((__s_idx__<<2) + __s_idx__));
-                __trans__ |= (1<<((__s_idx__<<2) + __b_idx__));
-                __trans__ |= (1<<((__b_idx__<<2) + __i_idx__));
-                __trans__ |= (1<<((__b_idx__<<2) + __e_idx__));
-                __trans__ |= (1<<((__i_idx__<<2) + __i_idx__));
-                __trans__ |= (1<<((__i_idx__<<2) + __e_idx__));
-                __trans__ |= (1<<((__e_idx__<<2) + __s_idx__));
-                __trans__ |= (1<<((__e_idx__<<2) + __b_idx__));
-            } else {
-                __trans__ = 0xffff;
-            }
-        }
+  RuleBase(utility::IndexableSmartMap & labels, int style = 4) {
+    // only 4 tag style is supported
+    if (style == 4) {
+      __trans__ = 0;
+      __s_idx__ = labels.index( __s__ );
+      __b_idx__ = labels.index( __b__ );
+      __i_idx__ = labels.index( __i__ );
+      __e_idx__ = labels.index( __e__ );
+
+      if (__s_idx__>=0 && __b_idx__>=0 && __i_idx__>=0 && __e_idx__>=0) {
+        __trans__ |= (1<<((__s_idx__<<2) + __s_idx__));
+        __trans__ |= (1<<((__s_idx__<<2) + __b_idx__));
+        __trans__ |= (1<<((__b_idx__<<2) + __i_idx__));
+        __trans__ |= (1<<((__b_idx__<<2) + __e_idx__));
+        __trans__ |= (1<<((__i_idx__<<2) + __i_idx__));
+        __trans__ |= (1<<((__i_idx__<<2) + __e_idx__));
+        __trans__ |= (1<<((__e_idx__<<2) + __s_idx__));
+        __trans__ |= (1<<((__e_idx__<<2) + __b_idx__));
+      } else {
+        __trans__ = 0xffff;
+      }
     }
+  }
 
-    ~RuleBase() {
-    }
+  ~RuleBase() {
+  }
 
-    inline bool legal_trans(int prev, int curr) {
-        return (__trans__ & (1<<((prev<<2) + curr))) > 0;
-    }
+  inline bool legal_trans(int prev, int curr) {
+    return (__trans__ & (1<<((prev<<2) + curr))) > 0;
+  }
 
-    inline bool legal_emit(int type, int curr) {
-        if (((type & 0x07) == CHAR_ENG) || ((type & 0x07) == CHAR_URI)) {
-            return (curr == __s_idx__);
-        }
+  inline bool legal_emit(int type, int curr) {
+    if (((type & 0x07) == CHAR_ENG) || ((type & 0x07) == CHAR_URI)) {
+      return (curr == __s_idx__);
+    }
 
-        /*if ((type & HAVE_SPACE_ON_LEFT)) {
-            return (curr == __s_idx__ || curr == __b_idx__);
-        }
+    /*if ((type & HAVE_SPACE_ON_LEFT)) {
+      return (curr == __s_idx__ || curr == __b_idx__);
+    }
 
-        if ((type & HAVE_SPACE_ON_RIGHT)) {
-            return (curr == __s_idx__ || curr == __e_idx__);
-        }*/
+    if ((type & HAVE_SPACE_ON_RIGHT)) {
+      return (curr == __s_idx__ || curr == __e_idx__);
+    }*/
 
-        return true;
-    }
+    return true;
+  }
 private:
-    unsigned __trans__;
+  unsigned __trans__;
 
-    int __s_idx__;
-    int __b_idx__;
-    int __i_idx__;
-    int __e_idx__;
+  int __s_idx__;
+  int __b_idx__;
+  int __i_idx__;
+  int __e_idx__;
 };
 
-}       //  end for rulebase
-}       //  end for namespace segmentor
-}       //  end for namespace ltp 
+}     //  end for rulebase
+}     //  end for namespace segmentor
+}     //  end for namespace ltp 
 
 #endif  //  end for __LTP_SEGMENTOR_RULE_BASE_H__
diff --git a/src/segmentor/segment_dll.cpp b/src/segmentor/segment_dll.cpp
index bb815304a..cf5a2c877 100644
--- a/src/segmentor/segment_dll.cpp
+++ b/src/segmentor/segment_dll.cpp
@@ -11,111 +11,115 @@
 
 class SegmentorWrapper : public ltp::segmentor::Segmentor {
 public:
-    SegmentorWrapper() :
-        beg_tag0(-1),
-        beg_tag1(-1) {}
+  SegmentorWrapper() :
+    beg_tag0(-1),
+    beg_tag1(-1) {}
 
-    ~SegmentorWrapper() {}
+  ~SegmentorWrapper() {}
 
-    bool load(const char * model_file, const char * lexicon_file = NULL) {
-        std::ifstream mfs(model_file, std::ifstream::binary);
+  bool load(const char * model_file, const char * lexicon_file = NULL) {
+    std::ifstream mfs(model_file, std::ifstream::binary);
 
-        if (!mfs) {
-            return false;
-        }
+    if (!mfs) {
+      return false;
+    }
 
-        model = new ltp::segmentor::Model;
-        if (!model->load(mfs)) {
-            delete model;
-            return false;
-        }
+    model = new ltp::segmentor::Model;
+    if (!model->load(mfs)) {
+      delete model;
+      return false;
+    }
 
-        if (NULL != lexicon_file) {
-            std::ifstream lfs(lexicon_file);
-
-            if (lfs) {
-                std::string buffer;
-                while (std::getline(lfs, buffer)) {
-                    buffer = ltp::strutils::chomp(buffer);
-                    if (buffer.size() == 0) {
-                        continue;
-                    }
-                    model->external_lexicon.set(buffer.c_str(), true);
-                }
-            }
+    if (NULL != lexicon_file) {
+      std::ifstream lfs(lexicon_file);
+
+      if (lfs) {
+        std::string buffer;
+        while (std::getline(lfs, buffer)) {
+          buffer = ltp::strutils::chomp(buffer);
+          if (buffer.size() == 0) {
+            continue;
+          }
+          model->external_lexicon.set(buffer.c_str(), true);
         }
-
-        // don't need to allocate a decoder
-        // one sentence, one decoder
-        baseAll = new ltp::segmentor::rulebase::RuleBase(model->labels);
-
-        beg_tag0 = model->labels.index( ltp::segmentor::__b__ );
-        beg_tag1 = model->labels.index( ltp::segmentor::__s__ );
-
-        return true;
+      }
     }
 
-    int segment(const char * str,
-            std::vector<std::string> & words) {
-        ltp::segmentor::Instance * inst = new ltp::segmentor::Instance;
-        // ltp::strutils::codecs::decode(str, inst->forms);
-        int ret = ltp::segmentor::rulebase::preprocess(str,
-                inst->raw_forms,
-                inst->forms,
-                inst->chartypes);
-
-        if (-1 == ret) {
-            delete inst;
-            words.clear();
-            return 0;
-        }
+    // don't need to allocate a decoder
+    // one sentence, one decoder
+    baseAll = new ltp::segmentor::rulebase::RuleBase(model->labels);
+
+    beg_tag0 = model->labels.index( ltp::segmentor::__b__ );
+    beg_tag1 = model->labels.index( ltp::segmentor::__s__ );
+
+    return true;
+  }
+
+  int segment(const char * str,
+      std::vector<std::string> & words) {
+    ltp::segmentor::Instance * inst = new ltp::segmentor::Instance;
+    // ltp::strutils::codecs::decode(str, inst->forms);
+    int ret = ltp::segmentor::rulebase::preprocess(str,
+        inst->raw_forms,
+        inst->forms,
+        inst->chartypes);
+
+    if (-1 == ret) {
+      delete inst;
+      words.clear();
+      return 0;
+    }
 
-        ltp::segmentor::Segmentor::extract_features(inst);
-        ltp::segmentor::Segmentor::calculate_scores(inst, true);
+    ltp::segmentor::Segmentor::extract_features(inst);
+    ltp::segmentor::Segmentor::calculate_scores(inst, true);
 
-        // allocate a new decoder so that the segmentor support multithreaded
-        // decoding. this modification was committed by niuox
-        ltp::segmentor::Decoder deco(model->num_labels(), *baseAll);
+    // allocate a new decoder so that the segmentor support multithreaded
+    // decoding. this modification was committed by niuox
+    ltp::segmentor::Decoder deco(model->num_labels(), *baseAll);
 
-        deco.decode(inst);
-        ltp::segmentor::Segmentor::build_words(inst, inst->predicted_tagsidx, words, beg_tag0, beg_tag1);
+    deco.decode(inst);
+    ltp::segmentor::Segmentor::build_words(inst,
+                                           inst->predicted_tagsidx,
+                                           words,
+                                           beg_tag0,
+                                           beg_tag1);
 
-        delete inst;
-        return words.size();
-    }
+    delete inst;
+    return words.size();
+  }
 
-    int segment(const std::string & str,
-            std::vector<std::string> & words) {
-        return segment(str.c_str(), words);
-    }
+  int segment(const std::string & str,
+      std::vector<std::string> & words) {
+    return segment(str.c_str(), words);
+  }
 private:
-    int beg_tag0;
-    int beg_tag1;
+  int beg_tag0;
+  int beg_tag1;
 };
 
 void * segmentor_create_segmentor(const char * path, const char * lexicon_file) {
-    SegmentorWrapper * wrapper = new SegmentorWrapper();
+  SegmentorWrapper * wrapper = new SegmentorWrapper();
 
-    if (!wrapper->load(path, lexicon_file)) {
-        return 0;
-    }
+  if (!wrapper->load(path, lexicon_file)) {
+    return 0;
+  }
 
-    return reinterpret_cast<void *>(wrapper);
+  return reinterpret_cast<void *>(wrapper);
 }
 
 int segmentor_release_segmentor(void * segmentor) {
-    if (!segmentor) {
-        return -1;
-    }
-    delete reinterpret_cast<SegmentorWrapper *>(segmentor);
-    return 0;
+  if (!segmentor) {
+    return -1;
+  }
+  delete reinterpret_cast<SegmentorWrapper *>(segmentor);
+  return 0;
 }
 
 int segmentor_segment(void * segmentor,
-        const std::string & str,
-        std::vector<std::string> & words) {
-    // std::cout << "input str = " << str << std::endl;
-    SegmentorWrapper * wrapper = 0;
-    wrapper = reinterpret_cast<SegmentorWrapper *>(segmentor);
-    return wrapper->segment(str.c_str(), words);
+    const std::string & str,
+    std::vector<std::string> & words) {
+  // std::cout << "input str = " << str << std::endl;
+  SegmentorWrapper * wrapper = 0;
+  wrapper = reinterpret_cast<SegmentorWrapper *>(segmentor);
+  return wrapper->segment(str.c_str(), words);
 }
diff --git a/src/segmentor/segment_dll.h b/src/segmentor/segment_dll.h
index 3912986f1..28f5fea86 100644
--- a/src/segmentor/segment_dll.h
+++ b/src/segmentor/segment_dll.h
@@ -1,5 +1,7 @@
 /*
- * this is a test.
+ * LTP Segmentor Wrapper
+ *
+ * Allowing user to use segmentor like a C function.
  */
 #ifndef __LTP_SEGMENT_DLL_H__
 #define __LTP_SEGMENT_DLL_H__
@@ -13,38 +15,38 @@
 #ifdef _WIN32
 #undef SEGMENTOR_DLL_API
 #ifdef SEGMENTOR_DLL_API_EXPORT
-    #define SEGMENTOR_DLL_API extern "C" _declspec(dllexport)
+  #define SEGMENTOR_DLL_API extern "C" _declspec(dllexport)
 #else
-    #define SEGMENTOR_DLL_API extern "C" _deslspec(dllimport)
-    #pragma comment(lib, "segmentor.lib")
-#endif      //  end for SEGMENTOR_DLL_API_EXPORT
-#endif      //  end for _WIN32
+  #define SEGMENTOR_DLL_API extern "C" _deslspec(dllimport)
+  #pragma comment(lib, "segmentor.lib")
+#endif    //  end for SEGMENTOR_DLL_API_EXPORT
+#endif    //  end for _WIN32
 
 /*
  * create a new parser
  *
- *  @param[in]  path    the path of the model
- *  @return     void *  the pointer to the segmentor
+ *  @param[in]  path  the path of the model
+ *  @return   void *  the pointer to the segmentor
  */
-SEGMENTOR_DLL_API void * segmentor_create_segmentor(const char * path, const char * lexicon_file = NULL);
+SEGMENTOR_DLL_API void * segmentor_create_segmentor(const char * path,
+                                                    const char * lexicon_file = NULL);
 
 /*
  * release the segmentor resources
  *
  *  @param[in]  segmentor   the segmentor
- *  @return     int         i don't know
+ *  @return   int     i don't know
  */
 SEGMENTOR_DLL_API int segmentor_release_segmentor(void * parser); 
-
 /*
  * run segment on the given segmentor
  *
- *  @param[in]  line        the string to be segmented
- *  @param[out] words       the words of the input line
- *  @return     int         the number of word tokens
+ *  @param[in]  line    the string to be segmented
+ *  @param[out] words     the words of the input line
+ *  @return   int     the number of word tokens
  */
 SEGMENTOR_DLL_API int segmentor_segment(void * parser,
-        const std::string & line,
-        std::vector<std::string> & words);
+                                        const std::string & line,
+                                        std::vector<std::string> & words);
 
 #endif  //  end for __LTP_SEGMENT_DLL_H__
diff --git a/src/segmentor/segmentor.cpp b/src/segmentor/segmentor.cpp
index 9c733d5af..41a014141 100644
--- a/src/segmentor/segmentor.cpp
+++ b/src/segmentor/segmentor.cpp
@@ -11,13 +11,14 @@
 
 #include <iostream>
 #include <fstream>
+#include <sstream>
 #include <algorithm>    //  std::sort
 #include <functional>   //  std::greater
 
 #if _WIN32
 #include <Windows.h>
 #define sleep Sleep
-#endif	//	end for _WIN32
+#endif  //  end for _WIN32
 
 namespace ltp {
 namespace segmentor {
@@ -25,789 +26,886 @@ namespace segmentor {
 Segmentor::Segmentor() :
    model(0),
    decoder(0),
-   baseAll(0) {
+   baseAll(0),
+   __TRAIN__(false),
+   __TEST__(false),
+   __DUMP__(false) {
 }
 
 Segmentor::Segmentor(ltp::utility::ConfigParser & cfg) :
-    model(0),
-    decoder(0),
-    baseAll(0) {
-    parse_cfg(cfg);
+  model(0),
+  decoder(0),
+  baseAll(0),
+  __TRAIN__(false),
+  __TEST__(false),
+  __DUMP__(false) {
+  parse_cfg(cfg);
 }
 
 Segmentor::~Segmentor() {
-    if (model) {
-        delete model;
-    }
+  if (model) {
+    delete model;
+  }
 
-    if (decoder) {
-        delete decoder;
-    }
+  if (decoder) {
+    delete decoder;
+  }
 
-    if(baseAll) {
-        delete baseAll;
-    }
+  if(baseAll) {
+    delete baseAll;
+  }
 }
 
-void Segmentor::run(void) {
-    if (__TRAIN__) {
-        train();
-    }
+void
+Segmentor::run(void) {
+  if (__TRAIN__) {
+    train();
+  }
 
-    if (__TEST__) {
-        test();
-    }
+  if (__TEST__) {
+    test();
+  }
 
-    if (__DUMP__) {
-        dump();
-    }
+  if (__DUMP__) {
+    dump();
+  }
 
-    for (int i = 0; i < train_dat.size(); ++ i) {
-        if (train_dat[i]) {
-            delete train_dat[i];
-        }
+  for (int i = 0; i < train_dat.size(); ++ i) {
+    if (train_dat[i]) {
+      delete train_dat[i];
     }
+  }
 }
 
-bool Segmentor::parse_cfg(ltp::utility::ConfigParser & cfg) {
-    std::string strbuf;
-    int         intbuf;
+bool
+Segmentor::parse_cfg(ltp::utility::ConfigParser & cfg) {
+  std::string strbuf;
+  int         intbuf;
+
+  train_opt.train_file              = "";
+  train_opt.holdout_file            = "";
+  train_opt.algorithm               = "pa";
+  train_opt.model_name              = "";
+  train_opt.max_iter                = 10;
+  train_opt.display_interval        = 5000;
+  train_opt.rare_feature_threshold  = 0;
+
+  if (cfg.has_section("train")) {
+    TRACE_LOG("Training mode specified.");
+    __TRAIN__ = true;
+
+    if (cfg.get("train", "train-file", strbuf)) {
+      train_opt.train_file = strbuf;
+    } else {
+      ERROR_LOG("train-file config item is not found.");
+      return false;
+    }
 
-    __TRAIN__ = false;
+    if (cfg.get("train", "holdout-file", strbuf)) {
+      train_opt.holdout_file = strbuf;
+    } else {
+      ERROR_LOG("holdout-file config item is not found.");
+      return false;
+    }
 
-    train_opt.train_file    = "";
-    train_opt.holdout_file  = "";
-    train_opt.algorithm     = "pa";
-    train_opt.model_name    = "";
-    train_opt.max_iter      = 10;
-    train_opt.display_interval = 5000;
+    if (cfg.get("train", "algorithm", strbuf)) {
+      train_opt.algorithm = strbuf;
+    } else {
+      WARNING_LOG("algorithm is not configed, [PA] is set as default");
+    }
 
-    if (cfg.has_section("train")) {
-        TRACE_LOG("Training mode specified.");
-        __TRAIN__ = true;
+    if (cfg.get("train", "rare-feature-threshold", strbuf)) {
+      train_opt.rare_feature_threshold = atoi(strbuf.c_str());
+    } else {
+      WARNING_LOG("rare feature threshold is not configed, 10 is set as default");
+    }
 
-        if (cfg.get("train", "train-file", strbuf)) {
-            train_opt.train_file = strbuf;
-        } else {
-            ERROR_LOG("train-file config item is not found.");
-            return false;
-        }
+    train_opt.model_name = train_opt.train_file + "." + train_opt.algorithm;
+    if (cfg.get("train", "model-name", strbuf)) {
+      train_opt.model_name = strbuf;
+    } else {
+      WARNING_LOG("model name is not configed, [%s] is set as default",
+                  train_opt.model_name.c_str());
+    }
 
-        if (cfg.get("train", "holdout-file", strbuf)) {
-            train_opt.holdout_file = strbuf;
-        } else {
-            ERROR_LOG("holdout-file config item is not found.");
-            return false;
-        }
+    if (cfg.get_integer("train", "max-iter", intbuf)) {
+      train_opt.max_iter = intbuf;
+    } else {
+      WARNING_LOG("max-iter is not configed, [10] is set as default.");
+    }
+  }
 
-        if (cfg.get("train", "algorithm", strbuf)) {
-            train_opt.algorithm = strbuf;
-        } else {
-            WARNING_LOG("algorithm is not configed, [PA] is set as default");
-        }
+  test_opt.test_file    = "";
+  test_opt.model_file   = "";
+  test_opt.lexicon_file = "";
 
-        train_opt.model_name = train_opt.train_file + "." + train_opt.algorithm;
-        if (cfg.get("train", "model-name", strbuf)) {
-            train_opt.model_name = strbuf;
-        } else {
-            WARNING_LOG("model name is not configed, [%s] is set as default",
-                    train_opt.model_name.c_str());
-        }
+  if (cfg.has_section("test")) {
+    __TEST__ = true;
 
-        if (cfg.get_integer("train", "max-iter", intbuf)) {
-            train_opt.max_iter = intbuf;
-        } else {
-            WARNING_LOG("max-iter is not configed, [10] is set as default.");
-        }
+    if (cfg.get("test", "test-file", strbuf)) {
+      test_opt.test_file = strbuf;
+    } else {
+      ERROR_LOG("test-file config item is not set.");
+      return false;
     }
 
-    __TEST__ = false;
+    if (cfg.get("test", "model-file", strbuf)) {
+      test_opt.model_file = strbuf;
+    } else {
+      ERROR_LOG("model-file is not configed.");
+      return false;
+    }
 
-    test_opt.test_file = "";
-    test_opt.model_file = "";
-    test_opt.lexicon_file = "";
+    if (cfg.get("test", "lexicon-file", strbuf)) {
+      test_opt.lexicon_file = strbuf;
+    }
+  }
 
-    if (cfg.has_section("test")) {
-        __TEST__ = true;
+  dump_opt.model_file = "";
+  if (cfg.has_section("dump")) {
+    __DUMP__ = true;
 
-        if (cfg.get("test", "test-file", strbuf)) {
-            test_opt.test_file = strbuf;
-        } else {
-            ERROR_LOG("test-file config item is not set.");
-            return false;
-        }
+    if (cfg.get("dump", "model-file", strbuf)) {
+      dump_opt.model_file = strbuf;
+    } else {
+      ERROR_LOG("model-file is not configed.");
+      return false;
+    }
+  }
 
-        if (cfg.get("test", "model-file", strbuf)) {
-            test_opt.model_file = strbuf;
-        } else {
-            ERROR_LOG("model-file is not configed. ");
-            return false;
-        }
+  return true;
+}
 
-        if (cfg.get("test", "lexicon-file", strbuf)) {
-            test_opt.lexicon_file = strbuf;
-        }
-    }
+bool
+Segmentor::read_instance(const char * train_file) {
+  std::ifstream ifs(train_file);
 
-    __DUMP__ = false;
+  if (!ifs) {
+    return false;
+  }
 
-    dump_opt.model_file = "";
-    if (cfg.has_section("dump")) {
-        __DUMP__ = true;
+  SegmentReader reader(ifs, true);
+  train_dat.clear();
 
-        if (cfg.get("dump", "model-file", strbuf)) {
-            dump_opt.model_file = strbuf;
-        } else {
-            ERROR_LOG("model-file is not configed.");
-            return false;
-        }
-    }
+  Instance * inst = NULL;
+
+  while ((inst = reader.next())) {
+    train_dat.push_back(inst);
+  }
 
-    return true;
+  return true;
 }
 
-bool Segmentor::read_instance(const char * train_file) {
-    std::ifstream ifs(train_file);
+void
+Segmentor::build_configuration(void) {
+  // model->labels.push( __dummy__ );
+  for (int i = 0; i < train_dat.size(); ++ i) {
+    Instance * inst = train_dat[i];
+    int len = inst->size();
 
-    if (!ifs) {
-        return false;
-    }
+    inst->tagsidx.resize(len);
+    for (int j = 0; j < len; ++ j) {
+      // build labels dictionary
+      inst->tagsidx[j] = model->labels.push( inst->tags[j] );
+    }
+
+  }
+  TRACE_LOG("Label sets is built");
+
+  SmartMap<bool> wordfreq;
+  long long total_freq = 0;
+  for (int i = 0; i < train_dat.size(); ++ i) {
+    //
+    Instance * inst = train_dat[i];
+    int len = inst->words.size();
+    int buff = 0;
+
+    for (int j = 0; j < len; ++ j) {
+      wordfreq.set(inst->words[j].c_str(), true);
+    }
+    total_freq += inst->words.size();
+  }
+
+  std::vector<int> freqs;
+  for (SmartMap<bool>::const_iterator itx = wordfreq.begin();
+      itx != wordfreq.end();
+      ++ itx) {
+    freqs.push_back(itx.frequency());
+  }
+
+  long long accumulate_freq = 0;
+  std::sort(freqs.begin(), freqs.end(), std::greater<int>());
+  int target = freqs[int(freqs.size() * 0.2)];
+  for (int i = 0; i < freqs.size(); ++ i) {
+    accumulate_freq += freqs[i];
+    if (accumulate_freq > total_freq * 0.9) {
+      target = freqs[i];
+      break;
+    }
+  }
+
+  for (SmartMap<bool>::const_iterator itx = wordfreq.begin();
+      itx != wordfreq.end();
+      ++ itx) {
+    if (itx.frequency() >= target && strutils::codecs::length(itx.key()) > 1) {
+    // if (itx.frequency() >= target) {
+      model->internal_lexicon.set(itx.key(), true);
+    }
+  }
+
+  TRACE_LOG("Collecting interanl lexicon is done.");
+  TRACE_LOG("Total word frequency : %ld", total_freq);
+  TRACE_LOG("Vocabulary size: %d", wordfreq.size());
+  TRACE_LOG("Trancation word frequency : %d", target);
+  TRACE_LOG("Internal lexicon size : %d", model->internal_lexicon.size());
+}
 
-    SegmentReader reader(ifs, true);
-    train_dat.clear();
+void
+Segmentor::extract_features(Instance * inst, bool create) {
+  const int N = Extractor::num_templates();
+  const int L = model->num_labels();
 
-    Instance * inst = NULL;
+  vector< StringVec > cache;
+  vector< int > cache_again;
 
-    while ((inst = reader.next())) {
-        train_dat.push_back(inst);
-    }
+  cache.resize(N);
+  int len = inst->size();
 
-    return true;
-}
+  // allocate the uni_features
+  inst->uni_features.resize(len, L);  inst->uni_features = 0;
+  inst->uni_scores.resize(len, L);  inst->uni_scores = NEG_INF;
+  inst->bi_scores.resize(L, L);     inst->bi_scores = NEG_INF;
 
+  // cache lexicon features.
+  if (0 == inst->lexicon_match_state.size()) {
+    inst->lexicon_match_state.resize(len, 0);
 
-void Segmentor::build_configuration(void) {
-    // model->labels.push( __dummy__ );
-    for (int i = 0; i < train_dat.size(); ++ i) {
-        Instance * inst = train_dat[i];
-        int len = inst->size();
+    for (int i = 0; i < len; ++ i) {
+      std::string word; word.reserve(32);
+      for (int j = i; j<i+5 && j < len; ++ j) {
+        word = word + inst->forms[j];
 
-        inst->tagsidx.resize(len);
-        for (int j = 0; j < len; ++ j) {
-            // build labels dictionary
-            inst->tagsidx[j] = model->labels.push( inst->tags[j] );
+        // it's not a lexicon word
+        if (!model->internal_lexicon.get(word.c_str())
+            && !model->external_lexicon.get(word.c_str())) {
+          continue;
         }
 
-    }
-    TRACE_LOG("Label sets is built");
-
-    SmartMap<bool> wordfreq;
-    long long total_freq = 0;
-    for (int i = 0; i < train_dat.size(); ++ i) {
-        //
-        Instance * inst = train_dat[i];
-        int len = inst->size();
-        int buff = 0;
+        int l = j+1-i;
 
-        for (int j = 0; j < inst->words.size(); ++ j) {
-            wordfreq.set(inst->words[j].c_str(), true);
+        if (l > (inst->lexicon_match_state[i] & 0x0F)) {
+          inst->lexicon_match_state[i] &= 0xfff0;
+          inst->lexicon_match_state[i] |= l;
         }
-        total_freq += inst->words.size();
-    }
-
-    std::vector<int> freqs;
-    for (SmartMap<bool>::const_iterator itx = wordfreq.begin(); 
-            itx != wordfreq.end(); 
-            ++ itx) {
-        freqs.push_back(itx.frequency());
-    }
 
-    long long accumulate_freq = 0;
-    std::sort(freqs.begin(), freqs.end(), std::greater<int>());
-    int target = freqs[int(freqs.size() * 0.2)];
-    for (int i = 0; i < freqs.size(); ++ i) {
-        accumulate_freq += freqs[i];
-        if (accumulate_freq > total_freq * 0.9) {
-            target = freqs[i];
-            break;
+        if (l > ((inst->lexicon_match_state[j]>>4) & 0x0F)) {
+          inst->lexicon_match_state[j] &= 0xff0f;
+          inst->lexicon_match_state[j] |= (l<<4);
         }
-    }
 
-    for (SmartMap<bool>::const_iterator itx = wordfreq.begin();
-            itx != wordfreq.end();
-            ++ itx) {
-        if (itx.frequency() >= target && strutils::codecs::length(itx.key()) > 1) {
-        // if (itx.frequency() >= target) {
-            model->internal_lexicon.set(itx.key(), true);
+        for (int k = i+1; k < j; ++k) {
+          if (l>((inst->lexicon_match_state[k]>>8) & 0x0F)) {
+            inst->lexicon_match_state[k] &= 0xf0ff;
+            inst->lexicon_match_state[k] |= (l<<8);
+          }
         }
+      }
     }
+  }
 
-    TRACE_LOG("Collecting interanl lexicon is done.");
-    TRACE_LOG("Total word frequency : %ld", total_freq);
-    TRACE_LOG("Vocabulary size: %d", wordfreq.size());
-    TRACE_LOG("Trancation word frequency : %d", target);
-    TRACE_LOG("Internal lexicon size : %d", model->internal_lexicon.size());
-}
+  for (int pos = 0; pos < len; ++ pos) {
+    for (int n = 0; n < N; ++ n) {
+      cache[n].clear();
+    }
+    cache_again.clear();
 
-void Segmentor::extract_features(Instance * inst, bool create) {
-    const int N = Extractor::num_templates();
-    const int L = model->num_labels();
+    Extractor::extract1o(inst, pos, cache);
 
-    vector< StringVec > cache;
-    vector< int > cache_again;
+    for (int tid = 0; tid < cache.size(); ++ tid) {
+      for (int itx = 0; itx < cache[tid].size(); ++ itx) {
+        if (create) {
+          model->space.retrieve(tid, cache[tid][itx], true);
+        }
 
-    cache.resize(N);
-    int len = inst->size();
+        int idx = model->space.index(tid, cache[tid][itx]);
 
-    // allocate the uni_features
-    inst->uni_features.resize(len, L);  inst->uni_features = 0;
-    inst->uni_scores.resize(len, L);    inst->uni_scores = NEG_INF;
-    inst->bi_scores.resize(L, L);       inst->bi_scores = NEG_INF;
-
-    // cache lexicon features.
-    if (0 == inst->lexicon_match_state.size()) {
-        inst->lexicon_match_state.resize(len, 0);
-
-        for (int i = 0; i < len; ++ i) {
-            std::string word; word.reserve(32);
-            for (int j = i; j<i+5 && j < len; ++ j) {
-                word = word + inst->forms[j];
-
-                // it's not a lexicon word
-                if (!model->internal_lexicon.get(word.c_str()) 
-                        && !model->external_lexicon.get(word.c_str())) {
-                    continue;
-                }
-
-                int l = j+1-i;
-
-                if (l > (inst->lexicon_match_state[i] & 0x0F)) {
-                    inst->lexicon_match_state[i] &= 0xfff0;
-                    inst->lexicon_match_state[i] |= l;
-                }
-
-                if (l > ((inst->lexicon_match_state[j]>>4) & 0x0F)) {
-                    inst->lexicon_match_state[j] &= 0xff0f;
-                    inst->lexicon_match_state[j] |= (l<<4);
-                }
-
-                for (int k = i+1; k < j; ++k) {
-                    if (l>((inst->lexicon_match_state[k]>>8) & 0x0F)) {
-                        inst->lexicon_match_state[k] &= 0xf0ff;
-                        inst->lexicon_match_state[k] |= (l<<8);
-                    }
-                }
-            }
+        if (idx >= 0) {
+          cache_again.push_back(idx);
         }
+      }
     }
 
-    for (int pos = 0; pos < len; ++ pos) {
-        for (int n = 0; n < N; ++ n) {
-            cache[n].clear();
-        }
-        cache_again.clear();
+    int num_feat = cache_again.size();
 
-        Extractor::extract1o(inst, pos, cache);
+    if (num_feat > 0) {
+      int l = 0;
+      int * idx = new int[num_feat];
+      for (int j = 0; j < num_feat; ++ j) {
+        idx[j] = cache_again[j];
+      }
 
-        for (int tid = 0; tid < cache.size(); ++ tid) {
-            for (int itx = 0; itx < cache[tid].size(); ++ itx) {
-                if (create) {
-                    model->space.retrieve(tid, cache[tid][itx], true);
-                }
+      inst->uni_features[pos][l] = new FeatureVector;
+      inst->uni_features[pos][l]->n = num_feat;
+      inst->uni_features[pos][l]->val = 0;
+      inst->uni_features[pos][l]->loff = 0;
+      inst->uni_features[pos][l]->idx = idx;
 
-                int idx = model->space.index(tid, cache[tid][itx]);
-
-                if (idx >= 0) {
-                    cache_again.push_back(idx);
-                }
-            }
-        }
-
-        int num_feat = cache_again.size();
-
-        if (num_feat > 0) {
-            int l = 0;
-            int * idx = new int[num_feat];
-            for (int j = 0; j < num_feat; ++ j) {
-                idx[j] = cache_again[j];
-            }
-
-            inst->uni_features[pos][l] = new FeatureVector;
-            inst->uni_features[pos][l]->n = num_feat;
-            inst->uni_features[pos][l]->val = 0;
-            inst->uni_features[pos][l]->loff = 0;
-            inst->uni_features[pos][l]->idx = idx;
-
-            for (l = 1; l < L; ++ l) {
-                inst->uni_features[pos][l] = new FeatureVector;
-                inst->uni_features[pos][l]->n = num_feat;
-                inst->uni_features[pos][l]->idx = idx;
-                inst->uni_features[pos][l]->val = 0;
-                inst->uni_features[pos][l]->loff = l;
-            }
-        }
+      for (l = 1; l < L; ++ l) {
+        inst->uni_features[pos][l] = new FeatureVector;
+        inst->uni_features[pos][l]->n = num_feat;
+        inst->uni_features[pos][l]->idx = idx;
+        inst->uni_features[pos][l]->val = 0;
+        inst->uni_features[pos][l]->loff = l;
+      }
     }
+  }
 }
 
-void Segmentor::build_words(Instance * inst,
-        const std::vector<int> & tagsidx,
-        std::vector<std::string> & words,
-        int beg_tag0,
-        int beg_tag1) {
-    std::string word = "";
-    int len = inst->size();
-
-    // should check the tagsidx size
-    word = inst->raw_forms[0];
-    for (int i = 1; i < len; ++ i) {
-        int tag = tagsidx[i];
-        if (tag == beg_tag0 || tag == beg_tag1) {
-            words.push_back(word);
-            word = inst->raw_forms[i];
-        } else {
-            word += inst->raw_forms[i];
-        }
+void
+Segmentor::build_words(Instance * inst,
+                       const std::vector<int> & tagsidx,
+                       std::vector<std::string> & words,
+                       int beg_tag0,
+                       int beg_tag1) {
+
+  int len = inst->size();
+
+  // should check the tagsidx size
+  std::string word = inst->raw_forms[0];
+  for (int i = 1; i < len; ++ i) {
+    int tag = tagsidx[i];
+    if (tag == beg_tag0 || tag == beg_tag1) {
+      words.push_back(word);
+      word = inst->raw_forms[i];
+    } else {
+      word += inst->raw_forms[i];
     }
+  }
 
-    words.push_back(word);
+  words.push_back(word);
 }
 
-void Segmentor::build_feature_space(void) {
-    // build feature space, it a wrapper for
-    // featurespace.build_feature_space
-    int N = Extractor::num_templates();
-    int L = model->num_labels();
-    model->space.set_num_labels(L);
-
-    for (int i = 0; i < train_dat.size(); ++ i) {
-        extract_features(train_dat[i], true);
-        if ((i + 1) % train_opt.display_interval == 0) {
-            TRACE_LOG("[%d] instances is extracted.", (i+1));
-        }
+void
+Segmentor::build_feature_space(void) {
+  // build feature space, it a wrapper for
+  // featurespace.build_feature_space
+  int N = Extractor::num_templates();
+  int L = model->num_labels();
+  model->space.set_num_labels(L);
+
+  for (int i = 0; i < train_dat.size(); ++ i) {
+    extract_features(train_dat[i], true);
+    if ((i + 1) % train_opt.display_interval == 0) {
+      TRACE_LOG("[%d] instances is extracted.", (i+1));
     }
+  }
 }
 
-void Segmentor::calculate_scores(Instance * inst, bool use_avg) {
-    int len = inst->size();
-    int L = model->num_labels();
-    for (int i = 0; i < len; ++ i) {
-        for (int l = 0; l < L; ++ l) {
-            FeatureVector * fv = inst->uni_features[i][l];
-            if (!fv) {
-                continue;
-            }
+void
+Segmentor::calculate_scores(Instance * inst, bool use_avg) {
+  int len = inst->size();
+  int L = model->num_labels();
+  for (int i = 0; i < len; ++ i) {
+    for (int l = 0; l < L; ++ l) {
+      FeatureVector * fv = inst->uni_features[i][l];
+      if (!fv) {
+        continue;
+      }
 
-            inst->uni_scores[i][l] = model->param.dot(inst->uni_features[i][l], use_avg);
-        }
+      inst->uni_scores[i][l] = model->param.dot(inst->uni_features[i][l], use_avg);
     }
+  }
 
-    for (int pl = 0; pl < L; ++ pl) {
-        for (int l = 0; l < L; ++ l) {
-            int idx = model->space.index(pl, l);
-            inst->bi_scores[pl][l] = model->param.dot(idx, use_avg);
-        }
+  for (int pl = 0; pl < L; ++ pl) {
+    for (int l = 0; l < L; ++ l) {
+      int idx = model->space.index(pl, l);
+      inst->bi_scores[pl][l] = model->param.dot(idx, use_avg);
     }
+  }
 }
 
-void Segmentor::collect_features(Instance * inst, const std::vector<int> & tagsidx, math::SparseVec & vec) {
-    int len = inst->size();
+void
+Segmentor::collect_features(Instance * inst,
+                            const std::vector<int> & tagsidx,
+                            math::SparseVec & vec) {
+  int len = inst->size();
 
-    vec.zero();
-    for (int i = 0; i < len; ++ i) {
-        int l = tagsidx[i];
-        const FeatureVector * fv = inst->uni_features[i][l];
+  vec.zero();
+  for (int i = 0; i < len; ++ i) {
+    int l = tagsidx[i];
+    const FeatureVector * fv = inst->uni_features[i][l];
 
-        if (!fv) {
-            continue;
-        }
+    if (!fv) {
+      continue;
+    }
 
-        vec.add(fv->idx, fv->val, fv->n, fv->loff, 1.);
+    vec.add(fv->idx, fv->val, fv->n, fv->loff, 1.);
 
-        if (i > 0) {
-            int prev_lid = tagsidx[i-1];
-            int idx = model->space.index(prev_lid, l);
-            vec.add(idx, 1.);
-        }
+    if (i > 0) {
+      int prev_lid = tagsidx[i-1];
+      int idx = model->space.index(prev_lid, l);
+      vec.add(idx, 1.);
     }
+  }
 }
 
-Model * Segmentor::truncate(void) {
-    Model * new_model = new Model;
-    // copy the label indexable map to the new model
-    for (int i = 0; i < model->labels.size(); ++ i) {
-        const char * key = model->labels.at(i);
-        new_model->labels.push(key);
-    }
-
-    TRACE_LOG("building labels map is done");
-
-    int L = new_model->num_labels();
-    new_model->space.set_num_labels(L);
-
-    // iterate over the feature space and see if the parameter value equals to zero
-    for (FeatureSpaceIterator itx = model->space.begin(); 
-            itx != model->space.end(); 
-            ++ itx) {
-        const char * key = itx.key();
-        int tid = itx.tid();
-        int id = model->space.index(tid, key);
-
-        bool flag = false;
-        for (int l = 0; l < L; ++ l) {
-            double p = model->param.dot(id + l);
-            if (p != 0.) {
-                flag = true;
-            }
-        }
-
-        if (!flag) {
-            continue;
-        }
+void
+Segmentor::increase_group_updated_time(const math::SparseVec & vec,
+                                       int * feature_group_updated_time) {
+  int L = model->num_labels();
+  for (math::SparseVec::const_iterator itx = vec.begin();
+      itx != vec.end();
+      ++ itx) {
 
-        new_model->space.retrieve(tid, key, true);
+    int idx = itx->first;
+    if (itx->second != 0.0) {
+      ++ feature_group_updated_time[idx / L];
     }
-    TRACE_LOG("Scanning old features space, building new feature space is done");
+  }
+}
 
-    new_model->param.realloc(new_model->space.dim());
-    TRACE_LOG("Parameter dimension of new model is [%d]", new_model->space.dim());
+// Perform model truncation on the model, according to these two conditions
+//  (1) Erase the group of parameters that it all the parameter in this group
+//      is equals to zero.
+//  (2) (optional) Erase the group of parameters the total updated time is
+//      lower than the pre-defined threshold.
+Model *
+Segmentor::erase_rare_features(const int * feature_updated_times) {
+  Model * new_model = new Model;
+  // copy the label indexable map to the new model
+  for (int i = 0; i < model->labels.size(); ++ i) {
+    const char * key = model->labels.at(i);
+    new_model->labels.push(key);
+  }
+
+  TRACE_LOG("building labels map is done");
+
+  int L = new_model->num_labels();
+  new_model->space.set_num_labels(L);
+
+  // Iterate over the feature space
+  for (FeatureSpaceIterator itx = model->space.begin();
+      itx != model->space.end();
+      ++ itx) {
+    const char * key = itx.key();
+    int tid = itx.tid();
+    int id  = model->space.index(tid, key);
+
+    // Enumerate each feature with the same feature prefix, check if it's zero.
+    bool flag = false;
+    for (int l = 0; l < L; ++ l) {
+      double p = model->param.dot(id + l);
+      if (p != 0.) {
+        flag = true;
+      }
+    }
+
+    if (!flag) {
+      continue;
+    }
+
+    // Check if this feature's updated time.
+    int idx = model->space.retrieve(tid, key, false);
+    if (feature_updated_times
+        && (feature_updated_times[idx] < train_opt.rare_feature_threshold)) {
+      continue;
+    }
+
+    new_model->space.retrieve(tid, key, true);
+  }
+
+  TRACE_LOG("Scanning old features space, building new feature space is done");
+  new_model->param.realloc(new_model->space.dim());
+  TRACE_LOG("Parameter dimension of new model is [%d]", new_model->space.dim());
+
+  for (FeatureSpaceIterator itx = new_model->space.begin();
+      itx != new_model->space.end();
+      ++ itx) {
+    const char * key = itx.key();
+    int tid = itx.tid();
+
+    int old_id = model->space.index(tid, key);
+    int new_id = new_model->space.index(tid, key);
+
+    for (int l = 0; l < L; ++ l) {
+      // pay attention to this place, use average should be set true
+      // some dirty code
+      new_model->param._W[new_id + l]      = model->param._W[old_id + l];
+      new_model->param._W_sum[new_id + l]  = model->param._W_sum[old_id + l];
+      new_model->param._W_time[new_id + l] = model->param._W_time[old_id + l];
+    }
+  }
+
+  for (int pl = 0; pl < L; ++ pl) {
+    for (int l = 0; l < L; ++ l) {
+      int old_id = model->space.index(pl, l);
+      int new_id = new_model->space.index(pl, l);
+
+      new_model->param._W[new_id]      = model->param._W[old_id];
+      new_model->param._W_sum[new_id]  = model->param._W_sum[old_id];
+      new_model->param._W_time[new_id] = model->param._W_time[old_id];
+    }
+  }
+  TRACE_LOG("Building new model is done");
+
+  for (SmartMap<bool>::const_iterator itx = model->internal_lexicon.begin();
+      itx != model->internal_lexicon.end();
+      ++ itx) {
+    new_model->internal_lexicon.set(itx.key(), true);
+  }
+
+  return new_model;
+}
 
-    for (FeatureSpaceIterator itx = new_model->space.begin();
-            itx != new_model->space.end();
-            ++ itx) {
-        const char * key = itx.key();
-        int tid = itx.tid();
+void
+Segmentor::train(void) {
+  const char * train_file = train_opt.train_file.c_str();
 
-        int old_id = model->space.index(tid, key);
-        int new_id = new_model->space.index(tid, key);
+  // read in training instance
+  if (!read_instance(train_file)) {
+    ERROR_LOG("Training file not exist.");
+    return;
+  }
+  TRACE_LOG("Read in [%d] instances.", train_dat.size());
+
+  model = new Model;
+  // build tag dictionary, map string tag to index
+  TRACE_LOG("Start build configuration");
+  build_configuration();
+  TRACE_LOG("Build configuration is done.");
+  TRACE_LOG("Number of labels: [%d]", model->labels.size());
+
+  // build feature space from the training instance
+  TRACE_LOG("Start building feature space.");
+  build_feature_space();
+  TRACE_LOG("Building feature space is done.");
+  TRACE_LOG("Number of features: [%d]", model->space.num_features());
+
+  model->param.realloc(model->space.dim());
+  TRACE_LOG("Allocate [%d] dimensition parameter.", model->space.dim());
+
+  int nr_feature_groups = model->space.num_feature_groups();
+  int * feature_group_updated_time = NULL;
+
+  // If the rare feature threshold is used, allocate memory for the
+  // feature group updated time.
+  if (train_opt.rare_feature_threshold > 0) {
+    feature_group_updated_time = new int[nr_feature_groups];
+    for (int i = 0; i < nr_feature_groups; ++ i) {
+      feature_group_updated_time[i] = 0;
+    }
+  }
+
+  TRACE_LOG("Allocate [%d] update counters.", nr_feature_groups);
+
+  SegmentWriter writer(cout);
+
+  if (train_opt.algorithm == "mira") {
+    // use mira to train model
+    // it's still not implemented.
+  } else {
+    // use pa or average perceptron algorithm
+    rulebase::RuleBase base(model->labels);
+    decoder = new Decoder(model->num_labels(), base);
+    TRACE_LOG("Allocated plain decoder");
 
-        for (int l = 0; l < L; ++ l) {
-            // pay attention to this place, use average should be set true
-            // some dirty code
-            new_model->param._W[new_id + l]         = model->param._W[old_id + l];
-            new_model->param._W_sum[new_id + l]     = model->param._W_sum[old_id + l];
-            new_model->param._W_time[new_id + l]    = model->param._W_time[old_id + l];
-        }
-    }
+    int best_iteration = -1;
+    double best_p = -1.;
+    double best_r = -1.;
+    double best_f = -1.;
 
-    for (int pl = 0; pl < L; ++ pl) {
-        for (int l = 0; l < L; ++ l) {
-            int old_id = model->space.index(pl, l);
-            int new_id = new_model->space.index(pl, l);
+    for (int iter = 0; iter < train_opt.max_iter; ++ iter) {
+      TRACE_LOG("Training iteraition [%d]", (iter + 1));
 
-            new_model->param._W[new_id]         = model->param._W[old_id];
-            new_model->param._W_sum[new_id]     = model->param._W_sum[old_id];
-            new_model->param._W_time[new_id]    = model->param._W_time[old_id];
-        }
-    }
-    TRACE_LOG("Building new model is done");
+      for (int i = 0; i < train_dat.size(); ++ i) {
+        // extract_features(train_dat[i]);
 
-    for (SmartMap<bool>::const_iterator itx = model->internal_lexicon.begin();
-            itx != model->internal_lexicon.end();
-            ++ itx) {
-        new_model->internal_lexicon.set(itx.key(), true);
-    }
+        Instance * inst = train_dat[i];
+        calculate_scores(inst, false);
+        decoder->decode(inst);
 
-    return new_model;
-}
+        if (inst->features.dim() == 0) {
+          collect_features(inst, inst->tagsidx, inst->features);
+        }
+        collect_features(inst, inst->predicted_tagsidx, inst->predicted_features);
 
-void Segmentor::train(void) {
-    const char * train_file = train_opt.train_file.c_str();
+        if (train_opt.algorithm == "pa") {
+          SparseVec update_features;
+          update_features.zero();
+          update_features.add(train_dat[i]->features, 1.);
+          update_features.add(train_dat[i]->predicted_features, -1.);
 
-    // read in training instance
-    if (!read_instance(train_file)) {
-        ERROR_LOG("Training file not exist.");
-        return;
-    }
-    TRACE_LOG("Read in [%d] instances.", train_dat.size());
+          if (feature_group_updated_time) {
+            increase_group_updated_time(update_features,
+                                        feature_group_updated_time);
+          }
 
-    model = new Model;
-    // build tag dictionary, map string tag to index
-    TRACE_LOG("Start build configuration");
-    build_configuration();
-    TRACE_LOG("Build configuration is done.");
-    TRACE_LOG("Number of labels: [%d]", model->labels.size());
+          double error = train_dat[i]->num_errors();
+          double score = model->param.dot(update_features, false);
+          double norm  = update_features.L2();
 
-    // build feature space from the training instance
-    TRACE_LOG("Start building feature space.");
-    build_feature_space();
-    TRACE_LOG("Building feature space is done.");
-    TRACE_LOG("Number of features: [%d]", model->space.num_features());
+          double step = 0.;
+          if (norm < EPS) {
+            step = 0;
+          } else {
+            step = (error - score) / norm;
+          }
 
-    model->param.realloc(model->space.dim());
-    TRACE_LOG("Allocate [%d] dimensition parameter.", model->space.dim());
+          model->param.add(update_features,
+                           iter * train_dat.size() + i + 1,
+                           step);
 
-    SegmentWriter writer(cout);
+        } else if (train_opt.algorithm == "ap") {
+          SparseVec update_features;
+          update_features.zero();
+          update_features.add(train_dat[i]->features, 1.);
+          update_features.add(train_dat[i]->predicted_features, -1.);
 
-    if (train_opt.algorithm == "mira") {
-        // use mira algorithm
-        /*kbest_decoder = new KBestDecoder(L);
+          if (feature_group_updated_time) {
+            increase_group_updated_time(update_features,
+                                        feature_group_updated_time);
+          }
 
-        for (int iter = 0; iter < train_opt.max_iter; ++ iter) {
-            for (int i = 0; i < train_dat.size(); ++ i) {
-                extract_features(train_dat[i]);
-                calculate_scores(train_dat[i]);
+          model->param.add(update_features,
+                           iter * train_dat.size() + i + 1,
+                           1.);
+        }
 
-                KBestDecoder::KBestDecodeResult result;
-                kbest_decoder->decode(train_dat[i], result);
-            }
-        }*/
-    } else {
-        // use pa or average perceptron algorithm
-        rulebase::RuleBase base(model->labels);
-        decoder = new Decoder(model->num_labels(), base);
-        TRACE_LOG("Allocated plain decoder");
-
-        for (int iter = 0; iter < train_opt.max_iter; ++ iter) {
-            TRACE_LOG("Training iteraition [%d]", (iter + 1));
-            for (int i = 0; i < train_dat.size(); ++ i) {
-                // extract_features(train_dat[i]);
-
-                Instance * inst = train_dat[i];
-                calculate_scores(inst, false);
-                decoder->decode(inst);
-
-                if (inst->features.dim() == 0) {
-                    collect_features(inst, inst->tagsidx, inst->features);
-                }
-                collect_features(inst, inst->predicted_tagsidx, inst->predicted_features);
-
-                // writer.debug(inst, true);
-
-                if (train_opt.algorithm == "pa") {
-                    SparseVec update_features;
-                    update_features.zero();
-                    update_features.add(train_dat[i]->features, 1.);
-                    update_features.add(train_dat[i]->predicted_features, -1.);
-
-                    double error = train_dat[i]->num_errors();
-                    double score = model->param.dot(update_features, false);
-                    double norm = update_features.L2();
-
-                    double step = 0.;
-                    if (norm < EPS) {
-                       step = 0;
-                    } else {
-                        step = (error - score) / norm;
-                    }
-
-                    model->param.add(update_features,
-                            iter * train_dat.size() + i + 1,
-                            step);
-                } else if (train_opt.algorithm == "ap") {
-                    SparseVec update_features;
-                    update_features.zero();
-                    update_features.add(train_dat[i]->features, 1.);
-                    update_features.add(train_dat[i]->predicted_features, -1.);
-
-                    model->param.add(update_features,
-                            iter * train_dat.size() + i + 1,
-                            1.);
-                }
-
-                if ((i+1) % train_opt.display_interval == 0) {
-                    TRACE_LOG("[%d] instances is trained.", i+1);
-                }
-            }
-            model->param.flush( train_dat.size() * (iter + 1) );
-
-            Model * new_model = truncate();
-            swap(model, new_model);
-            evaluate();
-
-            std::string saved_model_file = (train_opt.model_name + "." + strutils::to_str(iter) + ".model");
-            std::ofstream ofs(saved_model_file.c_str(), std::ofstream::binary);
-
-            swap(model, new_model);
-            new_model->save(ofs);
-            delete new_model;
-
-            TRACE_LOG("Model for iteration [%d] is saved to [%s]",
-                    iter + 1,
-                    saved_model_file.c_str());
+        if ((i+1) % train_opt.display_interval == 0) {
+          TRACE_LOG("[%d] instances is trained.", i+1);
         }
-    }
-}
+      }
+      model->param.flush( train_dat.size() * (iter + 1) );
+
+      Model * new_model = NULL;
+      new_model = erase_rare_features(feature_group_updated_time);
+
+      swap(model, new_model);
+
+      double p, r, f;
+      evaluate(p,r,f);
 
-void Segmentor::evaluate(void) {
-    const char * holdout_file = train_opt.holdout_file.c_str();
+      if (f > best_f) {
+        best_p = p;
+        best_r = r;
+        best_f = f;
+        best_iteration = iter;
+      }
 
-    ifstream ifs(holdout_file);
+      std::string saved_model_file = (train_opt.model_name
+                                      + "."
+                                      + strutils::to_str(iter)
+                                      + ".model");
+      std::ofstream ofs(saved_model_file.c_str(), std::ofstream::binary);
 
-    if (!ifs) {
-        ERROR_LOG("Failed to open holdout file.");
-        return;
+      swap(model, new_model);
+      new_model->save(ofs);
+      delete new_model;
+      TRACE_LOG("Model for iteration [%d] is saved to [%s]",
+                iter + 1,
+                saved_model_file.c_str());
     }
 
-    SegmentReader reader(ifs, true);
-    Instance * inst = NULL;
+    if (feature_group_updated_time) {
+      delete [] feature_group_updated_time;
+    }
 
-    int num_recalled_words = 0;
-    int num_predicted_words = 0;
-    int num_gold_words = 0;
+    TRACE_LOG("Best result (iteratin = %d) P = %lf | R = %lf | F = %lf",
+              best_iteration,
+              best_p,
+              best_r,
+              best_f);
+  }
+}
 
-    int beg_tag0 = model->labels.index( __b__ );
-    int beg_tag1 = model->labels.index( __s__ );
+void
+Segmentor::evaluate(double &p, double &r, double &f) {
+  const char * holdout_file = train_opt.holdout_file.c_str();
 
-    int L = model->num_labels();
+  ifstream ifs(holdout_file);
 
-    while ((inst = reader.next())) {
-        int len = inst->size();
-        inst->tagsidx.resize(len);
-        for (int i = 0; i < len; ++ i) {
-            inst->tagsidx[i] = model->labels.index(inst->tags[i]);
-        }
+  if (!ifs) {
+    ERROR_LOG("Failed to open holdout file.");
+    return;
+  }
 
-        extract_features(inst);
-        calculate_scores(inst, true);
+  SegmentReader reader(ifs, true);
+  Instance * inst = NULL;
 
-        decoder->decode(inst);
+  int num_recalled_words = 0;
+  int num_predicted_words = 0;
+  int num_gold_words = 0;
 
-        if (inst->words.size() == 0) {
-            build_words(inst, inst->tagsidx, inst->words, beg_tag0, beg_tag1);
-        }
-        build_words(inst, inst->predicted_tagsidx, inst->predicted_words, beg_tag0, beg_tag1);
+  int beg_tag0 = model->labels.index( __b__ );
+  int beg_tag1 = model->labels.index( __s__ );
 
-        num_recalled_words += inst->num_recalled_words();
-        num_predicted_words += inst->num_predicted_words();
-        num_gold_words += inst->num_gold_words();
+  while ((inst = reader.next())) {
+    int len = inst->size();
+    inst->tagsidx.resize(len);
+    for (int i = 0; i < len; ++ i) {
+      inst->tagsidx[i] = model->labels.index(inst->tags[i]);
+    }
 
-        delete inst;
+    extract_features(inst);
+    calculate_scores(inst, true);
+
+    decoder->decode(inst);
+
+    if (inst->words.size() == 0) {
+      build_words(inst, inst->tagsidx, inst->words, beg_tag0, beg_tag1);
     }
+    build_words(inst,
+                inst->predicted_tagsidx,
+                inst->predicted_words,
+                beg_tag0,
+                beg_tag1);
 
-    double p = (double)num_recalled_words / num_predicted_words;
-    double r = (double)num_recalled_words / num_gold_words;
-    double f = 2 * p * r / (p + r);
+    num_recalled_words += inst->num_recalled_words();
+    num_predicted_words += inst->num_predicted_words();
+    num_gold_words += inst->num_gold_words();
 
-    TRACE_LOG("P: %lf ( %d / %d )", p, num_recalled_words, num_predicted_words);
-    TRACE_LOG("R: %lf ( %d / %d )", r, num_recalled_words, num_gold_words);
-    TRACE_LOG("F: %lf" , f); 
-    return;
+    delete inst;
+  }
+
+  p = (double)num_recalled_words / num_predicted_words;
+  r = (double)num_recalled_words / num_gold_words;
+  f = 2 * p * r / (p + r);
+
+  TRACE_LOG("P: %lf ( %d / %d )", p, num_recalled_words, num_predicted_words);
+  TRACE_LOG("R: %lf ( %d / %d )", r, num_recalled_words, num_gold_words);
+  TRACE_LOG("F: %lf" , f);
+  return;
 }
 
-void Segmentor::test(void) {
-    // load model
-    const char * model_file = test_opt.model_file.c_str();
-    ifstream mfs(model_file, std::ifstream::binary);
+void
+Segmentor::test(void) {
+  // load model
+  const char * model_file = test_opt.model_file.c_str();
+  ifstream mfs(model_file, std::ifstream::binary);
 
-    if (!mfs) {
-        ERROR_LOG("Failed to load model");
-        return;
-    }
+  if (!mfs) {
+    ERROR_LOG("Failed to load model");
+    return;
+  }
 
-    model = new Model;
-    if (!model->load(mfs)) {
-        ERROR_LOG("Failed to load model");
-        return;
-    }
+  model = new Model;
+  if (!model->load(mfs)) {
+    ERROR_LOG("Failed to load model");
+    return;
+  }
 
-    TRACE_LOG("Number of labels                 [%d]", model->num_labels());
-    TRACE_LOG("Number of features               [%d]", model->space.num_features());
-    TRACE_LOG("Number of dimension              [%d]", model->space.dim());
+  TRACE_LOG("Number of labels     [%d]", model->num_labels());
+  TRACE_LOG("Number of features   [%d]", model->space.num_features());
+  TRACE_LOG("Number of dimension  [%d]", model->space.dim());
 
-    // load exteranl lexicon
-    const char * lexicon_file =test_opt.lexicon_file.c_str();
+  // load exteranl lexicon
+  const char * lexicon_file =test_opt.lexicon_file.c_str();
 
-    if (NULL != lexicon_file) {
-        ifstream lfs(lexicon_file);
+  if (NULL != lexicon_file) {
+    ifstream lfs(lexicon_file);
 
-        if (lfs) {
-            std::string buffer;
-            while (std::getline(lfs, buffer)) {
-                buffer = strutils::chomp(buffer);
-                if (buffer.size() == 0) {
-                    continue;
-                }
-                model->external_lexicon.set(buffer.c_str(), true);
-            }
+    if (lfs) {
+      std::string buffer;
+      while (std::getline(lfs, buffer)) {
+        buffer = strutils::chomp(buffer);
+        if (buffer.size() == 0) {
+          continue;
         }
+        model->external_lexicon.set(buffer.c_str(), true);
+      }
     }
+  }
 
-    const char * test_file = test_opt.test_file.c_str();
+  const char * test_file = test_opt.test_file.c_str();
 
-    ifstream ifs(test_file);
+  ifstream ifs(test_file);
 
-    if (!ifs) {
-        ERROR_LOG("Failed to open holdout file.");
-        return;
-    }
+  if (!ifs) {
+    ERROR_LOG("Failed to open holdout file.");
+    return;
+  }
 
-    rulebase::RuleBase base(model->labels);
-    Decoder * decoder = new Decoder(model->num_labels(), base);
-    SegmentReader reader(ifs);
-    SegmentWriter writer(cout);
-    Instance * inst = NULL;
+  rulebase::RuleBase base(model->labels);
+  Decoder * decoder = new Decoder(model->num_labels(), base);
+  SegmentReader reader(ifs);
+  SegmentWriter writer(cout);
+  Instance * inst = NULL;
 
-    int beg_tag0 = model->labels.index( __b__ );
-    int beg_tag1 = model->labels.index( __s__ );
+  int beg_tag0 = model->labels.index( __b__ );
+  int beg_tag1 = model->labels.index( __s__ );
 
-    double before = get_time();
+  double before = get_time();
 
-    while ((inst = reader.next())) {
-        int len = inst->size();
-        inst->tagsidx.resize(len);
+  while ((inst = reader.next())) {
+    int len = inst->size();
+    inst->tagsidx.resize(len);
 
-        extract_features(inst);
-        calculate_scores(inst, true);
-        decoder->decode(inst);
+    extract_features(inst);
+    calculate_scores(inst, true);
+    decoder->decode(inst);
 
-        build_words(inst, 
-                inst->predicted_tagsidx, 
-                inst->predicted_words, 
-                beg_tag0, 
+    build_words(inst,
+                inst->predicted_tagsidx,
+                inst->predicted_words,
+                beg_tag0,
                 beg_tag1);
 
-        writer.write(inst);
-        delete inst;
-    }
-
-    double after = get_time();
-    TRACE_LOG("Eclipse time %lf", after - before);
+    writer.write(inst);
+    delete inst;
+  }
 
-    sleep(1000000);
-    return;
+  double after = get_time();
+  TRACE_LOG("Eclipse time %lf", after - before);
+  return;
 }
 
-void Segmentor::dump() {
-    // load model
-    const char * model_file = dump_opt.model_file.c_str();
-    ifstream mfs(model_file, std::ifstream::binary);
-
-    if (!mfs) {
-        ERROR_LOG("Failed to load model");
-        return;
-    }
 
-    model = new Model;
-    if (!model->load(mfs)) {
-        ERROR_LOG("Failed to load model");
-        return;
-    }
-
-    int L = model->num_labels();
-    TRACE_LOG("Number of labels                 [%d]", model->num_labels());
-    TRACE_LOG("Number of features               [%d]", model->space.num_features());
-    TRACE_LOG("Number of dimension              [%d]", model->space.dim());
+void Segmentor::dump() {
+  // load model
+  const char * model_file = dump_opt.model_file.c_str();
+  ifstream mfs(model_file, std::ifstream::binary);
 
-    for (FeatureSpaceIterator itx = model->space.begin(); itx != model->space.end(); ++ itx) {
-        const char * key = itx.key();
-        int tid = itx.tid();
-        int id = model->space.index(tid, key);
+  if (!mfs) {
+    ERROR_LOG("Failed to load model");
+    return;
+  }
 
-        for (int l = 0; l < L; ++ l) {
-            std::cout << key << " ( " << id + l << " ) "
+  model = new Model;
+  if (!model->load(mfs)) {
+    ERROR_LOG("Failed to load model");
+    return;
+  }
+
+  int L = model->num_labels();
+  TRACE_LOG("Number of labels     [%d]", model->num_labels());
+  TRACE_LOG("Number of features   [%d]", model->space.num_features());
+  TRACE_LOG("Number of dimension  [%d]", model->space.dim());
+
+  for (FeatureSpaceIterator itx = model->space.begin();
+       itx != model->space.end();
+       ++ itx) {
+    const char * key = itx.key();
+    int tid = itx.tid();
+    int id = model->space.index(tid, key);
+
+    for (int l = 0; l < L; ++ l) {
+      std::cout << key
+                << " ( " << id + l << " ) "
                 << " --> "
                 << model->param.dot(id + l)
                 << std::endl;
-        }
     }
+  }
 
-    for (int pl = 0; pl < L; ++ pl) {
-        for (int l = 0; l < L; ++ l) {
-            int id = model->space.index(pl, l);
-            std::cout << pl << " --> " << l << " " << model->param.dot(id) << std::endl;
-        }
+  for (int pl = 0; pl < L; ++ pl) {
+    for (int l = 0; l < L; ++ l) {
+      int id = model->space.index(pl, l);
+      std::cout << pl << " --> " << l
+                << " " << model->param.dot(id)
+                << std::endl;
     }
+  }
 }
 
-}       //  end for namespace segmentor
-}       //  end for namespace ltp
+}     //  end for namespace segmentor
+}     //  end for namespace ltp
diff --git a/src/segmentor/segmentor.h b/src/segmentor/segmentor.h
index a7145a4e4..954773f37 100644
--- a/src/segmentor/segmentor.h
+++ b/src/segmentor/segmentor.h
@@ -11,114 +11,135 @@ namespace segmentor {
 
 class Segmentor {
 public:
-    Segmentor();
-    Segmentor(ltp::utility::ConfigParser & cfg);
-    ~Segmentor();
+  Segmentor();
+  Segmentor(ltp::utility::ConfigParser & cfg);
+  ~Segmentor();
 
-    void run();
+  void run();
 
 private:
-    /*
-     * parse the configuration, return true on success, otherwise false
-     *
-     *  @param[in]  cfg     the config class
-     *  @return     bool    return true on success, otherwise false
-     */
-    bool parse_cfg(ltp::utility::ConfigParser & cfg);
-
-    /*
-     * read instances from file and store them in train_dat
-     *
-     *  @param[in]  file_name   the filename
-     *  @return     bool        true on success, otherwise false
-     */
-    bool read_instance( const char * file_name );
-    void build_configuration(void);
-    void build_feature_space(void);
-
-    /*
-     * the training process
-     */
-    void train(void);
-
-    /*
-     * the evaluating process
-     */
-    void evaluate(void);
-
-    /*
-     * the testing process
-     */
-    void test(void);
-
-    /*
-     * the dumping model process
-     */
-    void dump(void);
-
-    /*
-     * do feature trauncation on the model. create a model duplation
-     * on the model and return their
-     *
-     *  @return Model   the duplication of the model
-     */
-    Model * truncate(void);
+  /*
+   * parse the configuration, return true on success, otherwise false
+   *
+   *  @param[in]  cfg         the config class
+   *  @return     bool        return true on success, otherwise false
+   */
+  bool parse_cfg(ltp::utility::ConfigParser & cfg);
+
+  /*
+   * read instances from file and store them in train_dat
+   *
+   *  @param[in]  file_name   the filename
+   *  @return     bool        true on success, otherwise false
+   */
+  bool read_instance( const char * file_name );
+
+  /*
+   * build tag sets, collect internal word map, record word frequency.
+   */
+  void build_configuration(void);
+
+  /*
+   *
+   *
+   */
+  void build_feature_space(void);
+
+  /*
+   * the training process
+   */
+  void train(void);
+
+  /*
+   * the evaluating process
+   */
+  void evaluate(double &p, double &r, double &f);
+
+  /*
+   * the testing process
+   */
+  void test(void);
+
+  /*
+   * the dumping model process
+   */
+  void dump(void);
+
+  /*
+   * do feature selection by erasing the rare feature. create a new model
+   * without rare feature (only witness a few times) according the original
+   * model.
+   *
+   *  @param[in]  nr_updates  the number of update times
+   *  @return     Model       the model without rare feature
+   */
+  Model * erase_rare_features(const int * nr_updates = NULL);
 protected:
-    /*
-     * extract features from one instance,
-     *
-     */
-    void extract_features(Instance * inst, bool create = false);
-
-    /*
-     * build words from tags for certain instance
-     *
-     *  @param[in/out]  inst    the instance
-     *  @param[out]     words   the output words
-     *  @param[in]      tagsidx the index of tags
-     *  @param[in]      begtag0 first of the word begin tag
-     *  @param[in]      begtag1 second of the word begin tag
-     */
-    void build_words(Instance * inst, 
-            const std::vector<int> & tagsidx,
-            std::vector<std::string> & words,
-            int beg_tag0,
-            int beg_tag1 = -1);
-
-    /*
-     * cache all the score for the certain instance.
-     *
-     *  @param[in/out]  inst    the instance
-     *  @param[in]      use_avg use to specify use average parameter
-     */
-    void calculate_scores(Instance * inst, bool use_avg);
-
-    /*
-     * collect feature when given the tags index
-     *
-     *  @param[in]      inst    the instance
-     *  @param[in]      tagsidx the tags index
-     *  @param[out]     vec     the output sparse vector
-     */
-    void collect_features(Instance * inst, 
-            const std::vector<int> & tagsidx, 
-            ltp::math::SparseVec & vec);
-
+  /*
+   * extract features from one instance,
+   *
+   */
+  void extract_features(Instance * inst, bool create = false);
+
+  /*
+   * build words from tags for certain instance
+   *
+   *  @param[in/out]  inst      the instance
+   *  @param[in]      tagsidx   the index of tags
+   *  @param[out]     words     the output words
+   *  @param[in]      begtag0   first of the word begin tag
+   *  @param[in]      begtag1   second of the word begin tag
+   */
+  void build_words(Instance * inst,
+                   const std::vector<int> & tagsidx,
+                   std::vector<std::string> & words,
+                   int beg_tag0,
+                   int beg_tag1 = -1);
+
+  /*
+   * cache all the score for the certain instance.
+   *
+   *  @param[in/out]  inst      the instance
+   *  @param[in]      use_avg   use to specify use average parameter
+   */
+  void calculate_scores(Instance * inst, bool use_avg);
+
+  /*
+   * collect feature when given the tags index
+   *
+   *  @param[in]    inst    the instance
+   *  @param[in]    tagsidx the tags index
+   *  @param[out]   vec     the output sparse vector
+   */
+  void collect_features(Instance * inst,
+                        const std::vector<int> & tagsidx,
+                        ltp::math::SparseVec & vec);
+
+
+  /*
+   * decode the group information for feature represented in sparse vector,
+   * increase their updated time
+   *
+   *  @param[in]  vec           the feature vector
+   *  @param[out] updated_time  the updated time
+   */
+  void increase_group_updated_time(const ltp::math::SparseVec & vec,
+                                   int * feature_group_updated_time);
 private:
-    bool    __TRAIN__;
-    bool    __TEST__;
-    bool    __DUMP__;
+  bool  __TRAIN__;
+  bool  __TEST__;
+  bool  __DUMP__;
 
 private:
-    std::vector< Instance * > train_dat;
+  std::vector< Instance * > train_dat;
 
 protected:
-    Model * model;
-    Decoder * decoder;
-    rulebase::RuleBase* baseAll;
+  Model *              model;
+  Decoder *            decoder;
+  rulebase::RuleBase * baseAll;
 };
 
-}       //  end for namespace segmentor
-}       //  end for namespace ltp
+}     //  end for namespace segmentor
+}     //  end for namespace ltp
 
 #endif  //  end for __LTP_SEGMENTOR_SEGMENTOR_H__
diff --git a/src/segmentor/segmentreader.h b/src/segmentor/segmentreader.h
index 530c64de1..6e4f6ba51 100644
--- a/src/segmentor/segmentreader.h
+++ b/src/segmentor/segmentreader.h
@@ -15,107 +15,107 @@ using namespace ltp::strutils;
 
 class SegmentReader {
 public:
-    SegmentReader(istream & _ifs, bool _segmented = false, int _style = 4) : 
-        ifs(_ifs),
-        segmented(_segmented),
-        style(_style) {}
-
-    Instance * next() {
-        if (ifs.eof()) {
-            return 0;
-        }
+  SegmentReader(istream & _ifs, bool _segmented = false, int _style = 4) : 
+    ifs(_ifs),
+    segmented(_segmented),
+    style(_style) {}
+
+  Instance * next() {
+    if (ifs.eof()) {
+      return 0;
+    }
 
-        Instance * inst = new Instance;
-        std::string  line;
+    Instance * inst = new Instance;
+    std::string  line;
 
-        std::getline(ifs, line);
+    std::getline(ifs, line);
 
-        line = chomp(line);
-        if (line.size() == 0) {
-            delete inst;
-            return 0;
-        }
+    line = chomp(line);
+    if (line.size() == 0) {
+      delete inst;
+      return 0;
+    }
 
-        if (segmented) {
-            std::vector<std::string> words = split(line);
-            inst->words = words;
-
-            for (int i = 0; i < words.size(); ++ i) {
-                // std::vector<std::string> chars;
-                // int num_chars = codecs::decode(words[i], chars);
-                int num_chars = rulebase::preprocess(words[i],
-                        inst->raw_forms,
-                        inst->forms,
-                        inst->chartypes);
-
-                // support different style
-                if (style == 2) {
-                    for (int j = 0; j < num_chars; ++ j) {
-                        // inst->forms.push_back(chars[j]);
-                        if (j == 0) {
-                            inst->tags.push_back( __b__ );
-                        } else {
-                            inst->tags.push_back( __i__ );
-                        }
-                    }
-                } else if (style == 4) {
-                    for(int j = 0; j < num_chars; ++ j) {
-                        // inst->forms.push_back(chars[j]);
-                        if (1 == num_chars) {
-                            inst->tags.push_back( __s__ );
-                        } else {
-                            if (0 == j) {
-                                inst->tags.push_back( __b__ );
-                            } else if (num_chars - 1 == j) {
-                                inst->tags.push_back( __e__ );
-                            } else {
-                                inst->tags.push_back( __i__ );
-                            }
-                        }
-                    }
-                } else if (style == 6) {
-                    for (int j = 0; j < num_chars; ++ j) {
-                        // inst->forms.push_back(chars[j]);
-
-                        if (1 == num_chars) {
-                            inst->tags.push_back( __s__ );
-                        } else {
-                            if (0 == j) {
-                                inst->tags.push_back( __b__ );
-                            } else if (1 == j) {
-                                inst->tags.push_back( __b2__ );
-                            } else if (2 == j) {
-                                inst->tags.push_back( __b3__ );
-                            } else if (num_chars - 1 == j) {
-                                inst->tags.push_back( __e__ );
-                            } else {
-                                inst->tags.push_back( __i__ );
-                            }
-                        }
-                    }
-                }
+    if (segmented) {
+      std::vector<std::string> words = split(line);
+      inst->words = words;
+
+      for (int i = 0; i < words.size(); ++ i) {
+        // std::vector<std::string> chars;
+        // int num_chars = codecs::decode(words[i], chars);
+        int num_chars = rulebase::preprocess(words[i],
+            inst->raw_forms,
+            inst->forms,
+            inst->chartypes);
+
+        // support different style
+        if (style == 2) {
+          for (int j = 0; j < num_chars; ++ j) {
+            // inst->forms.push_back(chars[j]);
+            if (j == 0) {
+              inst->tags.push_back( __b__ );
+            } else {
+              inst->tags.push_back( __i__ );
             }
-        } else {
-            int ret = rulebase::preprocess(line,
-                    inst->raw_forms,
-                    inst->forms,
-                    inst->chartypes);
-
-            if (ret < 0) {
-                delete inst;
-                return 0;
+          }
+        } else if (style == 4) {
+          for(int j = 0; j < num_chars; ++ j) {
+            // inst->forms.push_back(chars[j]);
+            if (1 == num_chars) {
+              inst->tags.push_back( __s__ );
+            } else {
+              if (0 == j) {
+                inst->tags.push_back( __b__ );
+              } else if (num_chars - 1 == j) {
+                inst->tags.push_back( __e__ );
+              } else {
+                inst->tags.push_back( __i__ );
+              }
             }
+          }
+        } else if (style == 6) {
+          for (int j = 0; j < num_chars; ++ j) {
+            // inst->forms.push_back(chars[j]);
+
+            if (1 == num_chars) {
+              inst->tags.push_back( __s__ );
+            } else {
+              if (0 == j) {
+                inst->tags.push_back( __b__ );
+              } else if (1 == j) {
+                inst->tags.push_back( __b2__ );
+              } else if (2 == j) {
+                inst->tags.push_back( __b3__ );
+              } else if (num_chars - 1 == j) {
+                inst->tags.push_back( __e__ );
+              } else {
+                inst->tags.push_back( __i__ );
+              }
+            }
+          }
         }
-
-        return inst;
+      }
+    } else {
+      int ret = rulebase::preprocess(line,
+          inst->raw_forms,
+          inst->forms,
+          inst->chartypes);
+
+      if (ret < 0) {
+        delete inst;
+        return 0;
+      }
     }
+
+    return inst;
+  }
 private:
-    istream &   ifs;
-    int         style;
-    bool        segmented;
+  istream &   ifs;
+  int     style;
+  bool    segmented;
 };
 
-}           //  end for namespace segmentor
-}           //  end for namespace ltp
+}       //  end for namespace segmentor
+}       //  end for namespace ltp
 
-#endif      //  end for __LTP_SEGMENTOR_READER_H__
+#endif    //  end for __LTP_SEGMENTOR_READER_H__
diff --git a/src/segmentor/segmentwriter.h b/src/segmentor/segmentwriter.h
index 59a580bc0..4a5fd21c0 100644
--- a/src/segmentor/segmentwriter.h
+++ b/src/segmentor/segmentwriter.h
@@ -9,76 +9,76 @@ namespace segmentor {
 
 class SegmentWriter {
 public:
-    SegmentWriter(std::ostream & _ofs) : ofs(_ofs) {}
+  SegmentWriter(std::ostream & _ofs) : ofs(_ofs) {}
 
-    void write(const Instance * inst) {
-        int len = inst->predicted_words.size();
-        for (int i = 0; i < len; ++ i) {
-            ofs << inst->predicted_words[i];
-            if (i+1==len) ofs << std::endl;
-            else ofs << "\t";
-        }
+  void write(const Instance * inst) {
+    int len = inst->predicted_words.size();
+    for (int i = 0; i < len; ++ i) {
+      ofs << inst->predicted_words[i];
+      if (i+1==len) ofs << std::endl;
+      else ofs << "\t";
     }
+  }
 
-    void debug(const Instance * inst, bool show_feat = false) {
-        int len = inst->size();
-        ofs << "_instance_debug_" << std::endl;
-        ofs << "FORMS: ";
-        for (int i = 0; i < len; ++ i) {
-            ofs << inst->forms[i] << "|";
-        }
-        ofs << std::endl;
+  void debug(const Instance * inst, bool show_feat = false) {
+    int len = inst->size();
+    ofs << "_instance_debug_" << std::endl;
+    ofs << "FORMS: ";
+    for (int i = 0; i < len; ++ i) {
+      ofs << inst->forms[i] << "|";
+    }
+    ofs << std::endl;
 
-        ofs << "TAGS: ";
-        for (int i = 0; i < inst->tags.size(); ++ i) {
-            ofs << inst->tags[i] << "|";
-        }
-        ofs << std::endl;
+    ofs << "TAGS: ";
+    for (int i = 0; i < inst->tags.size(); ++ i) {
+      ofs << inst->tags[i] << "|";
+    }
+    ofs << std::endl;
 
-        ofs << "TAGS(index): ";
-        for (int i = 0; i < inst->tagsidx.size(); ++ i) {
-            ofs << inst->tagsidx[i] << "|";
-        }
-        ofs << std::endl;
+    ofs << "TAGS(index): ";
+    for (int i = 0; i < inst->tagsidx.size(); ++ i) {
+      ofs << inst->tagsidx[i] << "|";
+    }
+    ofs << std::endl;
 
-        ofs << "PREDICTED TAGS: ";
-        for (int i = 0; i < inst->predicted_tags.size(); ++ i) {
-            ofs << inst->predicted_tags[i] << "|";
-        }
-        ofs << std::endl;
+    ofs << "PREDICTED TAGS: ";
+    for (int i = 0; i < inst->predicted_tags.size(); ++ i) {
+      ofs << inst->predicted_tags[i] << "|";
+    }
+    ofs << std::endl;
 
-        ofs << "PREDICTED TAGS(index): ";
-        for (int i = 0; i < inst->predicted_tagsidx.size(); ++ i) {
-            ofs << inst->predicted_tagsidx[i] << "|";
-        }
-        ofs << std::endl;
+    ofs << "PREDICTED TAGS(index): ";
+    for (int i = 0; i < inst->predicted_tagsidx.size(); ++ i) {
+      ofs << inst->predicted_tagsidx[i] << "|";
+    }
+    ofs << std::endl;
 
-        ofs << "WORDS: ";
-        for (int i = 0; i < inst->words.size(); ++ i) {
-            ofs << inst->words[i] << "|";
-        }
-        ofs << std::endl;
+    ofs << "WORDS: ";
+    for (int i = 0; i < inst->words.size(); ++ i) {
+      ofs << inst->words[i] << "|";
+    }
+    ofs << std::endl;
 
-        ofs << "PREDICTED WORDS: ";
-        for (int i = 0; i < inst->predicted_words.size(); ++ i) {
-            ofs << inst->predicted_words[i] << "|";
-        }
-        ofs << std::endl;
+    ofs << "PREDICTED WORDS: ";
+    for (int i = 0; i < inst->predicted_words.size(); ++ i) {
+      ofs << inst->predicted_words[i] << "|";
+    }
+    ofs << std::endl;
 
-        if (show_feat) {
-            ofs << "GOLD FEATURES: ";
-            inst->features.str(ofs);
-            ofs << std::endl;
+    if (show_feat) {
+      ofs << "GOLD FEATURES: ";
+      inst->features.str(ofs);
+      ofs << std::endl;
 
-            ofs << "PREDICTED FEATURES: ";
-            inst->predicted_features.str(ofs);
-            ofs << std::endl;
-        }
+      ofs << "PREDICTED FEATURES: ";
+      inst->predicted_features.str(ofs);
+      ofs << std::endl;
     }
+  }
 private:
-    std::ostream & ofs;
+  std::ostream & ofs;
 };
 
-}           //  end for namespace segmentor
-}           //  end for namespace ltp
-#endif      //  end for __LTP_SEGMENTOR_WRITER_H__
+}       //  end for namespace segmentor
+}       //  end for namespace ltp
+#endif    //  end for __LTP_SEGMENTOR_WRITER_H__
diff --git a/src/server/ltp_server.cpp b/src/server/ltp_server.cpp
index a070470af..5d9d7c4a7 100644
--- a/src/server/ltp_server.cpp
+++ b/src/server/ltp_server.cpp
@@ -2,7 +2,7 @@
 //
 
 #include <sys/wait.h>
-#include <unistd.h>             /* For pause() */
+#include <unistd.h>       /* For pause() */
 #include <stdlib.h>
 #include <signal.h>
 
@@ -32,147 +32,154 @@ static int exit_flag;
 static int Service(struct mg_connection *conn);
 
 static void signal_handler(int sig_num) {
-    exit_flag = sig_num;
+  exit_flag = sig_num;
 }
 
 int main(int argc, char *argv[]) {
-    engine = new LTP;
+  engine = new LTP;
+
+  signal(SIGTERM, signal_handler);
+  signal(SIGINT, signal_handler);
+  struct mg_context *ctx;
+  const char *options[] = {"listening_ports", LISTENING_PORT,
+    "num_threads", "1", NULL};
+  struct mg_callbacks callbacks;
+
+  memset(&callbacks, 0, sizeof(callbacks));
+  callbacks.begin_request = Service;
+
+  if ((ctx = mg_start(&callbacks, NULL, options)) == NULL) {
+    ERROR_LOG("Cannot initialize Mongoose context");
+    exit(EXIT_FAILURE);
+  }
+
+  // getchar();
+  while (exit_flag == 0) {
+    sleep(100000);
+  }
+  mg_stop(ctx);
+
+  return 0;
+}
+
+static int Service(struct mg_connection *conn) {
+  char *sentence;
+  char type[10];
+  char xml[10];
 
-    signal(SIGTERM, signal_handler);
-    signal(SIGINT, signal_handler);
-    struct mg_context *ctx;
-    const char *options[] = {"listening_ports", LISTENING_PORT, 
-        "num_threads", "1", NULL};
-    struct mg_callbacks callbacks;
+  string str_post_data;
+  string str_type;
+  string str_xml;
 
-    memset(&callbacks, 0, sizeof(callbacks));
-    callbacks.begin_request = Service;
+  const struct mg_request_info *ri = mg_get_request_info(conn);
 
-    if ((ctx = mg_start(&callbacks, NULL, options)) == NULL) {
-        ERROR_LOG("Cannot initialize Mongoose context");
-        exit(EXIT_FAILURE);
+  if (!strcmp(ri->uri, "/ltp")) {
+    int len;
+    char buffer[POST_LEN];
+
+    while((len = mg_read(conn, buffer, sizeof(buffer) - 1)) > 0){
+      buffer[len] = 0;
+      str_post_data += buffer;
     }
 
-    // getchar();
-    while (exit_flag == 0) {
-        sleep(100000);
+    TRACE_LOG("CDATA: %s", str_post_data.c_str());
+    TRACE_LOG("CDATA length: %d", str_post_data.size());
+
+    sentence = new char[str_post_data.size() + 1];
+
+    mg_get_var(str_post_data.c_str(),
+               str_post_data.size(),
+               "s",
+               sentence,
+               str_post_data.size());
+
+    mg_get_var(str_post_data.c_str(),
+               str_post_data.size(),
+               "t",
+               type,
+               sizeof(type) - 1);
+
+    mg_get_var(str_post_data.c_str(),
+               str_post_data.size(),
+               "x",
+               xml,
+               sizeof(xml) - 1);
+
+    string strSentence = sentence;
+
+    // validation check
+    if (strlen(sentence) == 0) {
+      WARNING_LOG("Input sentence is empty");
+      std::string response = "HTTP/1.1 400 EMPTY SENTENCE\r\n\r\n";
+      mg_printf(conn, "%s", response.c_str());
+      return 0;
     }
-    mg_stop(ctx);
 
-    return 0;
-}
+    if (!isclear(strSentence)) {
+      WARNING_LOG("Failed string validation check");
+      // Input sentence is not clear
+      std::string response = "HTTP/1.1 400 ENCODING NOT IN UTF8\r\n\r\n";
+      mg_printf(conn, "%s", response.c_str());
+      return 0;
+    }
 
-static int Service(struct mg_connection *conn) {
-    char *sentence;
-    char type[10];
-    char xml[10];
-    char buffer[POST_LEN];
+    if(strlen(type) == 0) {
+      str_type = "";
+    } else {
+      str_type = type;
+    }
+
+    if(strlen(xml) == 0) {
+      str_xml = "";
+    } else {
+      str_xml = xml;
+    }
+
+    delete []sentence;
+
+    TRACE_LOG("Input sentence is: %s", strSentence.c_str());
 
-    string str_post_data;
-    string str_type;
-    string str_xml;
-
-    const struct mg_request_info *ri = mg_get_request_info(conn);
-
-    if (!strcmp(ri->uri, "/ltp")) {
-        int len;
-        while((len = mg_read(conn, buffer, sizeof(buffer) - 1)) > 0){
-            buffer[len] = 0;
-            str_post_data += buffer;
-        }
-
-        TRACE_LOG("CDATA: %s", str_post_data.c_str());
-        TRACE_LOG("CDATA length: %d", str_post_data.size());
-
-        sentence = new char[str_post_data.size() + 1];
-
-        mg_get_var(str_post_data.c_str(), 
-                str_post_data.size(), 
-                "s",
-                sentence,
-                str_post_data.size());
-
-        mg_get_var(str_post_data.c_str(), 
-                str_post_data.size(), 
-                "t",
-                type,
-                sizeof(type) - 1);
-
-        mg_get_var(str_post_data.c_str(), 
-                str_post_data.size(), 
-                "x",
-                xml,
-                sizeof(xml) - 1);
-
-        string strSentence = sentence;
-
-        /*
-         * validation check
-         */
-        if (strlen(sentence) == 0 || !isclear(strSentence)) {
-            // std::cerr << "Failed validation check" << std::endl;
-            WARNING_LOG("Failed string validation check");
-            return 0;
-        }
-
-        if(strlen(type) == 0) {
-            str_type = "";
-        } else {
-            str_type = type;
-        }
-
-        if(strlen(xml) == 0) {
-            str_xml = "";
-        } else {
-            str_xml = xml;
-        }
-
-        delete []sentence;
-
-        TRACE_LOG("Input sentence is: %s", strSentence.c_str());
-
-        //Get a XML4NLP instance here.
-        XML4NLP    xml4nlp;
-        
-        if(str_xml == "y"){
-            if (-1 == xml4nlp.LoadXMLFromString(strSentence)) {
-                // failed the xml validation check
-                return 0;
-            }
-
-            // move sentence validation check into each module
-        } else {
-            xml4nlp.CreateDOMFromString(strSentence);
-        }
-
-        TRACE_LOG("XML Creation is done.");
-
-        if(str_type == "ws"){
-            engine->wordseg(xml4nlp);
-        } else if(str_type == "pos"){
-            engine->postag(xml4nlp);
-        } else if(str_type == "ner"){
-            engine->ner(xml4nlp);
-        } else if(str_type == "dp"){
-            engine->parser(xml4nlp);
-        } else if(str_type == "srl"){
-            engine->srl(xml4nlp);
-        } else {
-            engine->srl(xml4nlp);
-        }
-
-        TRACE_LOG("Analysis is done.");
-
-        string strResult;
-        xml4nlp.SaveDOM(strResult);
-
-        strResult = "HTTP/1.1 200 OK\r\n\r\n" + strResult;
-
-        // cout << "Result is: " << strResult << endl;
-        mg_printf(conn, "%s", strResult.c_str());
-
-        xml4nlp.ClearDOM();
+    //Get a XML4NLP instance here.
+    XML4NLP  xml4nlp;
+
+    if(str_xml == "y") {
+      if (-1 == xml4nlp.LoadXMLFromString(strSentence)) {
+        // Failed the xml validation check
+        std::string response = "HTTP/1.1 400 BAD XML FORMAT\r\n\r\n";
+        response += "Failed to load custom xml";
+        mg_printf(conn, "%s", response.c_str());
+        return 0;
+      }
+
+      // move sentence validation check into each module
+    } else {
+      xml4nlp.CreateDOMFromString(strSentence);
     }
-    return 1;
+
+    TRACE_LOG("XML Creation is done.");
+
+    if(str_type == "ws"){
+      engine->wordseg(xml4nlp);
+    } else if(str_type == "pos"){
+      engine->postag(xml4nlp);
+    } else if(str_type == "ner"){
+      engine->ner(xml4nlp);
+    } else if(str_type == "dp"){
+      engine->parser(xml4nlp);
+    } else { // srl or all
+      engine->srl(xml4nlp);
+    }
+
+    TRACE_LOG("Analysis is done.");
+
+    string strResult;
+    xml4nlp.SaveDOM(strResult);
+
+    strResult = "HTTP/1.1 200 OK\r\n\r\n" + strResult;
+    mg_printf(conn, "%s", strResult.c_str());
+
+    xml4nlp.ClearDOM();
+  }
+  return 1;
 }
 
diff --git a/src/srl/DepSRL.cpp b/src/srl/DepSRL.cpp
index 37c288608..e6b96bc29 100644
--- a/src/srl/DepSRL.cpp
+++ b/src/srl/DepSRL.cpp
@@ -468,7 +468,7 @@ void DepSRL::GetParAndRel(const vector< pair<int, string> >& vecParser,
         pairParser = *itParser;
         vecParent.push_back(pairParser.first);
         vecRelation.push_back(pairParser.second);
-        itParser++;
+        ++ itParser;
     }
 }
 
@@ -486,8 +486,8 @@ void DepSRL::GetPredicateFromSentence(const vector<string>& vecPos,
             vecPredicate.push_back(index);
         }
 
-        index++;
-        itPos++;
+        ++ index;
+        ++ itPos;
     }
 }
 
@@ -763,7 +763,7 @@ bool DepSRL::IsMaxPropGreaterThreshold(
             return 1;
         }
 
-        itIndex++;
+        ++ itIndex;
     }
 
     return 0;
diff --git a/src/srl/FeatureExtractor.cpp b/src/srl/FeatureExtractor.cpp
index 83d2c05ea..067fc9134 100644
--- a/src/srl/FeatureExtractor.cpp
+++ b/src/srl/FeatureExtractor.cpp
@@ -446,7 +446,7 @@ void FeatureExtractor::calc_node_vs_predicate_features_(const vector<int>& node_
     nodes_queue.push(node_iter);
 
     // traverse
-    while (nodes_queue.size())
+    while (!nodes_queue.empty())
     {
         // fetch a node from the queue
         node_iter = nodes_queue.front();
diff --git a/src/srl/MyTree.cpp b/src/srl/MyTree.cpp
index 2dec72884..2aeb985d6 100644
--- a/src/srl/MyTree.cpp
+++ b/src/srl/MyTree.cpp
@@ -61,7 +61,7 @@ int MyTree::GetLeftChild(const int nodeID) const
             break;
         }
 
-        itChildren++;
+        ++ itChildren;
     }
 
     return leftChild;
@@ -89,7 +89,7 @@ int MyTree::GetRightChild(const int nodeID) const
             break;
         }
 
-        itChildren++;
+        ++ itChildren;
     }
 
     return rightChild;
@@ -125,7 +125,7 @@ int MyTree::GetLeftSib(const int nodeID) const
             break;
         }
 
-        itDequeChildren++;
+        ++ itDequeChildren;
     }
 
     return leftID;
@@ -157,7 +157,7 @@ int MyTree::GetRightSib(const int nodeID) const
             rightID = *itDequeChildren;
             break;
         }
-        itDequeChildren++;
+        ++ itDequeChildren;
     }
 
     return rightID;
@@ -247,7 +247,7 @@ void MyTree::GetAllNodePath(
     while(itDequeChildren != dequeChildren.end())
     {
         queDepNode.push(*itDequeChildren);
-        itDequeChildren++;
+        ++ itDequeChildren;
     }
 
     while(!queDepNode.empty())
@@ -275,7 +275,7 @@ void MyTree::GetAllNodePath(
         while(itDequeChildren != dequeChildren.end())
         {
             queDepNode.push(*itDequeChildren);
-            itDequeChildren++;
+            ++ itDequeChildren;
         }
     }
 }
@@ -454,9 +454,9 @@ void MyTree::InitTree(const LTPData* ltpData)
             m_rootID = index;
         }
 
-        itParent++;
-        itRelation++;
-        index++;
+        ++ itParent;
+        ++ itRelation;
+        ++ index;
     }
     m_depTree.nodeNum = index;
 
@@ -511,8 +511,8 @@ bool MyTree::UpdateTree()
                 }
             }
 
-            itDepNode++;
-            curIndex++; //next node
+            ++ itDepNode;
+            ++ curIndex; //next node
         } //interior while
 
         //for debug
diff --git a/src/srl/SRLBaseline.cpp b/src/srl/SRLBaseline.cpp
index 2aa7c3c67..05359f95d 100644
--- a/src/srl/SRLBaseline.cpp
+++ b/src/srl/SRLBaseline.cpp
@@ -10,11 +10,17 @@
 #include "SRLBaseline.h"
 
 SRLBaseline::SRLBaseline(string configXml, string selectFeats)
+  : m_dataPreProc(NULL),
+    m_featureExtractor(NULL),
+    m_featureCollection(NULL)
 {
 }
 
 SRLBaseline::~SRLBaseline()
 {
+  if (m_dataPreProc)       { delete m_dataPreProc; }
+  if (m_featureCollection) { delete m_featureCollection; }
+  if (m_featureExtractor)  { delete m_featureExtractor; }
 }
 
 // Check if the node will be filtered: only when the node 
diff --git a/src/srl/lgsrl.cpp b/src/srl/lgsrl.cpp
index 1ac006848..f72907af1 100644
--- a/src/srl/lgsrl.cpp
+++ b/src/srl/lgsrl.cpp
@@ -45,7 +45,7 @@ bool __TEST__      = false;
 
 void usage(void) {
     cerr << "srltrain - Training suite for semantic role labeling" << endl;
-    cerr << "Copyright (C) 2012-2013 HIT-SCIR" << endl;
+    cerr << "Copyright (C) 2012-2014 HIT-SCIR" << endl;
     cerr << endl;
     cerr << "usage: ./srltrain <config_file>" << endl;
     cerr << endl;
diff --git a/src/utils/math/sparsevec.h b/src/utils/math/sparsevec.h
index b28baaf09..04a1ade0e 100644
--- a/src/utils/math/sparsevec.h
+++ b/src/utils/math/sparsevec.h
@@ -18,135 +18,152 @@ namespace math {
 class SparseVec {
 public:
 #ifdef _WIN32
-    typedef stdext::hash_map<int,double> internal_sparsevec_t;
+  typedef stdext::hash_map<int,double> internal_sparsevec_t;
 #else
-    typedef std::tr1::unordered_map<int, double> internal_sparsevec_t;
-    // typedef __gnu_cxx::hash_map<int, double> internal_sparsevec_t;
+  typedef std::tr1::unordered_map<int, double> internal_sparsevec_t;
+  // typedef __gnu_cxx::hash_map<int, double> internal_sparsevec_t;
 #endif  //  end for _WIN32
-    typedef internal_sparsevec_t::iterator       iterator;
-    typedef internal_sparsevec_t::const_iterator const_iterator;
-
-    SparseVec() {}
-    ~SparseVec() {}
-
-    const_iterator begin() const {
-        return _vec.begin();
-    }
-
-    const_iterator end() const {
-        return _vec.end();
-    }
-
-    iterator mbegin() {
-        return _vec.begin();
+  typedef internal_sparsevec_t::iterator     iterator;
+  typedef internal_sparsevec_t::const_iterator const_iterator;
+
+  SparseVec() {}
+  ~SparseVec() {}
+
+  const_iterator begin() const {
+    return _vec.begin();
+  }
+
+  const_iterator end() const {
+    return _vec.end();
+  }
+
+  iterator mbegin() {
+    return _vec.begin();
+  }
+
+  iterator mend() {
+    return _vec.end();
+  }
+
+  inline int dim() const {
+    return _vec.size();
+  }
+
+  inline double L2() {
+    double norm = 0;
+    for (const_iterator itx = _vec.begin();
+        itx != _vec.end(); ++ itx) {
+      double val = itx->second;
+      norm += (val * val);
     }
-
-    iterator mend() {
-        return _vec.end();
-    }
-
-    inline int dim() const {
-        return _vec.size();
+    return norm;
+  }
+
+  inline void add(int idx,
+                  double scale) {
+    if (_vec.find(idx) == _vec.end()) _vec[idx] = 0.;
+    _vec[idx] += scale;
+  }
+
+  inline void add(const SparseVec &other,
+                  const double scale) {
+    for (const_iterator itx = other.begin();
+        itx != other.end(); ++ itx) {
+      int idx = itx->first;
+      if (_vec.find(idx) == _vec.end()) _vec[idx] = 0.;
+      _vec[idx] += (scale * itx->second);
     }
-
-    inline double L2() {
-        double norm = 0;
-        for (const_iterator itx = _vec.begin();
-                itx != _vec.end(); ++ itx) {
-            double val = itx->second;
-            norm += (val * val);
+  }
+
+  void update_counter(int * updates,
+                      int offset,
+                      int num_labels) {
+
+    int tmp = offset*num_labels;
+    for (const_iterator itx = this->begin();
+        itx != this->end(); ++ itx) {
+      int idx = itx->first;
+      if(idx < tmp) {//this means unfeatrues
+        if(itx->second!=0.0){
+          //std::cout<<"idx:"<<idx<<" value:"<<itx->second<<" +1"<<std::endl;
+          updates[idx/num_labels]++;
         }
-        return norm;
+      }
     }
-
-    inline void add(int idx,
-            double scale) {
-        if (_vec.find(idx) == _vec.end()) _vec[idx] = 0.;
-        _vec[idx] += scale;
+  }
+
+  inline void add(const int * idx,
+      const double * val,
+      const int n,
+      const double scale) {
+    if (!idx) {
+      return;
     }
-
-    inline void add(const SparseVec &other,
-            const double scale) {
-        for (const_iterator itx = other.begin();
-                itx != other.end(); ++ itx) {
-            int idx = itx->first;
-            if (_vec.find(idx) == _vec.end()) _vec[idx] = 0.;
-            _vec[idx] += (scale * itx->second);
-        }
+    // int n = other->n;
+    // const int * idx = other->idx;
+    // const double * val = other->val;
+
+    if (val == NULL) {
+      for (int i = 0; i < n; ++ i) {
+        if (_vec.find(idx[i]) == _vec.end()) _vec[idx[i]] = 0.;
+        _vec[idx[i]] += scale;
+      }
+    } else {
+      for (int i = 0; i < n; ++ i) {
+        _vec[idx[i]] += (scale * val[i]);
+      }
     }
-
-    inline void add(const int * idx,
-            const double * val,
-            const int n,
-            const double scale) {
-        if (!idx) {
-            return;
-        }
-        // int n = other->n;
-        // const int * idx = other->idx;
-        // const double * val = other->val;
-
-        if (val == NULL) {
-            for (int i = 0; i < n; ++ i) {
-                if (_vec.find(idx[i]) == _vec.end()) _vec[idx[i]] = 0.;
-                _vec[idx[i]] += scale;
-            }
-        } else {
-            for (int i = 0; i < n; ++ i) {
-                _vec[idx[i]] += (scale * val[i]);
-            }
-        }
+  }
+
+  inline void add(const int * idx, 
+      const double * val,
+      const int n, 
+      const int loff,
+      const double scale) {
+    if (!idx) {
+      return ;
     }
 
-    inline void add(const int * idx, 
-            const double * val,
-            const int n, 
-            const int loff,
-            const double scale) {
-        if (!idx) {
-            return ;
-        }
-
-        if (val == NULL) {
-            for (int i = 0; i < n; ++ i) {
-                int id = idx[i] + loff;
-                if (_vec.find(id) == _vec.end()) _vec[id] = 0.;
-                _vec[id] += scale;
-            }
-        } else {
-            for (int i = 0; i < n; ++ i) {
-                int id = idx[i] + loff;
-                if (_vec.find(id) == _vec.end()) _vec[id] = 0.;
-                _vec[id] += (scale * val[i]);
-            }
-        }
-    }
-
-    inline void zero() {
-        _vec.clear();
+    if (val == NULL) {
+      for (int i = 0; i < n; ++ i) {
+        int id = idx[i] + loff;
+        if (_vec.find(id) == _vec.end()) _vec[id] = 0.;
+        _vec[id] += scale;
+      }
+    } else {
+      for (int i = 0; i < n; ++ i) {
+        int id = idx[i] + loff;
+        if (_vec.find(id) == _vec.end()) _vec[id] = 0.;
+        _vec[id] += (scale * val[i]);
+      }
     }
-
-    inline void str(std::ostream & out, std::string prefix = "  ") const {
-        int i = 0;
-        out << "{ ";
-        for (const_iterator itx = _vec.begin();
-                itx != _vec.end();
-                ++ itx) {
-            out << itx->first << ":" << itx->second << ", ";
-            ++ i;
-
-            if (i % 10 == 0) {
-				out << "\n" << prefix;
-            }
-        }
-        out << "}" << std::endl;
+  }
+
+  inline void zero() {
+    _vec.clear();
+  }
+
+  inline void str(std::ostream & out, std::string prefix = "  ") const {
+    int i = 0;
+    out << "{ ";
+    for (const_iterator itx = _vec.begin();
+        itx != _vec.end();
+        ++ itx) {
+      out << itx->first << ":" << itx->second << ", ";
+      ++ i;
+
+      if (i % 10 == 0) {
+        out << "\n" << prefix;
+      }
     }
+    out << "}" << std::endl;
+  }
 private:
-    internal_sparsevec_t _vec;
-    double norm;
+  internal_sparsevec_t _vec;
+  double norm;
 };
 
-}       //  end for namespace math
-}       //  end for namespace ltp
+}     //  end for namespace math
+}     //  end for namespace ltp
 
 #endif  //  end for __SPARSE_VECTOR_H__
diff --git a/src/utils/strutils.hpp b/src/utils/strutils.hpp
index 8bfe33c12..c4bee041a 100644
--- a/src/utils/strutils.hpp
+++ b/src/utils/strutils.hpp
@@ -471,6 +471,21 @@ inline std::string to_str(int x) {
     return std::string(buff, sprintf(buff, "%d", x));
 }
 
+// remove the leading space and ending \r\n\t
+inline void clean(std::string &str) {
+  std::string blank = " \t\r\n";
+
+  size_t pos1 = str.find_first_not_of(blank);
+  size_t pos2 = str.find_last_not_of(blank);
+
+  if (pos1 == std::string::npos) {
+    str = "";
+  } else {
+    str = str.substr(pos1, pos2 - pos1 + 1);
+  }
+}
+
+
 /*
  *
  *
diff --git a/tools/train/conf/cws/cws.cnf b/tools/train/conf/cws/cws.cnf
index f60df446e..d68502568 100644
--- a/tools/train/conf/cws/cws.cnf
+++ b/tools/train/conf/cws/cws.cnf
@@ -1,6 +1,7 @@
 [train]
 train-file = sample/seg/example-train.seg
 holdout-file = sample/seg/example-holdout.seg
-algorithm = pa 
+algorithm = pa
 model-name = build/cws/example-seg
 max-iter = 1
+rare-feature-threshold = 0
diff --git a/tools/train/conf/parser/parser-o1.cnf b/tools/train/conf/parser/parser-o1.cnf
index 7335e7f7e..5458fe2f7 100644
--- a/tools/train/conf/parser/parser-o1.cnf
+++ b/tools/train/conf/parser/parser-o1.cnf
@@ -20,3 +20,4 @@ holdout-file = sample/parser/example-holdout.conll
 max-iter = 1 
 algorithm = pa
 model-name = build/parser/example-parser-o1
+rare-feature-threshold = 0
diff --git a/tools/train/conf/parser/parser-o2carreras.cnf b/tools/train/conf/parser/parser-o2carreras.cnf
index 99e0c8a4b..94e61e180 100644
--- a/tools/train/conf/parser/parser-o2carreras.cnf
+++ b/tools/train/conf/parser/parser-o2carreras.cnf
@@ -23,3 +23,4 @@ holdout-file = sample/parser/example-holdout.conll
 max-iter = 1 
 algorithm = pa
 model-name = build/parser/example-parser-o2carreras
+rare-feature-threshold = 0
diff --git a/tools/train/conf/parser/parser-o2sib.cnf b/tools/train/conf/parser/parser-o2sib.cnf
index 503868c72..1c9910567 100644
--- a/tools/train/conf/parser/parser-o2sib.cnf
+++ b/tools/train/conf/parser/parser-o2sib.cnf
@@ -20,3 +20,4 @@ holdout-file = sample/parser/example-holdout.conll
 max-iter = 1 
 algorithm = pa
 model-name = build/parser/example-parser-o2sib
+rare-feature-threshold = 0
diff --git a/tools/train/conf/pos/pos.cnf b/tools/train/conf/pos/pos.cnf
index 1c21af0be..5c4a4dbd5 100644
--- a/tools/train/conf/pos/pos.cnf
+++ b/tools/train/conf/pos/pos.cnf
@@ -4,3 +4,4 @@ holdout-file = sample/pos/example-holdout.pos
 algorithm = pa
 model-name = build/pos/example-pos
 max-iter = 2
+rare-feature-threshold = 0