diff --git a/Makefile b/Makefile
index 85bc0b3..f3718b5 100644
--- a/Makefile
+++ b/Makefile
@@ -78,6 +78,7 @@ ELC_SRCS := \
 	c.c \
 	cl.c \
 	cpp.c \
+	cpp_template.c \
 	cr.c \
 	cs.c \
 	el.c \
@@ -311,6 +312,14 @@ TOOL := g++-6
 include target.mk
 $(OUT.eir.cpp.out): tools/runcpp.sh
 
+ifdef CPP_TEMPLATE
+TARGET := cpp_template
+RUNNER := tools/runcpp_template.sh
+TOOL := g++
+include target.mk
+$(OUT.eir.cpp_template.out): tools/runcpp_template.sh
+endif
+
 ifeq ($(uname),Linux)
 TARGET := $(ARCH)
 RUNNER :=
diff --git a/README.md b/README.md
index 3c48c24..d4ff6b1 100644
--- a/README.md
+++ b/README.md
@@ -19,7 +19,8 @@ Currently, there are 31 backends:
 * Befunge
 * Brainfuck
 * C
-* C++14 (compile-time) (by [@kw-udon](https://github.com/kw-udon/))
+* C++14 constexpr (compile-time) (by [@kw-udon](https://github.com/kw-udon/))
+* C++ Template Metaprogramming (compile-time) (by [@kw-udon](https://github.com/kw-udon/)) (WIP)
 * C# (by [@masaedw](https://github.com/masaedw/))
 * C-INTERCAL
 * CommonLisp (by [@youz](https://github.com/youz/))
@@ -214,7 +215,7 @@ You can find more descriptions and released vim script in
 This backend was contributed by [@hak7a3](https://github.com/hak7a3/). See
 also [8cc.tex](https://github.com/hak7a3/8cc.tex).
 
-### C++14 (compile-time)
+### C++14 constexpr (compile-time)
 
 This backend was contributed by [@kw-udon](https://github.com/kw-udon/). You can find more
 descriptions in
diff --git a/target/cpp_template.c b/target/cpp_template.c
new file mode 100644
index 0000000..4cf9324
--- /dev/null
+++ b/target/cpp_template.c
@@ -0,0 +1,243 @@
+#include <ir/ir.h>
+#include <target/util.h>
+#include <target/cpp_template_lib.h>
+
+static void cpp_template_emit_file_prologue(void) {
+  emit_line("#include <cstdio>");
+  emit_line("");
+  emit_line(cpp_template_lib);
+  emit_line("");
+  emit_line("typedef enum { a, b, c, d, bp, sp } Reg_Name;");
+}
+
+static const char* cpp_template_op_str(Inst* inst) {
+  const char * op_str;
+  const char * src_str = inst->src.type == REG ? "reg" : "imm";
+  switch (inst->op) {
+  case MOV:
+    op_str = "mov"; break;
+  case ADD:
+    op_str = "add"; break;
+  case SUB:
+    op_str = "sub"; break;
+  case LOAD:
+    op_str = "load"; break;
+  case STORE:
+    op_str = "store"; break;
+  case PUTC:
+    op_str = "putc"; break;
+  case EQ:
+  case NE:
+  case LT:
+  case GT:
+  case LE:
+  case GE:
+    op_str = "cmp"; break;
+  case JEQ:
+  case JNE:
+  case JLT:
+  case JGT:
+  case JLE:
+  case JGE:
+    op_str = "jcmp"; break;
+  default:
+    error("oops");
+  }
+  return format("%s_%s", op_str, src_str);
+}
+
+
+int reg_id = 0;
+int mem_id = 0;
+int buf_id = 0;
+int exit_flag = 0;
+
+static void cpp_template_emit_inst(Inst* inst) {
+  switch (inst->op) {
+  case MOV:
+  case ADD:
+  case SUB:
+    emit_line("typedef %s<r%d, %s, %s> r%d;",
+              cpp_template_op_str(inst),
+              reg_id, reg_names[inst->dst.reg], src_str(inst), reg_id + 1);
+    reg_id++;
+    break;
+
+  case LOAD:
+    emit_line("typedef %s<r%d, m%d, %s, %s> r%d;",
+              cpp_template_op_str(inst),
+              reg_id, mem_id, reg_names[inst->dst.reg], src_str(inst), reg_id + 1);
+    reg_id++;
+    break;
+
+  case STORE:
+    emit_line("typedef %s<r%d, m%d, %s, %s> m%d;",
+              cpp_template_op_str(inst),
+              reg_id, mem_id, reg_names[inst->dst.reg], src_str(inst), mem_id + 1);
+    mem_id++;
+    break;
+
+  case PUTC:
+    emit_line("typedef %s<r%d, b%d,%s> b%d;",
+              cpp_template_op_str(inst),
+              reg_id, buf_id, src_str(inst), buf_id + 1);
+    buf_id++;
+    break;
+
+  case GETC:
+    emit_line("typedef getc_reg<r%d, %s> r%d;",
+              reg_id, reg_names[inst->dst.reg], reg_id + 1);
+    reg_id++;
+    break;
+
+  case EXIT:
+    emit_line("typedef exit_inst<r%d> r%d;",
+              reg_id, reg_id + 1);
+    exit_flag = 1;
+    reg_id++;
+    return;
+
+  case DUMP:
+    break;
+
+  case EQ:
+  case NE:
+  case LT:
+  case GT:
+  case LE:
+  case GE:
+    emit_line("typedef %s<r%d, %s, %s, %d> r%d;",
+              cpp_template_op_str(inst),
+              reg_id,
+              reg_names[inst->dst.reg],
+              src_str(inst),
+              inst->op - EQ,
+              reg_id + 1);
+    reg_id++;
+    break;
+
+  case JEQ:
+  case JNE:
+  case JLT:
+  case JGT:
+  case JLE:
+  case JGE:
+    emit_line("typedef %s<r%d, %s - 1, %s, %s, %d> r%d;",
+              cpp_template_op_str(inst),
+              reg_id,
+              value_str(&inst->jmp),
+              reg_names[inst->dst.reg],
+              src_str(inst),
+              inst->op - JEQ,
+              reg_id + 1);
+    reg_id++;
+    break;
+
+  case JMP:
+    emit_line("typedef jmp_%s<r%d, %s> r%d;",
+              inst->jmp.type == REG ? "reg" : "imm",
+              reg_id, value_str(&inst->jmp), reg_id + 1);
+    reg_id++;
+    break;
+
+  default:
+    error("oops");
+  }
+  return;
+}
+
+static void cpp_template_emit_pc_change(int pc) {
+  emit_line("typedef inc_pc<r%d, m%d, b%d> result;", reg_id, mem_id, buf_id);
+  dec_indent();
+  emit_line("};");
+  emit_line("");
+  emit_line("template <typename r0, typename m0, typename b0>");
+  emit_line("struct func_switch_impl<r0, m0, b0, %d> {", pc);
+  inc_indent();
+}
+
+static void cpp_template_emit_func_epilogue() {
+  emit_line("typedef inc_pc<r%d, m%d, b%d> result;", reg_id, mem_id, buf_id);
+  dec_indent();
+  emit_line("};");
+  emit_line("");
+  emit_line("template <typename env, int pc>");
+  emit_line("struct func_switch : func_switch_impl<"
+            "typename env::regs, typename env::mem, "
+            "typename env::buf, pc>::result {};");
+}
+
+void cpp_template_emit_func_switch_impl(Inst* inst) {
+  int prev_pc = 0;
+  emit_line("template <typename r0, typename m0, typename b0, int pc>");
+  emit_line("struct func_switch_impl { typedef inc_pc<r0, m0, b0> result; };");
+  emit_line("");
+  emit_line("template <typename r0, typename m0, typename b0>");
+  emit_line("struct func_switch_impl<r0, m0, b0, 0> {");
+  inc_indent();
+  for (; inst; inst = inst->next) {
+    if (prev_pc != inst->pc) {
+      cpp_template_emit_pc_change(inst->pc);
+      reg_id = 0;
+      mem_id = 0;
+      buf_id = 0;
+      exit_flag = 0;
+    }
+    prev_pc = inst->pc;
+
+    cpp_template_emit_inst(inst);
+  }
+  cpp_template_emit_func_epilogue();
+}
+
+static void cpp_template_emit_main_loop(void) {
+  emit_line("template <typename env, bool, int>");
+  emit_line("struct main_loop { typedef env result; };");
+  emit_line("template <typename env, int pc>");
+  emit_line("struct main_loop<env, false, pc> {");
+  inc_indent();
+  emit_line("typedef func_switch<env, pc> env2;");
+  emit_line("typedef typename main_loop<env2, env2::regs::exit_flag, env2::regs::pc>::result result;");
+  dec_indent();
+  emit_line("};");
+}
+
+static void cpp_template_emit_calc_main(Data* data) {
+  emit_line("struct calc_main {");
+  inc_indent();
+  emit_line("typedef init_memory<MEM_SIZE> mem0;");
+  int mp;
+  for (mp = 0; data; data = data->next, mp++) {
+    if (data->v) {
+      emit_line("typedef store_value<mem%d, %d, %d> mem%d;", mp, mp, data->v, mp + 1);
+    } else {
+      emit_line("typedef mem%d mem%d;", mp, mp + 1);
+    }
+  }
+  emit_line("typedef init_regs<0> regs;");
+  emit_line(" typedef make_env<regs, mem%d, Nil> env;", mp);
+  emit_line("typedef main_loop<env, false, 0>::result result;");
+  dec_indent();
+  emit_line("};");
+}
+
+void target_cpp_template(Module* module) {
+  cpp_template_emit_file_prologue();
+  emit_line("");
+
+  cpp_template_emit_func_switch_impl(module->text);
+  emit_line("");
+
+  cpp_template_emit_main_loop();
+  emit_line("");
+
+  cpp_template_emit_calc_main(module->data);
+  emit_line("");
+
+  emit_line("int main() {");
+  inc_indent();
+  emit_line("typedef calc_main::result result;");
+  emit_line("print_buffer<result::buf>::run();");
+  dec_indent();
+  emit_line("}");
+}
diff --git a/target/cpp_template_lib.h b/target/cpp_template_lib.h
new file mode 100644
index 0000000..d9fa81f
--- /dev/null
+++ b/target/cpp_template_lib.h
@@ -0,0 +1,326 @@
+/*
+  Library for C++ Template Metaprogramming backend
+
+  Original Version:
+  https://gist.github.com/kw-udon/6248197ec8fdc681b63e4cb8271fac56
+*/
+
+static char cpp_template_lib[] =
+  "// Library for ELVM's C++ Template Metaprogramming backend\n"
+ "\n"
+  "// Input Buffer\n"
+  "constexpr static const char* input =\n"
+  "#   include \"input.txt\"\n"
+  ";\n"
+  "\n"
+  "// Memory Size\n"
+  "const int MEM_SIZE = 1 << 16;\n"
+  "\n"
+  "// Data Structures\n"
+  "\n"
+  "template <int n>  struct Int {static const int  val = n;};\n"
+  "template <bool b> struct Bool{static const bool val = b;};\n"
+  "\n"
+  "// List\n"
+  "struct Nil { typedef Nil head; typedef Nil tail; };\n"
+  "template <typename Head, typename Tail/*=Nil*/>\n"
+  "struct Pair { typedef Head head; typedef Tail tail; };\n"
+  "\n"
+  "template<typename l>\n"
+  "struct is_nil : Bool<false> {};\n"
+  "template<>\n"
+  "struct is_nil<Nil> : Bool<true> {};\n"
+  "\n"
+  "template <typename head, typename tail>\n"
+  "struct cons : Pair<head, tail> {};\n"
+  "\n"
+  "template <typename list, int n>\n"
+  "struct get_at : get_at<typename list::tail, n-1> {};\n"
+  "template <typename list>\n"
+  "struct get_at<list, 0> : list::head {};\n"
+  "\n"
+  "template <typename list, int n, int v>\n"
+  "struct set_at : cons<typename list::head, set_at<typename list::tail, n - 1, v>> {};\n"
+  "template <typename list, int v>\n"
+  "struct set_at<list, 0, v> : cons<Int<v>, typename list::tail> {};\n"
+  "\n"
+  "template <int n>\n"
+  "struct init_list_aux {\n"
+  "  typedef typename init_list_aux<n-1>::result tail;\n"
+  "  typedef cons<Int<0>, tail> result;\n"
+  "};\n"
+  "template <>\n"
+  "struct init_list_aux<0> {\n"
+  "  typedef Nil result;\n"
+  "};\n"
+  "template <int n>\n"
+  "struct init_list : init_list_aux<n>::result {};\n"
+  "\n"
+  "//  Binary Tree (for Memory)\n"
+  "template <typename node_v, typename lnode, typename rnode>\n"
+  "struct Node {\n"
+  "  typedef node_v value;\n"
+  "  typedef lnode left;\n"
+  "  typedef rnode right;\n"
+  "  static const bool is_leaf = is_nil<lnode>::val && is_nil<rnode>::val;\n"
+  "};\n"
+  "template <typename v>\n"
+  "struct Leaf : Node<v, Nil, Nil> {};\n"
+  "\n"
+  "template <int depth>\n"
+  "struct mk_tree {\n"
+  "  typedef Int<depth> value;\n"
+  "  typedef mk_tree<depth-1> left;\n"
+  "  typedef mk_tree<depth-1> right;\n"
+  "};\n"
+  "template <>\n"
+  "struct mk_tree<0> : Leaf<Int<0>> {};\n"
+  "\n"
+  "template <typename tree, int flg>\n"
+  "struct get_child : tree::left {};\n"
+  "template <typename tree>\n"
+  "struct get_child<tree, 1> : tree::right {};\n"
+  "template <typename tree, typename child, int flg>\n"
+  "struct update_child : tree { typedef child left; };\n"
+  "template <typename tree, typename child>\n"
+  "struct update_child<tree, child, 1> : tree {typedef child right;};\n"
+  "\n"
+  "\n"
+  "// Memory\n"
+  "\n"
+  "constexpr int const_log2(int x) {\n"
+  "  return x < 2 ? x : 1 + const_log2(x >> 1);\n"
+  "}\n"
+  "template <int mem_size>\n"
+  "struct init_memory {\n"
+  "  static const int depth = const_log2(mem_size); // memory size == 2^d\n"
+  "  typedef mk_tree<depth> tree;\n"
+  "};\n"
+  "\n"
+  "// Memory Access\n"
+  "// Load\n"
+  "template <typename tree, int depth, int idx>\n"
+  "struct load_value_aux {\n"
+  "  static const int flg = (idx >> (depth-1)) & 1;\n"
+  "  typedef get_child<tree, flg> child;\n"
+  "  typedef typename load_value_aux<child, depth-1, idx>::result result;\n"
+  "};\n"
+  "\n"
+  "template <typename tree, int idx>\n"
+  "struct load_value_aux<tree, 0, idx> {\n"
+  "  typedef typename tree::value result;\n"
+  "};\n"
+  "\n"
+  "template <typename memory, int idx>\n"
+  "struct load_value : load_value_aux<typename memory::tree, memory::depth, idx & (MEM_SIZE - 1)>::result {};\n"
+  "\n"
+  "// Store\n"
+  "template <typename tree, int depth, int idx, int new_v>\n"
+  "struct store_value_aux {\n"
+  "  static const int flg = (idx >> (depth-1)) & 1;\n"
+  "  typedef get_child<tree, flg> child;\n"
+  "  typedef typename store_value_aux<child, depth-1, idx, new_v>::result new_child;\n"
+  "  typedef update_child<tree, new_child, flg> result;\n"
+  "};\n"
+  "template <typename tree, int idx, int new_v>\n"
+  "struct store_value_aux<tree, 0, idx, new_v> {\n"
+  "  typedef Leaf<Int<new_v>> result;\n"
+  "};\n"
+  "\n"
+  "template <typename memory, int idx, int new_v>\n"
+  "struct store_value : memory {\n"
+  "  typedef typename store_value_aux<typename memory::tree, memory::depth, idx & (MEM_SIZE - 1), new_v>::result tree;\n"
+  "};\n"
+  "\n"
+  "// Registers\n"
+  "template <int PC>\n"
+  "struct init_regs {\n"
+  "  static const int a = 0;\n"
+  "  static const int b = 0;\n"
+  "  static const int c = 0;\n"
+  "  static const int d = 0;\n"
+  "  static const int sp = 0;\n"
+  "  static const int bp = 0;\n"
+  "  static const int pc = PC;\n"
+  "  static const bool exit_flag = false;\n"
+  "  static const int input_cur = 0;\n"
+  "};\n"
+  "\n"
+  "template <typename regs, int src_reg>\n"
+  "struct reg_val {};\n"
+  "template <typename regs>\n"
+  "struct reg_val<regs, 0> { static const int val = regs::a;};\n"
+  "template <typename regs>\n"
+  "struct reg_val<regs, 1> { static const int val = regs::b;};\n"
+  "template <typename regs>\n"
+  "struct reg_val<regs, 2> { static const int val = regs::c;};\n"
+  "template <typename regs>\n"
+  "struct reg_val<regs, 3> { static const int val = regs::d;};\n"
+  "template <typename regs>\n"
+  "struct reg_val<regs, 4> { static const int val = regs::sp;};\n"
+  "template <typename regs>\n"
+  "struct reg_val<regs, 5> { static const int val = regs::bp;};\n"
+  "\n"
+  "\n"
+  "// Environment (Tuple of Registers, Memory and Buffer)\n"
+  "template <typename Regs, typename Mem, typename Buf>\n"
+  "struct make_env {\n"
+  "  typedef Regs regs;\n"
+  "  typedef Mem mem;\n"
+  "  typedef Buf buf;\n"
+  "};\n"
+  "\n"
+  "template <typename regs, int PC>\n"
+  "struct update_pc : regs {static const int pc = PC;};\n"
+  "template <typename regs>\n"
+  "struct inc_input_cur : regs {static const int input_cur = regs::input_cur + (input[regs::input_cur] ? 1 : 0);};\n"
+  "template <typename regs, typename mem, typename buf>\n"
+  "struct inc_pc : make_env<update_pc<regs, 1 + regs::pc>, mem, buf> {};\n"
+  "\n"
+  "\n"
+  "// Functions for Each Instruction\n"
+  "\n"
+  "// MOV\n"
+  "template <typename r, int dst_reg, int imm>\n"
+  "struct mov_imm_aux : r {};\n"
+  "template <typename r, int imm>\n"
+  "struct mov_imm_aux<r, 0, imm> : r {static const int a = imm;};\n"
+  "template <typename r, int imm>\n"
+  "struct mov_imm_aux<r, 1, imm> : r {static const int b = imm;};\n"
+  "template <typename r, int imm>\n"
+  "struct mov_imm_aux<r, 2, imm> : r {static const int c = imm;};\n"
+  "template <typename r, int imm>\n"
+  "struct mov_imm_aux<r, 3, imm> : r {static const int d = imm;};\n"
+  "template <typename r, int imm>\n"
+  "struct mov_imm_aux<r, 4, imm> : r {static const int sp = imm;};\n"
+  "template <typename r, int imm>\n"
+  "struct mov_imm_aux<r, 5, imm> : r {static const int bp = imm;};\n"
+  "\n"
+  "template <typename regs, int dst_reg, int imm>\n"
+  "struct mov_imm : mov_imm_aux<regs, dst_reg, imm> {};\n"
+  "template <typename regs, int dst_reg, int src_reg>\n"
+  "struct mov_reg : mov_imm_aux<regs, dst_reg, reg_val<regs, src_reg>::val> {};\n"
+  "\n"
+  "// ADD, SUB\n"
+  "template <typename regs, int dst_reg, int imm>\n"
+  "struct add_aux {\n"
+  "  static const int dst_val = reg_val<regs, dst_reg>::val;\n"
+  "  typedef mov_imm<regs, dst_reg, (dst_val + imm) & (MEM_SIZE - 1)> result;\n"
+  "};\n"
+  "template <typename regs, int dst_reg, int imm>\n"
+  "struct add_imm : add_aux<regs, dst_reg, imm>::result {};\n"
+  "template <typename regs, int dst_reg, int src_reg>\n"
+  "struct add_reg : add_aux<regs, dst_reg, reg_val<regs, src_reg>::val>::result {};\n"
+  "template <typename regs, int dst_reg, int imm>\n"
+  "struct sub_imm : add_aux<regs, dst_reg, -imm>::result {};\n"
+  "template <typename regs, int dst_reg, int src_reg>\n"
+  "struct sub_reg : add_aux<regs, dst_reg, -reg_val<regs, src_reg>::val>::result {};\n"
+  "\n"
+  "// LOAD\n"
+  "template <typename mem, int addr>\n"
+  "struct load_aux : load_value<mem, addr> {};\n"
+  "\n"
+  "template <typename regs, typename mem, int dst_reg, int addr>\n"
+  "struct load_imm : mov_imm<regs, dst_reg, load_aux<mem, addr>::val> {};\n"
+  "template <typename regs, typename mem, int dst_reg, int src_reg>\n"
+  "struct load_reg : load_imm<regs, mem, dst_reg, reg_val<regs, src_reg>::val> {};\n"
+  "\n"
+  "// STORE\n"
+  "template <typename regs, typename mem, int src_reg, int addr>\n"
+  "struct store_aux {\n"
+  "  typedef reg_val<regs, src_reg> data;\n"
+  "  typedef store_value<mem, addr, data::val> result;\n"
+  "};\n"
+  "\n"
+  "template <typename regs, typename mem, int src_reg, int addr>\n"
+  "struct store_imm : store_aux<regs, mem, src_reg, addr>::result {};\n"
+  "template <typename regs, typename mem, int src_reg, int dst_reg>\n"
+  "struct store_reg : store_imm<regs, mem, src_reg, reg_val<regs, dst_reg>::val> {};\n"
+  "\n"
+  "// PUTC\n"
+  "template <typename regs, typename buffer, int imm>\n"
+  "struct putc_aux {\n"
+  "  typedef cons<Int<imm>, buffer> result;\n"
+  "};\n"
+  "template <typename regs, typename buffer, int imm>\n"
+  "struct putc_imm : putc_aux<regs, buffer, imm>::result {};\n"
+  "template <typename regs, typename buffer, int src_reg>\n"
+  "struct putc_reg : putc_imm<regs, buffer, reg_val<regs, src_reg>::val> {};\n"
+  "\n"
+  "// GETC\n"
+  "template <typename regs, int dst_reg>\n"
+  "struct getc_aux {\n"
+  "  static const int read_val = input[regs::input_cur];\n"
+  "  typedef inc_input_cur<regs> regs2;\n"
+  "  typedef mov_imm<regs2, dst_reg, read_val & (MEM_SIZE - 1)> result;\n"
+  "};\n"
+  "template <typename regs, int dst_reg>\n"
+  "struct getc_reg : getc_aux<regs, dst_reg>::result {};\n"
+  "\n"
+  "\n"
+  "// EXIT\n"
+  "template <typename regs>\n"
+  "struct exit_inst : regs {\n"
+  "  static const int pc = 1000000;\n"
+  "  static const bool exit_flag = true;\n"
+  "};\n"
+  "\n"
+  "// JMP\n"
+  "template <typename regs, int label, int cmp_flg>\n"
+  "struct jmp_aux : update_pc<regs, label>{};\n"
+  "template <typename regs, int label>\n"
+  "struct jmp_aux<regs, label, 0> : regs {};\n"
+  "\n"
+  "template <typename regs, int imm>\n"
+  "struct jmp_imm : jmp_aux<regs, imm - 1, 1> {};\n"
+  "template <typename regs, int reg>\n"
+  "struct jmp_reg : jmp_aux<regs, reg_val<regs, reg>::val - 1, 1> {};\n"
+  "\n"
+  "// CMP\n"
+  "template <typename regs, int reg0, int imm>\n"
+  "struct eq_imm {\n"
+  "  static const int reg_v = reg_val<regs, reg0>::val;\n"
+  "  static const bool result = (reg_v == imm);\n"
+  "};\n"
+  "\n"
+  "template <typename regs, int reg, int imm, int op>\n"
+  "struct cmp_op_imm {\n"
+  "  static const int v = reg_val<regs, reg>::val;\n"
+  "  static const int result =\n"
+  "    op == 0 ? (v == imm) :\n"
+  "    op == 1 ? (v != imm) :\n"
+  "    op == 2 ? (v <  imm) :\n"
+  "    op == 3 ? (v >  imm) :\n"
+  "    op == 4 ? (v <= imm) :\n"
+  "    op == 5 ? (v >= imm) :\n"
+  "    1;\n"
+  "};\n"
+  "\n"
+  "template <typename regs, int reg1, int reg2, int op>\n"
+  "struct cmp_op_reg : cmp_op_imm<regs, reg1, reg_val<regs, reg2>::val, op> {};\n"
+  "\n"
+  "template <typename regs, int dst_reg, int imm, int op>\n"
+  "struct cmp_imm : mov_imm<regs, dst_reg, cmp_op_imm<regs, dst_reg, imm, op>::result> {};\n"
+  "template <typename regs, int dst_reg, int src_reg, int op>\n"
+  "struct cmp_reg : mov_imm<regs, dst_reg, cmp_op_reg<regs, dst_reg, src_reg, op>::result> {};\n"
+  "\n"
+  "// JCMP\n"
+  "template <typename regs, int label, int src_reg, int imm, int op>\n"
+  "struct jcmp_imm : jmp_aux<regs, label, cmp_op_imm<regs, src_reg, imm, op>::result> {};\n"
+  "template <typename regs, int label, int src_reg1, int src_reg2, int op>\n"
+  "struct jcmp_reg : jmp_aux<regs, label, cmp_op_reg<regs, src_reg1, src_reg2, op>::result> {};\n"
+  "\n"
+  "// print_buffer\n"
+  "template <typename list>\n"
+  "struct print_buffer_aux {\n"
+  "  static inline void run () {\n"
+  "    print_buffer_aux<typename list::tail>::run();\n"
+  "    putchar(list::head::val);\n"
+  "  }\n"
+  "};\n"
+  "template <>\n"
+  "struct print_buffer_aux<Nil> { static inline void run () {}};\n"
+  "template <typename list>\n"
+  "struct print_buffer : print_buffer_aux<list> {};\n"
+  "\n"
+  "// Library ends here\n";
diff --git a/target/elc.c b/target/elc.c
index e3713f8..d0f3f9f 100644
--- a/target/elc.c
+++ b/target/elc.c
@@ -11,6 +11,7 @@ void target_bf(Module* module);
 void target_c(Module* module);
 void target_cl(Module* module);
 void target_cpp(Module* module);
+void target_cpp_template(Module* module);
 void target_cr(Module* module);
 void target_cs(Module* module);
 void target_el(Module* module);
@@ -51,6 +52,7 @@ static target_func_t get_target_func(const char* ext) {
   if (!strcmp(ext, "c")) return target_c;
   if (!strcmp(ext, "cl")) return target_cl;
   if (!strcmp(ext, "cpp")) return target_cpp;
+  if (!strcmp(ext, "cpp_template")) return target_cpp_template;
   if (!strcmp(ext, "cr")) return target_cr;
   if (!strcmp(ext, "cs")) return target_cs;
   if (!strcmp(ext, "el")) return target_el;
diff --git a/tools/runcpp_template.sh b/tools/runcpp_template.sh
new file mode 100755
index 0000000..5a5fdb8
--- /dev/null
+++ b/tools/runcpp_template.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+
+set -e
+
+dir=$(mktemp -d)
+mkdir -p $dir
+cp $1 $dir/$(basename $1).cpp
+infile=${dir}/input.txt
+
+cat > $infile
+
+if [ ! -s $infile ]; then
+    echo '""' > $infile
+else
+  sed -i '1s/^/R"(/' $infile
+  echo ')"' >> $infile
+fi
+
+g++ -std=c++11 ${dir}/$(basename $1).cpp -o $1.exe -ftemplate-depth=2147483647
+rm -fr $dir
+./$1.exe