rm whitespace

60 files changed, 19471 insertions, 19471 deletions

diff --git a/src/array.c b/src/array.c
index 5ffa03821..249ae8d8c 100644
--- a/src/array.c
+++ b/src/array.c
@@ -1,6 +1,6 @@
 /*
 ** array.c - Array class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/cdump.c b/src/cdump.c
index 47c89300c..7029ae3de 100644
--- a/src/cdump.c
+++ b/src/cdump.c
@@ -1,6 +1,6 @@
 /*
 ** cdump.c - mruby binary dumper (C source format)
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -124,7 +124,7 @@ make_cdump_irep(mrb_state *mrb, int irep_no, FILE *f)
     SOURCE_CODE    ("  irep->syms = mrb_malloc(mrb, sizeof(mrb_sym)*%d);",            irep->slen);
     for (n=0; n<irep->slen; n++)
       if (irep->syms[n]) {
-	SOURCE_CODE  ("  irep->syms[%d] = mrb_intern(mrb, \"%s\");",                  n, mrb_sym2name(mrb, irep->syms[n]));
+        SOURCE_CODE  ("  irep->syms[%d] = mrb_intern(mrb, \"%s\");",                  n, mrb_sym2name(mrb, irep->syms[n]));
       }
   }
   else
diff --git a/src/class.c b/src/class.c
index 879502364..366bde96d 100644
--- a/src/class.c
+++ b/src/class.c
@@ -1,6 +1,6 @@
 /*
 ** class.c - Class class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -49,7 +49,7 @@ mrb_gc_mark_mt(mrb_state *mrb, struct RClass *c)
     if (kh_exist(h, k)){
       struct RProc *m = kh_value(h, k);
       if (m) {
-	paint_black(m);
+        paint_black(m);
       }
     }
   }
@@ -94,7 +94,7 @@ class_sym(mrb_state *mrb, struct RClass *c, struct RClass *outer)
       if (!kh_exist(h,k)) continue;
       v = kh_value(h,k);
       if (mrb_type(v) == c->tt && mrb_class_ptr(v) == c) {
-	return kh_key(h,k);
+        return kh_key(h,k);
       }
     }
   }
@@ -183,7 +183,7 @@ mrb_define_class_id(mrb_state *mrb, mrb_sym name, struct RClass *super)
   struct RClass *c = mrb_class_new(mrb, super);
 
   mrb_obj_iv_set(mrb, (struct RObject*)mrb->object_class,
-		 name, mrb_obj_value(c));
+                 name, mrb_obj_value(c));
   mrb_name_class(mrb, c, name);
 
   return c;
@@ -258,7 +258,7 @@ mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, s
   }
   if (!super) {
     mrb_warn("no super class for `%s::%s', Object assumed",
-	     mrb_obj_classname(mrb, mrb_obj_value(outer)), mrb_sym2name(mrb, id));
+             mrb_obj_classname(mrb, mrb_obj_value(outer)), mrb_sym2name(mrb, id));
   }
   c = mrb_class_new(mrb, super);
   setup_class(mrb, mrb_obj_value(outer), c, id);
@@ -366,17 +366,17 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         mrb_float *p;
 
         p = va_arg(ap, mrb_float*);
-	switch (sp->tt) {
-	case MRB_TT_FLOAT:
-	  *p = (argc > i) ? mrb_float(*sp) : 0;
-	  break;
-	case MRB_TT_FIXNUM:
-	  *p = (argc > i) ? (mrb_float)mrb_fixnum(*sp) : 0;
-	  break;
-	default:
-	  // error
-	  break;
-	}
+        switch (sp->tt) {
+        case MRB_TT_FLOAT:
+          *p = (argc > i) ? mrb_float(*sp) : 0;
+          break;
+        case MRB_TT_FIXNUM:
+          *p = (argc > i) ? (mrb_float)mrb_fixnum(*sp) : 0;
+          break;
+        default:
+          // error
+          break;
+        }
         i++; sp++;
       }
       break;
@@ -386,17 +386,17 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         size_t *pl;
         struct RString *s;
 
-	if (argc > i) {
-	  s = mrb_str_ptr(*sp);
-	  ps = va_arg(ap, char**);
-	  *ps = s->buf;
-	  pl = va_arg(ap, size_t*);
-	  *pl = s->len;
-	}
-	else {
-	  *ps = "";
-	  *pl = 0;
-	}
+        if (argc > i) {
+          s = mrb_str_ptr(*sp);
+          ps = va_arg(ap, char**);
+          *ps = s->buf;
+          pl = va_arg(ap, size_t*);
+          *pl = s->len;
+        }
+        else {
+          *ps = "";
+          *pl = 0;
+        }
         i++; sp++;
       }
       break;
@@ -421,25 +421,25 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
     case 'b':
       {
         struct RProc **p;
-	mrb_value *bp = mrb->stack + 1;
+        mrb_value *bp = mrb->stack + 1;
 
         p = va_arg(ap, struct RProc**);
-	if (mrb->ci->argc > 0) {
-	  bp += mrb->ci->argc;
-	}
-	if (mrb_nil_p(*bp)) *p = 0;
-	else *p = mrb_proc_ptr(*bp);
+        if (mrb->ci->argc > 0) {
+          bp += mrb->ci->argc;
+        }
+        if (mrb_nil_p(*bp)) *p = 0;
+        else *p = mrb_proc_ptr(*bp);
       }
       break;
     case '&':
       {
-	mrb_value *p, *bp = mrb->stack + 1;
+        mrb_value *p, *bp = mrb->stack + 1;
 
         p = va_arg(ap, mrb_value*);
-	if (mrb->ci->argc > 0) {
-	  bp += mrb->ci->argc;
-	}
-	*p = *bp;
+        if (mrb->ci->argc > 0) {
+          bp += mrb->ci->argc;
+        }
+        *p = *bp;
       }
       break;
     case '*':
@@ -447,20 +447,20 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         mrb_value **var;
         var = va_arg(ap, mrb_value**);
         argcp = va_arg(ap, int*);
-	if (argc > i) {
-	  *argcp = argc-i;
-	  if (*argcp > 0) {
-	    if (var) {
-	      *var = sp;
-	    }
-	    i += *argcp;
-	  }
-	}
-	else {
-	  *argcp = 0;
-	  *var = NULL;
-	}
-	goto last_var;
+        if (argc > i) {
+          *argcp = argc-i;
+          if (*argcp > 0) {
+            if (var) {
+              *var = sp;
+            }
+            i += *argcp;
+          }
+        }
+        else {
+          *argcp = 0;
+          *var = NULL;
+        }
+        goto last_var;
       }
       break;
     }
@@ -535,7 +535,7 @@ mrb_singleton_class(mrb_state *mrb, mrb_value v)
   case MRB_TT_FLOAT:
     return mrb_nil_value();    /* should raise TypeError */
   default:
-    break; 
+    break;
   }
   obj = (struct RBasic*)mrb_object(v);
   obj->c = mrb_singleton_class_ptr(mrb, obj->c);
@@ -561,10 +561,10 @@ mrb_method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid)
     if (h) {
       k = kh_get(mt, h, mid);
       if (k != kh_end(h)) {
-	m = kh_value(h, k);
-	if (!m) break;
-	*cp = c;
-	return m;
+        m = kh_value(h, k);
+        if (!m) break;
+        *cp = c;
+        return m;
       }
     }
     c = c->super;
@@ -748,7 +748,7 @@ mrb_obj_respond_to(struct RClass* c, mrb_sym mid)
     if (h) {
       k = kh_get(mt, h, mid);
       if (k != kh_end(h))
-	return 1; /* exist method */
+        return 1; /* exist method */
     }
     c = c->super;
   }
@@ -884,7 +884,7 @@ void
 mrb_alias_method(mrb_state *mrb, struct RClass *c, mrb_sym a, mrb_sym b)
 {
   struct RProc *m = mrb_method_search(mrb, c, b);
-  
+
   mrb_define_method_vm(mrb, c, a, mrb_obj_value(m));
 }
 
@@ -938,7 +938,7 @@ mrb_mod_to_s(mrb_state *mrb, mrb_value klass)
     if (!cn) {
       char buf[256];
 
-      
+
       switch (mrb_type(klass)) {
         case MRB_TT_CLASS:
           snprintf(buf, 256, "#<Class:%p>", c);
@@ -1011,10 +1011,10 @@ mrb_mod_eqq(mrb_state *mrb, mrb_value mod)
 void
 mrb_init_class(mrb_state *mrb)
 {
-  struct RClass *bob;		/* BasicObject */
-  struct RClass *obj;		/* Object */
-  struct RClass *mod;		/* Module */
-  struct RClass *cls;		/* Class */
+  struct RClass *bob;           /* BasicObject */
+  struct RClass *obj;           /* Object */
+  struct RClass *mod;           /* Module */
+  struct RClass *cls;           /* Class */
   //struct RClass *krn;    /* Kernel */
 
   /* boot class hierarchy */
diff --git a/src/codegen.c b/src/codegen.c
index 5eca94ad0..b0f5abc1a 100644
--- a/src/codegen.c
+++ b/src/codegen.c
@@ -1,6 +1,6 @@
 /*
 ** codegen.c - mruby code generator
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -97,7 +97,7 @@ codegen_palloc(codegen_scope *s, size_t len)
   if (!p) codegen_error(s, "pool memory allocation");
   return p;
 }
-  
+
 void*
 codegen_malloc(codegen_scope *s, size_t len)
 {
@@ -147,27 +147,27 @@ genop_peep(codegen_scope *s, mrb_code i, int val)
     case OP_MOVE:
       switch (c0) {
       case OP_MOVE:
-	if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i) == GETARG_B(i0) && GETARG_A(i) >= s->nlocals) {
-	  // skip swapping OP_MOVE
-	  return;
-	}
-	break;
+        if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i) == GETARG_B(i0) && GETARG_A(i) >= s->nlocals) {
+          // skip swapping OP_MOVE
+          return;
+        }
+        break;
       case OP_LOADI:
-	if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {
-	  s->iseq[s->pc-1] = MKOP_AsBx(OP_LOADI, GETARG_A(i), GETARG_sBx(i0));
-	  return;
-	}
-	break;
+        if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {
+          s->iseq[s->pc-1] = MKOP_AsBx(OP_LOADI, GETARG_A(i), GETARG_sBx(i0));
+          return;
+        }
+        break;
       case OP_ARRAY:
       case OP_HASH:
       case OP_RANGE:
       case OP_AREF:
       case OP_GETUPVAR:
-	if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {
-	  s->iseq[s->pc-1] = MKOP_ABC(c0, GETARG_A(i), GETARG_B(i0), GETARG_C(i0));
-	  return;
-	}
-	break;
+        if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {
+          s->iseq[s->pc-1] = MKOP_ABC(c0, GETARG_A(i), GETARG_B(i0), GETARG_C(i0));
+          return;
+        }
+        break;
       case OP_LOADSYM:
       case OP_GETGLOBAL:
       case OP_GETIV:
@@ -177,27 +177,27 @@ genop_peep(codegen_scope *s, mrb_code i, int val)
       case OP_LOADL:
       case OP_STRING:
       case OP_GETMCNST:
-	if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {
-	  s->iseq[s->pc-1] = MKOP_ABx(c0, GETARG_A(i), GETARG_Bx(i0));
-	  return;
-	}
-	break;
+        if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {
+          s->iseq[s->pc-1] = MKOP_ABx(c0, GETARG_A(i), GETARG_Bx(i0));
+          return;
+        }
+        break;
       case OP_SCLASS:
-	if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {
-	  s->iseq[s->pc-1] = MKOP_AB(c0, GETARG_A(i), GETARG_B(i0));
-	  return;
-	}
-	break;
+        if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {
+          s->iseq[s->pc-1] = MKOP_AB(c0, GETARG_A(i), GETARG_B(i0));
+          return;
+        }
+        break;
       case OP_LOADNIL:
       case OP_LOADSELF:
       case OP_LOADT:
       case OP_LOADF:
       case OP_OCLASS:
-	if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {
-	  s->iseq[s->pc-1] = MKOP_A(c0, GETARG_A(i));
-	  return;
-	}
-	break;
+        if (GETARG_B(i) == GETARG_A(i0) && GETARG_A(i0) >= s->nlocals) {
+          s->iseq[s->pc-1] = MKOP_A(c0, GETARG_A(i));
+          return;
+        }
+        break;
       }
       break;
     case OP_SETIV:
@@ -206,33 +206,33 @@ genop_peep(codegen_scope *s, mrb_code i, int val)
     case OP_SETMCNST:
       switch (c0) {
       case OP_MOVE:
-	if (GETARG_A(i) == GETARG_A(i0)) {
-	  s->iseq[s->pc-1] = MKOP_ABx(c1, GETARG_B(i0), GETARG_Bx(i));
-	  return;
-	}
-	break;
+        if (GETARG_A(i) == GETARG_A(i0)) {
+          s->iseq[s->pc-1] = MKOP_ABx(c1, GETARG_B(i0), GETARG_Bx(i));
+          return;
+        }
+        break;
       }
       break;
     case OP_SETUPVAR:
       switch (c0) {
       case OP_MOVE:
-	if (GETARG_A(i) == GETARG_A(i0)) {
-	  s->iseq[s->pc-1] = MKOP_ABC(c1, GETARG_B(i0), GETARG_B(i), GETARG_C(i));
-	  return;
-	}
-	break;
+        if (GETARG_A(i) == GETARG_A(i0)) {
+          s->iseq[s->pc-1] = MKOP_ABC(c1, GETARG_B(i0), GETARG_B(i), GETARG_C(i));
+          return;
+        }
+        break;
       }
       break;
     case OP_EPOP:
       if (c0 == OP_EPOP) {
-	s->iseq[s->pc-1] = MKOP_A(OP_EPOP, GETARG_A(i0)+GETARG_A(i));
-	return;
+        s->iseq[s->pc-1] = MKOP_A(OP_EPOP, GETARG_A(i0)+GETARG_A(i));
+        return;
       }
       break;
     case OP_POPERR:
       if (c0 == OP_POPERR) {
-	s->iseq[s->pc-1] = MKOP_A(OP_POPERR, GETARG_A(i0)+GETARG_A(i));
-	return;
+        s->iseq[s->pc-1] = MKOP_A(OP_POPERR, GETARG_A(i0)+GETARG_A(i));
+        return;
       }
       break;
     }
@@ -575,16 +575,16 @@ gen_values(codegen_scope *s, node *t)
       genop(s, MKOP_AB(OP_ARYCAT, cursp(), cursp()+1));
       t = t->cdr;
       while (t) {
-	push();
-	codegen(s, t->car, VAL);
-	pop(); pop();
-	if ((intptr_t)t->car->car == NODE_SPLAT) {
-	  genop(s, MKOP_AB(OP_ARYCAT, cursp(), cursp()+1));
-	}
-	else {
-	  genop(s, MKOP_AB(OP_ARYPUSH, cursp(), cursp()+1));
-	}
-	t = t->cdr;
+        push();
+        codegen(s, t->car, VAL);
+        pop(); pop();
+        if ((intptr_t)t->car->car == NODE_SPLAT) {
+          genop(s, MKOP_AB(OP_ARYCAT, cursp(), cursp()+1));
+        }
+        else {
+          genop(s, MKOP_AB(OP_ARYPUSH, cursp(), cursp()+1));
+        }
+        t = t->cdr;
       }
       return -1;
     }
@@ -683,22 +683,22 @@ gen_assignment(codegen_scope *s, node *node, int sp, int val)
     idx = lv_idx(s, (mrb_sym)node);
     if (idx > 0) {
       if (idx != sp) {
-	genop_peep(s, MKOP_AB(OP_MOVE, idx, sp), val);
+        genop_peep(s, MKOP_AB(OP_MOVE, idx, sp), val);
       }
       break;
     }
-    else {			/* upvar */
+    else {                      /* upvar */
       int lv = 0;
       codegen_scope *up = s->prev;
 
       while (up) {
-	idx = lv_idx(up, (mrb_sym)node);
-	if (idx > 0) {
-	  genop_peep(s, MKOP_ABC(OP_SETUPVAR, sp, idx, lv), val);
-	  break;
-	}
-	lv++;
-	up = up->prev;
+        idx = lv_idx(up, (mrb_sym)node);
+        if (idx > 0) {
+          genop_peep(s, MKOP_ABC(OP_SETUPVAR, sp, idx, lv), val);
+          break;
+        }
+        lv++;
+        up = up->prev;
       }
       //      assert(up!=0);
     }
@@ -727,7 +727,7 @@ gen_assignment(codegen_scope *s, node *node, int sp, int val)
   case NODE_CALL:
     push();
     gen_call(s, node, attrsym(s, (mrb_sym)node->cdr->car), sp, val);
-    val = NOVAL;		/* push should have done in gen_call() */
+    val = NOVAL;                /* push should have done in gen_call() */
     break;
 
   default:
@@ -743,7 +743,7 @@ gen_vmassignment(codegen_scope *s, node *tree, int rhs, int val)
   int n = 0, post = 0;
   node *t, *p;
 
-  if (tree->car) {		/* pre */
+  if (tree->car) {              /* pre */
     t = tree->car;
     n = 0;
     while (t) {
@@ -755,11 +755,11 @@ gen_vmassignment(codegen_scope *s, node *tree, int rhs, int val)
   }
   t = tree->cdr;
   if (t) {
-    if (t->cdr) {		/* post count */
+    if (t->cdr) {               /* post count */
       p = t->cdr->car;
       while (p) {
-	post++;
-	p = p->cdr;
+        post++;
+        p = p->cdr;
       }
     }
     if (val) {
@@ -769,15 +769,15 @@ gen_vmassignment(codegen_scope *s, node *tree, int rhs, int val)
     pop();
     genop(s, MKOP_ABC(OP_APOST, cursp(), n, post));
     n = 1;
-    if (t->car) {		/* rest */
+    if (t->car) {               /* rest */
       gen_assignment(s, t->car, cursp(), NOVAL);
     }
     if (t->cdr && t->cdr->car) {
       t = t->cdr->car;
       while (t) {
-	gen_assignment(s, t->car, cursp()+n, NOVAL);
-	t = t->cdr;
-	n++;
+        gen_assignment(s, t->car, cursp()+n, NOVAL);
+        t = t->cdr;
+        n++;
       }
     }
   }
@@ -817,7 +817,7 @@ codegen(codegen_scope *s, node *tree, int val)
       lp = loop_push(s, LOOP_BEGIN);
       lp->pc1 = onerr;
       if (tree->car) {
-	codegen(s, tree->car, val);
+        codegen(s, tree->car, val);
       }
       lp->type = LOOP_RESCUE;
       noexc = new_label(s);
@@ -827,58 +827,58 @@ codegen(codegen_scope *s, node *tree, int val)
       exend = 0;
       pos1 = 0;
       if (tree->car) {
-	node *n2 = tree->car;
-	int exc = cursp();
-
-	genop(s, MKOP_A(OP_RESCUE, exc));
-	push();
-	while (n2) {
-	  node *n3 = n2->car;
-
-	  if (pos1) dispatch(s, pos1);
-	  if (n3->car) {
-	    node *n4 = n3->car;
-
-	    pos2 = 0;
-	    while (n4) {
-	      codegen(s, n4->car, VAL);
-	      genop(s, MKOP_AB(OP_MOVE, cursp(), exc));
-	      push();
-	      genop(s, MKOP_A(OP_LOADNIL, cursp()));
-	      pop(); pop();
-	      genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern(s->mrb, "===")), 1));
-	      tmp = new_label(s);
-	      genop(s, MKOP_AsBx(OP_JMPIF, cursp(), pos2));
-	      pos2 = tmp;
-	      n4 = n4->cdr;
-	    }
-	    pos1 = new_label(s);
-	    genop(s, MKOP_Bx(OP_JMP, 0));
-	    dispatch_linked(s, pos2);
-	  }
-	  pop();
-	  if (n3->cdr->car) {
-	    gen_assignment(s, n3->cdr->car, exc, NOVAL);
-	  }
-	  if (n3->cdr->cdr->car) {
-	    codegen(s, n3->cdr->cdr->car, val);
-	  }
-	  tmp = new_label(s);
-	  genop(s, MKOP_AsBx(OP_JMP, cursp(), exend));
-	  exend = tmp;
-	  n2 = n2->cdr;
-	  push();
-	}
-	if (pos1) {
-	  dispatch(s, pos1);
-	  genop(s, MKOP_A(OP_RAISE, exc));
-	}
+        node *n2 = tree->car;
+        int exc = cursp();
+
+        genop(s, MKOP_A(OP_RESCUE, exc));
+        push();
+        while (n2) {
+          node *n3 = n2->car;
+
+          if (pos1) dispatch(s, pos1);
+          if (n3->car) {
+            node *n4 = n3->car;
+
+            pos2 = 0;
+            while (n4) {
+              codegen(s, n4->car, VAL);
+              genop(s, MKOP_AB(OP_MOVE, cursp(), exc));
+              push();
+              genop(s, MKOP_A(OP_LOADNIL, cursp()));
+              pop(); pop();
+              genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern(s->mrb, "===")), 1));
+              tmp = new_label(s);
+              genop(s, MKOP_AsBx(OP_JMPIF, cursp(), pos2));
+              pos2 = tmp;
+              n4 = n4->cdr;
+            }
+            pos1 = new_label(s);
+            genop(s, MKOP_Bx(OP_JMP, 0));
+            dispatch_linked(s, pos2);
+          }
+          pop();
+          if (n3->cdr->car) {
+            gen_assignment(s, n3->cdr->car, exc, NOVAL);
+          }
+          if (n3->cdr->cdr->car) {
+            codegen(s, n3->cdr->cdr->car, val);
+          }
+          tmp = new_label(s);
+          genop(s, MKOP_AsBx(OP_JMP, cursp(), exend));
+          exend = tmp;
+          n2 = n2->cdr;
+          push();
+        }
+        if (pos1) {
+          dispatch(s, pos1);
+          genop(s, MKOP_A(OP_RAISE, exc));
+        }
       }
       tree = tree->cdr;
       dispatch(s, noexc);
       genop(s, MKOP_A(OP_POPERR, 1));
       if (tree->car) {
-	codegen(s, tree->car, val);
+        codegen(s, tree->car, val);
       }
       dispatch_linked(s, exend);
       loop_pop(s, NOVAL);
@@ -922,7 +922,7 @@ codegen(codegen_scope *s, node *tree, int val)
     {
       int pos1, pos2;
       node *e = tree->cdr->cdr->car;
-      
+
       codegen(s, tree->car, VAL);
       pop();
       pos1 = new_label(s);
@@ -930,20 +930,20 @@ codegen(codegen_scope *s, node *tree, int val)
 
       codegen(s, tree->cdr->car, val);
       if (e) {
-	if (val) pop();
-	pos2 = new_label(s);
-	genop(s, MKOP_sBx(OP_JMP, 0));
-	dispatch(s, pos1);
-	codegen(s, e, val);
-	dispatch(s, pos2);
+        if (val) pop();
+        pos2 = new_label(s);
+        genop(s, MKOP_sBx(OP_JMP, 0));
+        dispatch(s, pos1);
+        codegen(s, e, val);
+        dispatch(s, pos2);
       }
       else {
-	if (val) {
-	  pop();
-	  genop(s, MKOP_A(OP_LOADNIL, cursp()));
-	  push();
-	}
-	dispatch(s, pos1);
+        if (val) {
+          pop();
+          genop(s, MKOP_A(OP_LOADNIL, cursp()));
+          push();
+        }
+        dispatch(s, pos1);
       }
     }
     break;
@@ -1019,40 +1019,40 @@ codegen(codegen_scope *s, node *tree, int val)
 
       pos3 = 0;
       if (tree->car) {
-	head = cursp();
-	codegen(s, tree->car, VAL);
+        head = cursp();
+        codegen(s, tree->car, VAL);
       }
       tree = tree->cdr;
       while (tree) {
-	n = tree->car->car;
-	pos1 = pos2 = 0;
-	while (n) {
-	  codegen(s, n->car, VAL);
-	  if (head) {
-	    genop(s, MKOP_AB(OP_MOVE, cursp(), head));
-	    push();
-	    genop(s, MKOP_A(OP_LOADNIL, cursp()));
-	    pop(); pop();
-	    genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern(s->mrb, "===")), 1));
-	  }
-	  tmp = new_label(s);
-	  genop(s, MKOP_AsBx(OP_JMPIF, cursp(), pos2));
-	  pos2 = tmp;
-	  n = n->cdr;
-	}
-	if (tree->car->car) {
-	  pos1 = new_label(s);
-	  genop(s, MKOP_AsBx(OP_JMP, cursp(), 0));
-	  dispatch_linked(s, pos2);
-	}
-	pop(); pop();
-	codegen(s, tree->car->cdr, val);
-	tmp = new_label(s);
-	genop(s, MKOP_AsBx(OP_JMP, cursp(), pos3));
-	pos3 = tmp;
-	if (pos1) dispatch(s, pos1);
-	tree = tree->cdr;
-	push(); push();
+        n = tree->car->car;
+        pos1 = pos2 = 0;
+        while (n) {
+          codegen(s, n->car, VAL);
+          if (head) {
+            genop(s, MKOP_AB(OP_MOVE, cursp(), head));
+            push();
+            genop(s, MKOP_A(OP_LOADNIL, cursp()));
+            pop(); pop();
+            genop(s, MKOP_ABC(OP_SEND, cursp(), new_msym(s, mrb_intern(s->mrb, "===")), 1));
+          }
+          tmp = new_label(s);
+          genop(s, MKOP_AsBx(OP_JMPIF, cursp(), pos2));
+          pos2 = tmp;
+          n = n->cdr;
+        }
+        if (tree->car->car) {
+          pos1 = new_label(s);
+          genop(s, MKOP_AsBx(OP_JMP, cursp(), 0));
+          dispatch_linked(s, pos2);
+        }
+        pop(); pop();
+        codegen(s, tree->car->cdr, val);
+        tmp = new_label(s);
+        genop(s, MKOP_AsBx(OP_JMP, cursp(), pos3));
+        pos3 = tmp;
+        if (pos1) dispatch(s, pos1);
+        tree = tree->cdr;
+        push(); push();
       }
       pop();
       if (pos3) dispatch_linked(s, pos3);
@@ -1116,14 +1116,14 @@ codegen(codegen_scope *s, node *tree, int val)
 
       n = gen_values(s, tree);
       if (n >= 0) {
-	pop_n(n);
-	if (val) {
-	  genop(s, MKOP_ABC(OP_ARRAY, cursp(), cursp(), n));
-	  push();
-	}
+        pop_n(n);
+        if (val) {
+          genop(s, MKOP_ABC(OP_ARRAY, cursp(), cursp(), n));
+          push();
+        }
       }
       else if (val) {
-	push();
+        push();
       }
     }
     break;
@@ -1133,15 +1133,15 @@ codegen(codegen_scope *s, node *tree, int val)
       int len = 0;
 
       while (tree) {
-	codegen(s, tree->car->car, VAL);
-	codegen(s, tree->car->cdr, VAL);
-	len++;
-	tree = tree->cdr;
+        codegen(s, tree->car->car, VAL);
+        codegen(s, tree->car->cdr, VAL);
+        len++;
+        tree = tree->cdr;
       }
       pop_n(len*2);
       if (val) {
-	genop(s, MKOP_ABC(OP_HASH, cursp(), cursp(), len));
-	push();
+        genop(s, MKOP_ABC(OP_HASH, cursp(), cursp(), len));
+        push();
       }
     }
     break;
@@ -1163,59 +1163,59 @@ codegen(codegen_scope *s, node *tree, int val)
       int rhs = cursp();
 
       if ((intptr_t)t->car == NODE_ARRAY && nosplat(t->cdr)) {
-	// fixed rhs
-	t = t->cdr;
-	while (t) {
-	  codegen(s, t->car, VAL);
-	  len++;
-	  t = t->cdr;
-	}
-	tree = tree->car;
-	if (tree->car) {		/* pre */
-	  t = tree->car;
-	  n = 0;
-	  while (t) {
-	    gen_assignment(s, t->car, rhs+n, NOVAL);
-	    n++;
-	    t = t->cdr;
-	  }
-	}
-	t = tree->cdr;
-	if (t) {
-	  if (t->cdr) {		/* post count */
-	    p = t->cdr->car;
-	    while (p) {
-	      post++;
-	      p = p->cdr;
-	    }
-	  }
-	  if (t->car) {		/* rest (len - pre - post) */
-	    int rn = len - post - n;
-
-	    genop(s, MKOP_ABC(OP_ARRAY, cursp(), rhs+n, rn));
-	    gen_assignment(s, t->car, cursp(), NOVAL);
-	    n += rn;
-	  }
-	  if (t->cdr && t->cdr->car) {
-	    t = t->cdr->car;
-	    while (n<len) {
-	      gen_assignment(s, t->car, rhs+n, NOVAL);
-	      t = t->cdr;
-	      n++;
-	    }
-	  }
-	}
-	pop_n(len);
-	if (val) {
-	  genop(s, MKOP_ABC(OP_ARRAY, rhs, rhs, len));
-	  push();
-	}
+        // fixed rhs
+        t = t->cdr;
+        while (t) {
+          codegen(s, t->car, VAL);
+          len++;
+          t = t->cdr;
+        }
+        tree = tree->car;
+        if (tree->car) {                /* pre */
+          t = tree->car;
+          n = 0;
+          while (t) {
+            gen_assignment(s, t->car, rhs+n, NOVAL);
+            n++;
+            t = t->cdr;
+          }
+        }
+        t = tree->cdr;
+        if (t) {
+          if (t->cdr) {         /* post count */
+            p = t->cdr->car;
+            while (p) {
+              post++;
+              p = p->cdr;
+            }
+          }
+          if (t->car) {         /* rest (len - pre - post) */
+            int rn = len - post - n;
+
+            genop(s, MKOP_ABC(OP_ARRAY, cursp(), rhs+n, rn));
+            gen_assignment(s, t->car, cursp(), NOVAL);
+            n += rn;
+          }
+          if (t->cdr && t->cdr->car) {
+            t = t->cdr->car;
+            while (n<len) {
+              gen_assignment(s, t->car, rhs+n, NOVAL);
+              t = t->cdr;
+              n++;
+            }
+          }
+        }
+        pop_n(len);
+        if (val) {
+          genop(s, MKOP_ABC(OP_ARRAY, rhs, rhs, len));
+          push();
+        }
       }
       else {
-	// variable rhs
-	codegen(s, t, VAL);
-	gen_vmassignment(s, tree->car, rhs, val);
-	if (!val) pop();
+        // variable rhs
+        codegen(s, t, VAL);
+        gen_vmassignment(s, tree->car, rhs, val);
+        if (!val) pop();
       }
     }
     break;
@@ -1231,25 +1231,25 @@ codegen(codegen_scope *s, node *tree, int val)
       int idx = new_msym(s, sym);
 
       if (name[0] == '+' && strlen(name) == 1)  {
-	genop(s, MKOP_ABC(OP_ADD, cursp(), idx, 2));
+        genop(s, MKOP_ABC(OP_ADD, cursp(), idx, 2));
       }
       else if (name[0] == '-' && strlen(name) == 1)  {
-	genop(s, MKOP_ABC(OP_SUB, cursp(), idx, 2));
+        genop(s, MKOP_ABC(OP_SUB, cursp(), idx, 2));
       }
       else if (name[0] == '<' && strlen(name) == 1)  {
-	genop(s, MKOP_ABC(OP_LT, cursp(), idx, 2));
+        genop(s, MKOP_ABC(OP_LT, cursp(), idx, 2));
       }
       else if (name[0] == '<' && strlen(name) == 2 && name[1] == '=')  {
-	genop(s, MKOP_ABC(OP_LE, cursp(), idx, 2));
+        genop(s, MKOP_ABC(OP_LE, cursp(), idx, 2));
       }
       else if (name[0] == '>' && strlen(name) == 1)  {
-	genop(s, MKOP_ABC(OP_GT, cursp(), idx, 2));
+        genop(s, MKOP_ABC(OP_GT, cursp(), idx, 2));
       }
       else if (name[0] == '>' && strlen(name) == 2 && name[1] == '=')  {
-	genop(s, MKOP_ABC(OP_GE, cursp(), idx, 2));
+        genop(s, MKOP_ABC(OP_GE, cursp(), idx, 2));
       }
       else {
-	genop(s, MKOP_ABC(OP_SEND, cursp(), idx, 2));
+        genop(s, MKOP_ABC(OP_SEND, cursp(), idx, 2));
       }
     }
     gen_assignment(s, tree->car, cursp(), val);
@@ -1261,19 +1261,19 @@ codegen(codegen_scope *s, node *tree, int val)
 
       push();
       if (tree) {
-	node *args = tree->car;
-	while (args) {
-	  codegen(s, args->car, VAL);
-	  n++;
-	  args = args->cdr;
-	}
+        node *args = tree->car;
+        while (args) {
+          codegen(s, args->car, VAL);
+          n++;
+          args = args->cdr;
+        }
       }
       if (tree && tree->cdr) {
-	codegen(s, tree->cdr, VAL);
-	pop();
+        codegen(s, tree->cdr, VAL);
+        pop();
       }
       else {
-	genop(s, MKOP_A(OP_LOADNIL, cursp()));
+        genop(s, MKOP_A(OP_LOADNIL, cursp()));
       }
       pop_n(n+1);
       genop(s, MKOP_ABC(OP_SUPER, cursp(), 0, n));
@@ -1287,9 +1287,9 @@ codegen(codegen_scope *s, node *tree, int val)
       int lv = 0, ainfo = 0;
 
       while (s2->ainfo < 0) {
-	lv++;
-	s2 = s2->prev;
-	if (!s2) break;
+        lv++;
+        s2 = s2->prev;
+        if (!s2) break;
       }
       if (s2) ainfo = s2->ainfo;
       push();
@@ -1318,19 +1318,19 @@ codegen(codegen_scope *s, node *tree, int val)
       int n = 0, sendv = 0;
 
       while (s2->ainfo < 0) {
-	lv++;
-	s2 = s2->prev;
-	if (!s2) break;
+        lv++;
+        s2 = s2->prev;
+        if (!s2) break;
       }
       if (s2) ainfo = s2->ainfo;
       genop(s, MKOP_ABx(OP_BLKPUSH, cursp(), (ainfo<<4)|(lv & 0xf)));
       push();
       if (tree) {
-	n = gen_values(s, tree);
-	if (n < 0) {
-	  n = sendv = 1;
-	  push();
-	}
+        n = gen_values(s, tree);
+        if (n < 0) {
+          n = sendv = 1;
+          push();
+        }
       }
       genop(s, MKOP_A(OP_LOADNIL, cursp()));
       pop_n(n+1);
@@ -1351,7 +1351,7 @@ codegen(codegen_scope *s, node *tree, int val)
     }
     else if (s->loop->type == LOOP_NORMAL) {
       if (s->ensure_level > s->loop->ensure_level) {
-	genop_peep(s, MKOP_A(OP_EPOP, s->ensure_level - s->loop->ensure_level), NOVAL);
+        genop_peep(s, MKOP_A(OP_EPOP, s->ensure_level - s->loop->ensure_level), NOVAL);
       }
       codegen(s, tree, NOVAL);
       genop(s, MKOP_sBx(OP_JMP, s->loop->pc1 - s->pc));
@@ -1370,7 +1370,7 @@ codegen(codegen_scope *s, node *tree, int val)
     }
     else {
       if (s->ensure_level > s->loop->ensure_level) {
-	genop_peep(s, MKOP_A(OP_EPOP, s->ensure_level - s->loop->ensure_level), NOVAL);
+        genop_peep(s, MKOP_A(OP_EPOP, s->ensure_level - s->loop->ensure_level), NOVAL);
       }
       genop(s, MKOP_sBx(OP_JMP, s->loop->pc2 - s->pc));
     }
@@ -1379,34 +1379,34 @@ codegen(codegen_scope *s, node *tree, int val)
   case NODE_RETRY:
     {
       const char *msg = "unexpected retry";
-      
+
       if (!s->loop) {
-	raise_error(s, msg);
+        raise_error(s, msg);
       }
       else {
-	struct loopinfo *lp = s->loop;
-	int n = 0;
-
-	while (lp && lp->type != LOOP_RESCUE) {
-	  if (lp->type == LOOP_BEGIN) {
-	    n++;
-	  }
-	  lp = lp->prev;
-	}
-	if (!lp) {
-	  raise_error(s, msg);
-	}
-	else {
-	  if (n > 0) {
-	    while (n--) {
-	      genop_peep(s, MKOP_A(OP_POPERR, 1), NOVAL);
-	    }
-	  }
-	  if (s->ensure_level > lp->ensure_level) {
-	    genop_peep(s, MKOP_A(OP_EPOP, s->ensure_level - lp->ensure_level), NOVAL);
-	  }
-	  genop(s, MKOP_sBx(OP_JMP, lp->pc1 - s->pc));
-	}
+        struct loopinfo *lp = s->loop;
+        int n = 0;
+
+        while (lp && lp->type != LOOP_RESCUE) {
+          if (lp->type == LOOP_BEGIN) {
+            n++;
+          }
+          lp = lp->prev;
+        }
+        if (!lp) {
+          raise_error(s, msg);
+        }
+        else {
+          if (n > 0) {
+            while (n--) {
+              genop_peep(s, MKOP_A(OP_POPERR, 1), NOVAL);
+            }
+          }
+          if (s->ensure_level > lp->ensure_level) {
+            genop_peep(s, MKOP_A(OP_EPOP, s->ensure_level - lp->ensure_level), NOVAL);
+          }
+          genop(s, MKOP_sBx(OP_JMP, lp->pc1 - s->pc));
+        }
       }
     }
     break;
@@ -1416,21 +1416,21 @@ codegen(codegen_scope *s, node *tree, int val)
       int idx = lv_idx(s, (mrb_sym)tree);
 
       if (idx > 0) {
-	genop(s, MKOP_AB(OP_MOVE, cursp(), idx));
+        genop(s, MKOP_AB(OP_MOVE, cursp(), idx));
       }
       else {
-	int lv = 0;
-	codegen_scope *up = s->prev;
-
-	while (up) {
-	  idx = lv_idx(up, (mrb_sym)tree);
-	  if (idx > 0) {
-	    genop(s, MKOP_ABC(OP_GETUPVAR, cursp(), idx, lv));
-	    break;
-	  }
-	  lv++;
-	  up = up->prev;
-	}
+        int lv = 0;
+        codegen_scope *up = s->prev;
+
+        while (up) {
+          idx = lv_idx(up, (mrb_sym)tree);
+          if (idx > 0) {
+            genop(s, MKOP_ABC(OP_GETUPVAR, cursp(), idx, lv));
+            break;
+          }
+          lv++;
+          up = up->prev;
+        }
       }
       push();
     }
@@ -1500,11 +1500,11 @@ codegen(codegen_scope *s, node *tree, int val)
       mrb_code co;
 
       if (i < MAXARG_sBx && i > -MAXARG_sBx) {
-	co = MKOP_AsBx(OP_LOADI, cursp(), i);
+        co = MKOP_AsBx(OP_LOADI, cursp(), i);
       }
       else {
-	int off = new_lit(s, mrb_fixnum_value(i));
-	co = MKOP_ABx(OP_LOADL, cursp(), off);
+        int off = new_lit(s, mrb_fixnum_value(i));
+        co = MKOP_ABx(OP_LOADL, cursp(), off);
       }
       genop(s, co);
       push();
@@ -1528,47 +1528,47 @@ codegen(codegen_scope *s, node *tree, int val)
       tree = tree->cdr;
       switch (nt) {
       case NODE_FLOAT:
-	{
-	  char *p = (char*)tree;
-	  mrb_float f = readfloat(p);
-	  int off = new_lit(s, mrb_float_value(-f));
+        {
+          char *p = (char*)tree;
+          mrb_float f = readfloat(p);
+          int off = new_lit(s, mrb_float_value(-f));
 
-	  genop(s, MKOP_ABx(OP_LOADL, cursp(), off));
-	  push();
-	}
-	break;
+          genop(s, MKOP_ABx(OP_LOADL, cursp(), off));
+          push();
+        }
+        break;
 
       case NODE_INT:
-	{
-	  char *p = (char*)tree->car;
-	  int base = (intptr_t)tree->cdr->car;
-	  int i = readint(p, base);
-	  mrb_code co;
-
-	  i = -i;
-	  if (i < MAXARG_sBx && i > -MAXARG_sBx) {
-	    co = MKOP_AsBx(OP_LOADI, cursp(), i);
-	  }
-	  else {
-	    int off = new_lit(s, mrb_fixnum_value(i));
-	    co = MKOP_ABx(OP_LOADL, cursp(), off);
-	  }
-	  genop(s, co);
-	  push();
-	}
-	break;
+        {
+          char *p = (char*)tree->car;
+          int base = (intptr_t)tree->cdr->car;
+          int i = readint(p, base);
+          mrb_code co;
+
+          i = -i;
+          if (i < MAXARG_sBx && i > -MAXARG_sBx) {
+            co = MKOP_AsBx(OP_LOADI, cursp(), i);
+          }
+          else {
+            int off = new_lit(s, mrb_fixnum_value(i));
+            co = MKOP_ABx(OP_LOADL, cursp(), off);
+          }
+          genop(s, co);
+          push();
+        }
+        break;
 
       default:
-	{
-	  int sym = new_msym(s, mrb_intern(s->mrb, "-"));
+        {
+          int sym = new_msym(s, mrb_intern(s->mrb, "-"));
 
-	  genop(s, MKOP_ABx(OP_LOADI, cursp(), 0));
-	  push();
-	  codegen(s, tree, VAL);
-	  pop(); pop();
-	  genop(s, MKOP_ABC(OP_SUB, cursp(), sym, 2));
-	}
-	break;
+          genop(s, MKOP_ABx(OP_LOADI, cursp(), 0));
+          push();
+          codegen(s, tree, VAL);
+          pop(); pop();
+          genop(s, MKOP_ABC(OP_SUB, cursp(), sym, 2));
+        }
+        break;
       }
     }
     break;
@@ -1591,21 +1591,21 @@ codegen(codegen_scope *s, node *tree, int val)
       codegen(s, n->car, VAL);
       n = n->cdr;
       while (n) {
-	codegen(s, n->car, VAL);
-	pop(); pop();
-	genop(s, MKOP_AB(OP_STRCAT, cursp(), cursp()+1));
-	push();
-	n = n->cdr;
+        codegen(s, n->car, VAL);
+        pop(); pop();
+        genop(s, MKOP_AB(OP_STRCAT, cursp(), cursp()+1));
+        push();
+        n = n->cdr;
       }
     }
     else {
       node *n = tree;
 
       while (n) {
-	if ((intptr_t)n->car->car != NODE_STR) {
-	  codegen(s, n->car, NOVAL);
-	}
-	n = n->cdr;
+        if ((intptr_t)n->car->car != NODE_STR) {
+          codegen(s, n->car, NOVAL);
+        }
+        n = n->cdr;
       }
     }
     break;
@@ -1663,7 +1663,7 @@ codegen(codegen_scope *s, node *tree, int val)
       pop_n(3);
       genop(s, MKOP_ABC(OP_SEND, cursp(), c, 2));
       if (val) {
-	push();
+        push();
       }
     }
    break;
@@ -1681,7 +1681,7 @@ codegen(codegen_scope *s, node *tree, int val)
       pop_n(2);
       genop(s, MKOP_ABC(OP_SEND, cursp(), undef, 2));
       if (val) {
-	push();
+        push();
       }
     }
     break;
@@ -1690,23 +1690,23 @@ codegen(codegen_scope *s, node *tree, int val)
     {
       int idx;
 
-      if (tree->car->car == (node*)0) { 
-	genop(s, MKOP_A(OP_LOADNIL, cursp()));
-	push();
+      if (tree->car->car == (node*)0) {
+        genop(s, MKOP_A(OP_LOADNIL, cursp()));
+        push();
       }
       else if (tree->car->car == (node*)1) {
-	genop(s, MKOP_A(OP_OCLASS, cursp()));
-	push();
+        genop(s, MKOP_A(OP_OCLASS, cursp()));
+        push();
       }
       else {
-	codegen(s, tree->car->car, VAL);
+        codegen(s, tree->car->car, VAL);
       }
       if (tree->cdr->car) {
-	codegen(s, tree->cdr->car, VAL);
+        codegen(s, tree->cdr->car, VAL);
       }
       else {
-	genop(s, MKOP_A(OP_LOADNIL, cursp()));
-	push();
+        genop(s, MKOP_A(OP_LOADNIL, cursp()));
+        push();
       }
       pop(); pop();
       idx = new_msym(s, (mrb_sym)tree->car->cdr);
@@ -1714,7 +1714,7 @@ codegen(codegen_scope *s, node *tree, int val)
       idx = scope_body(s, tree->cdr->cdr->car);
       genop(s, MKOP_ABx(OP_EXEC, cursp(), idx));
       if (val) {
-	push();
+        push();
       }
     }
     break;
@@ -1723,16 +1723,16 @@ codegen(codegen_scope *s, node *tree, int val)
     {
       int idx;
 
-      if (tree->car->car == (node*)0) { 
-	genop(s, MKOP_A(OP_LOADNIL, cursp()));
-	push();
+      if (tree->car->car == (node*)0) {
+        genop(s, MKOP_A(OP_LOADNIL, cursp()));
+        push();
       }
       else if (tree->car->car == (node*)1) {
-	genop(s, MKOP_A(OP_OCLASS, cursp()));
-	push();
+        genop(s, MKOP_A(OP_OCLASS, cursp()));
+        push();
       }
       else {
-	codegen(s, tree->car->car, VAL);
+        codegen(s, tree->car->car, VAL);
       }
       pop();
       idx = new_msym(s, (mrb_sym)tree->car->cdr);
@@ -1740,7 +1740,7 @@ codegen(codegen_scope *s, node *tree, int val)
       idx = scope_body(s, tree->cdr->car);
       genop(s, MKOP_ABx(OP_EXEC, cursp(), idx));
       if (val) {
-	push();
+        push();
       }
     }
     break;
@@ -1755,7 +1755,7 @@ codegen(codegen_scope *s, node *tree, int val)
       idx = scope_body(s, tree->cdr->car);
       genop(s, MKOP_ABx(OP_EXEC, cursp(), idx));
       if (val) {
-	push();
+        push();
       }
     }
     break;
@@ -1771,7 +1771,7 @@ codegen(codegen_scope *s, node *tree, int val)
       pop();
       genop(s, MKOP_AB(OP_METHOD, cursp(), sym));
       if (val) {
-	genop(s, MKOP_A(OP_LOADNIL, cursp()));
+        genop(s, MKOP_A(OP_LOADNIL, cursp()));
       }
     }
     break;
@@ -1790,7 +1790,7 @@ codegen(codegen_scope *s, node *tree, int val)
       pop();
       genop(s, MKOP_AB(OP_METHOD, cursp(), sym));
       if (val) {
-	genop(s, MKOP_A(OP_LOADNIL, cursp()));
+        genop(s, MKOP_A(OP_LOADNIL, cursp()));
       }
     }
     break;
@@ -1906,10 +1906,10 @@ loop_break(codegen_scope *s, node *tree)
       int tmp;
 
       if (s->ensure_level > s->loop->ensure_level) {
-	genop_peep(s, MKOP_A(OP_EPOP, s->ensure_level - s->loop->ensure_level), NOVAL);
+        genop_peep(s, MKOP_A(OP_EPOP, s->ensure_level - s->loop->ensure_level), NOVAL);
       }
       if (tree) {
-	genop_peep(s, MKOP_AB(OP_MOVE, loop->acc, cursp()), NOVAL);
+        genop_peep(s, MKOP_AB(OP_MOVE, loop->acc, cursp()), NOVAL);
       }
       tmp = new_label(s);
       genop(s, MKOP_sBx(OP_JMP, loop->pc3));
@@ -1941,7 +1941,7 @@ codedump(mrb_state *mrb, int n)
 
   if (!irep) return;
   printf("irep %d nregs=%d nlocals=%d pools=%d syms=%d\n", n,
-	 irep->nregs, irep->nlocals, irep->plen, irep->slen);
+         irep->nregs, irep->nlocals, irep->plen, irep->slen);
   for (i=0; i<irep->ilen; i++) {
     printf("%03d ", i);
     c = irep->iseq[i];
@@ -1960,7 +1960,7 @@ codedump(mrb_state *mrb, int n)
       break;
     case OP_LOADSYM:
       printf("OP_LOADSYM\tR%d\t'%s'\n", GETARG_A(c),
-	     mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
+             mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
       break;
     case OP_LOADNIL:
       printf("OP_LOADNIL\tR%d\n", GETARG_A(c));
@@ -1976,56 +1976,56 @@ codedump(mrb_state *mrb, int n)
       break;
     case OP_GETGLOBAL:
       printf("OP_GETGLOBAL\tR%d\t'%s'\n", GETARG_A(c),
-	     mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
+             mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
       break;
     case OP_SETGLOBAL:
       printf("OP_SETGLOBAL\t'%s'\tR%d\n",
-	     mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]),
-	     GETARG_A(c));
+             mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]),
+             GETARG_A(c));
       break;
     case OP_GETCONST:
       printf("OP_GETCONST\tR%d\t'%s'\n", GETARG_A(c),
-	     mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
+             mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
       break;
     case OP_SETCONST:
       printf("OP_SETCONST\t'%s'\tR%d\n",
-	     mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]),
-	     GETARG_A(c));
+             mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]),
+             GETARG_A(c));
       break;
     case OP_GETMCNST:
       printf("OP_GETMCNST\tR%d\tR%d::%s\n", GETARG_A(c), GETARG_A(c),
-	     mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
+             mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
       break;
     case OP_SETMCNST:
       printf("OP_SETMCNST\tR%d::%s\tR%d\n", GETARG_A(c)+1,
-	     mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]),
-	     GETARG_A(c));
+             mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]),
+             GETARG_A(c));
       break;
     case OP_GETIV:
       printf("OP_GETIV\tR%d\t%s\n", GETARG_A(c),
-	     mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
+             mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
       break;
     case OP_SETIV:
       printf("OP_SETIV\t%s\tR%d\n",
-	     mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]),
-	     GETARG_A(c));
+             mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]),
+             GETARG_A(c));
       break;
     case OP_GETUPVAR:
       printf("OP_GETUPVAR\tR%d\t%d\t%d\n",
-	     GETARG_A(c), GETARG_B(c), GETARG_C(c));
+             GETARG_A(c), GETARG_B(c), GETARG_C(c));
       break;
     case OP_SETUPVAR:
       printf("OP_SETUPVAR\tR%d\t%d\t%d\n",
-	     GETARG_A(c), GETARG_B(c), GETARG_C(c));
+             GETARG_A(c), GETARG_B(c), GETARG_C(c));
       break;
     case OP_GETCV:
       printf("OP_GETCV\tR%d\t%s\n", GETARG_A(c),
-	     mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
+             mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
       break;
     case OP_SETCV:
       printf("OP_SETCV\t%s\tR%d\n",
-	     mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]),
-	     GETARG_A(c));
+             mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]),
+             GETARG_A(c));
       break;
     case OP_JMP:
       printf("OP_JMP\t\t%03d\n", i+GETARG_sBx(c));
@@ -2038,51 +2038,51 @@ codedump(mrb_state *mrb, int n)
       break;
     case OP_SEND:
       printf("OP_SEND\tR%d\t'%s'\t%d\n", GETARG_A(c),
-	     mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
-	     GETARG_C(c));
+             mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
+             GETARG_C(c));
       break;
     case OP_SUPER:
       printf("OP_SUPER\tR%d\t%d\n", GETARG_A(c),
-	     GETARG_C(c));
+             GETARG_C(c));
       break;
     case OP_ARGARY:
       printf("OP_ARGARY\tR%d\t%d:%d:%d:%d\n", GETARG_A(c),
-	     (GETARG_Bx(c)>>10)&0x3f,
-	     (GETARG_Bx(c)>>9)&0x1,
-	     (GETARG_Bx(c)>>4)&0x1f,
-	     (GETARG_Bx(c)>>0)&0xf);
+             (GETARG_Bx(c)>>10)&0x3f,
+             (GETARG_Bx(c)>>9)&0x1,
+             (GETARG_Bx(c)>>4)&0x1f,
+             (GETARG_Bx(c)>>0)&0xf);
       break;
 
     case OP_ENTER:
       printf("OP_ENTER\t%d:%d:%d:%d:%d:%d:%d\n",
-	     (GETARG_Ax(c)>>18)&0x1f,
-	     (GETARG_Ax(c)>>13)&0x1f,
-	     (GETARG_Ax(c)>>12)&0x1,
-	     (GETARG_Ax(c)>>7)&0x1f,
-	     (GETARG_Ax(c)>>2)&0x1f,
-	     (GETARG_Ax(c)>>1)&0x1,
-	     GETARG_Ax(c) & 0x1);
+             (GETARG_Ax(c)>>18)&0x1f,
+             (GETARG_Ax(c)>>13)&0x1f,
+             (GETARG_Ax(c)>>12)&0x1,
+             (GETARG_Ax(c)>>7)&0x1f,
+             (GETARG_Ax(c)>>2)&0x1f,
+             (GETARG_Ax(c)>>1)&0x1,
+             GETARG_Ax(c) & 0x1);
       break;
     case OP_RETURN:
       printf("OP_RETURN\tR%d", GETARG_A(c));
       switch (GETARG_B(c)) {
       case OP_R_NORMAL:
-	printf("\n"); break;
+        printf("\n"); break;
       case OP_R_RETURN:
-	printf("\treturn\n"); break;
+        printf("\treturn\n"); break;
       case OP_R_BREAK:
-	printf("\tbreak\n"); break;
+        printf("\tbreak\n"); break;
       default:
-	printf("\tbroken\n"); break;
-	break;
+        printf("\tbroken\n"); break;
+        break;
       }
       break;
     case OP_BLKPUSH:
       printf("OP_BLKPUSH\tR%d\t%d:%d:%d:%d\n", GETARG_A(c),
-	     (GETARG_Bx(c)>>10)&0x3f,
-	     (GETARG_Bx(c)>>9)&0x1,
-	     (GETARG_Bx(c)>>4)&0x1f,
-	     (GETARG_Bx(c)>>0)&0xf);
+             (GETARG_Bx(c)>>10)&0x3f,
+             (GETARG_Bx(c)>>9)&0x1,
+             (GETARG_Bx(c)>>4)&0x1f,
+             (GETARG_Bx(c)>>0)&0xf);
       break;
 
     case OP_LAMBDA:
@@ -2093,38 +2093,38 @@ codedump(mrb_state *mrb, int n)
       break;
     case OP_METHOD:
       printf("OP_METHOD\tR%d\t'%s'\n", GETARG_A(c),
-	     mrb_sym2name(mrb, irep->syms[GETARG_B(c)]));
+             mrb_sym2name(mrb, irep->syms[GETARG_B(c)]));
       break;
 
     case OP_ADD:
       printf("OP_ADD\tR%d\t'%s'\t%d\n", GETARG_A(c),
-	     mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
-	     GETARG_C(c));
+             mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
+             GETARG_C(c));
       break;
     case OP_SUB:
       printf("OP_SUB\tR%d\t'%s'\t%d\n", GETARG_A(c),
-	     mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
-	     GETARG_C(c));
+             mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
+             GETARG_C(c));
       break;
     case OP_LT:
       printf("OP_LT\tR%d\t'%s'\t%d\n", GETARG_A(c),
-	     mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
-	     GETARG_C(c));
+             mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
+             GETARG_C(c));
       break;
     case OP_LE:
       printf("OP_LE\tR%d\t'%s'\t%d\n", GETARG_A(c),
-	     mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
-	     GETARG_C(c));
+             mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
+             GETARG_C(c));
       break;
     case OP_GT:
       printf("OP_GT\tR%d\t'%s'\t%d\n", GETARG_A(c),
-	     mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
-	     GETARG_C(c));
+             mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
+             GETARG_C(c));
       break;
     case OP_GE:
       printf("OP_GE\tR%d\t'%s'\t%d\n", GETARG_A(c),
-	     mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
-	     GETARG_C(c));
+             mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
+             GETARG_C(c));
       break;
 
     case OP_STOP:
@@ -2161,11 +2161,11 @@ codedump(mrb_state *mrb, int n)
       break;
     case OP_CLASS:
       printf("OP_CLASS\tR%d\t'%s'\n", GETARG_A(c),
-	     mrb_sym2name(mrb, irep->syms[GETARG_B(c)]));
+             mrb_sym2name(mrb, irep->syms[GETARG_B(c)]));
       break;
     case OP_MODULE:
       printf("OP_MODULE\tR%d\t'%s'\n", GETARG_A(c),
-	     mrb_sym2name(mrb, irep->syms[GETARG_B(c)]));
+             mrb_sym2name(mrb, irep->syms[GETARG_B(c)]));
       break;
     case OP_EXEC:
       printf("OP_EXEC\tR%d\tI(%d)\n", GETARG_A(c), n+GETARG_Bx(c));
@@ -2200,7 +2200,7 @@ codedump(mrb_state *mrb, int n)
 
     default:
       printf("OP_unknown %d\t%d\t%d\t%d\n", GET_OPCODE(c),
-	     GETARG_A(c), GETARG_B(c), GETARG_C(c));
+             GETARG_A(c), GETARG_B(c), GETARG_C(c));
       break;
     }
   }
diff --git a/src/compar.c b/src/compar.c
index 5fef89329..bcd77867e 100644
--- a/src/compar.c
+++ b/src/compar.c
@@ -1,6 +1,6 @@
 /*
 ** compar.c - Comparable module
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -22,7 +22,7 @@ mrb_cmperr(mrb_state *mrb, mrb_value x, mrb_value y)
     classname = mrb_obj_classname(mrb, y);
   }
   mrb_raise(mrb, E_ARGUMENT_ERROR, "comparison of %s with %s failed",
-	    mrb_obj_classname(mrb, x), classname);
+            mrb_obj_classname(mrb, x), classname);
 }
 
 int
diff --git a/src/compile.h b/src/compile.h
index 6e6975cbf..9d58acaa0 100644
--- a/src/compile.h
+++ b/src/compile.h
@@ -1,6 +1,6 @@
 /*
 ** compile.h - mruby parser
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -17,17 +17,17 @@ typedef struct mrb_ast_node {
 #include <stdio.h>
 
 enum mrb_lex_state_enum {
-    EXPR_BEG,			/* ignore newline, +/- is a sign. */
-    EXPR_END,			/* newline significant, +/- is an operator. */
-    EXPR_ENDARG,		/* ditto, and unbound braces. */
-    EXPR_ENDFN, 		/* ditto, and unbound braces. */
-    EXPR_ARG,			/* newline significant, +/- is an operator. */
-    EXPR_CMDARG,		/* newline significant, +/- is an operator. */
-    EXPR_MID,			/* newline significant, +/- is an operator. */
-    EXPR_FNAME,			/* ignore newline, no reserved words. */
-    EXPR_DOT,			/* right after `.' or `::', no reserved words. */
-    EXPR_CLASS,			/* immediate after `class', no here document. */
-    EXPR_VALUE,			/* alike EXPR_BEG but label is disallowed. */
+    EXPR_BEG,                   /* ignore newline, +/- is a sign. */
+    EXPR_END,                   /* newline significant, +/- is an operator. */
+    EXPR_ENDARG,                /* ditto, and unbound braces. */
+    EXPR_ENDFN,                 /* ditto, and unbound braces. */
+    EXPR_ARG,                   /* newline significant, +/- is an operator. */
+    EXPR_CMDARG,                /* newline significant, +/- is an operator. */
+    EXPR_MID,                   /* newline significant, +/- is an operator. */
+    EXPR_FNAME,                 /* ignore newline, no reserved words. */
+    EXPR_DOT,                   /* right after `.' or `::', no reserved words. */
+    EXPR_CLASS,                 /* immediate after `class', no here document. */
+    EXPR_VALUE,                 /* alike EXPR_BEG but label is disallowed. */
     EXPR_MAX_STATE
 };
 
diff --git a/src/crc.c b/src/crc.c
index 412252347..0451c363c 100644
--- a/src/crc.c
+++ b/src/crc.c
@@ -1,6 +1,6 @@
 /*
 ** crc.c - calculate CRC
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/dump.c b/src/dump.c
index 61297eb10..1771a061c 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -1,6 +1,6 @@
 /*
 ** dump.c - mruby binary dumper (Rite binary format)
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -661,7 +661,7 @@ mrb_dump_irep(mrb_state *mrb, int top, FILE* fp)
   if (fwrite("00000000"/* end of file */, 8, 1, fp) != 1)
     return MRB_DUMP_WRITE_FAULT;
 
-  rc = dump_rite_header(mrb, top, fp, rbds);	//TODO: Remove top(SIREP)
+  rc = dump_rite_header(mrb, top, fp, rbds);    //TODO: Remove top(SIREP)
 
   return rc;
 }
diff --git a/src/encoding.c b/src/encoding.c
index 2f698865b..54cf290c2 100644
--- a/src/encoding.c
+++ b/src/encoding.c
@@ -1,6 +1,6 @@
 /*
 ** encoding.c - Encoding class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -1376,14 +1376,14 @@ nl_langinfo_codeset(void)
     p = strchr(l, '.');
     if (!p++) p = l;
     if (strstart(p, "UTF"))
-	return "UTF-8";
+        return "UTF-8";
     if ((n = 5, strstart(p, "8859-")) || (n = 9, strstart(p, "ISO-8859-"))) {
       if (digit(p[n])) {
-	p += n;
-	memcpy(buf, "ISO-8859-\0\0", 12);
-	buf[9] = *p++;
-	if (digit(*p)) buf[10] = *p++;
-	return buf;
+        p += n;
+        memcpy(buf, "ISO-8859-\0\0", 12);
+        buf[9] = *p++;
+        if (digit(*p)) buf[10] = *p++;
+        return buf;
       }
     }
     if (strstart(p, "KOI8-R")) return "KOI8-R";
@@ -1406,8 +1406,8 @@ nl_langinfo_codeset(void)
     if (strstart(l, "ru")) return "KOI8-R";
     if (strstart(l, "uk")) return "KOI8-U";
     if (strstart(l, "pl") || strstart(l, "hr") ||
-	strstart(l, "hu") || strstart(l, "cs") ||
-	strstart(l, "sk") || strstart(l, "sl")) return "ISO-8859-2";
+        strstart(l, "hu") || strstart(l, "cs") ||
+        strstart(l, "sk") || strstart(l, "sl")) return "ISO-8859-2";
     if (strstart(l, "eo") || strstart(l, "mt")) return "ISO-8859-3";
     if (strstart(l, "el")) return "ISO-8859-7";
     if (strstart(l, "he")) return "ISO-8859-8";
diff --git a/src/encoding.h b/src/encoding.h
index bc4a7ccc2..0cae09db0 100644
--- a/src/encoding.h
+++ b/src/encoding.h
@@ -1,6 +1,6 @@
 /*
 ** encoding.h - Encoding class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -62,16 +62,16 @@ int mrb_toupper(int c);
 
 #define ENCODING_MAXNAMELEN 42
 
-#define ENC_CODERANGE_MASK	((int)(FL_USER8|FL_USER9))
-#define ENC_CODERANGE_UNKNOWN	0
-#define ENC_CODERANGE_7BIT	((int)FL_USER8)
-#define ENC_CODERANGE_VALID	((int)FL_USER9)
-#define ENC_CODERANGE_BROKEN	((int)(FL_USER8|FL_USER9))
+#define ENC_CODERANGE_MASK      ((int)(FL_USER8|FL_USER9))
+#define ENC_CODERANGE_UNKNOWN   0
+#define ENC_CODERANGE_7BIT      ((int)FL_USER8)
+#define ENC_CODERANGE_VALID     ((int)FL_USER9)
+#define ENC_CODERANGE_BROKEN    ((int)(FL_USER8|FL_USER9))
 #define ENC_CODERANGE(obj) ((int)(RSTRING(obj)->flags & ENC_CODERANGE_MASK))
 #define ENC_CODERANGE_ASCIIONLY(obj) (ENC_CODERANGE(obj) == ENC_CODERANGE_7BIT)
 #ifdef INCLUDE_ENCODING
 #define ENC_CODERANGE_SET(obj,cr) (RSTRING(obj)->flags = \
-				   (RSTRING(obj)->flags & ~ENC_CODERANGE_MASK) | (cr))
+                                   (RSTRING(obj)->flags & ~ENC_CODERANGE_MASK) | (cr))
 #else
 #define ENC_CODERANGE_SET(obj,cr)
 #endif //INCLUDE_ENCODING
diff --git a/src/enum.c b/src/enum.c
index 0b8e6dcdb..b062d4146 100644
--- a/src/enum.c
+++ b/src/enum.c
@@ -1,6 +1,6 @@
 /*
 ** enum.c - Enumerable module
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/error.c b/src/error.c
index 2dbfe0ac2..d18311633 100644
--- a/src/error.c
+++ b/src/error.c
@@ -1,6 +1,6 @@
 /*
 ** error.c - Exception class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -332,7 +332,7 @@ error_pos(void)
 static void
 set_backtrace(mrb_state *mrb, mrb_value info, mrb_value bt)
 {
-	mrb_funcall(mrb, info, "set_backtrace", 1, bt);
+        mrb_funcall(mrb, info, "set_backtrace", 1, bt);
 }
 
 mrb_value
diff --git a/src/error.h b/src/error.h
index 42fb635c5..babf93a7d 100644
--- a/src/error.h
+++ b/src/error.h
@@ -1,6 +1,6 @@
 /*
 ** error.h - Exception class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/etc.c b/src/etc.c
index e82657a97..51ed9ada1 100644
--- a/src/etc.c
+++ b/src/etc.c
@@ -1,6 +1,6 @@
 /*
-** etc.c - 
-** 
+** etc.c -
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/eval_intern.h b/src/eval_intern.h
index 3179f50b2..4324f26cc 100644
--- a/src/eval_intern.h
+++ b/src/eval_intern.h
@@ -1,6 +1,6 @@
 /*
-** eval_intern.h - 
-** 
+** eval_intern.h -
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -48,7 +48,7 @@
 #  ifndef alloca
 #   define alloca __builtin_alloca
 #  endif
-# endif	/* atarist */
+# endif /* atarist */
 #else
 # ifdef HAVE_ALLOCA_H
 #  include <alloca.h>
@@ -56,11 +56,11 @@
 #  ifdef _AIX
 #pragma alloca
 #  else
-#   ifndef alloca		/* predefined by HP cc +Olibcalls */
+#   ifndef alloca               /* predefined by HP cc +Olibcalls */
 void *alloca();
 #   endif
 #  endif /* AIX */
-# endif	/* HAVE_ALLOCA_H */
+# endif /* HAVE_ALLOCA_H */
 #endif /* __GNUC__ */
 
 #ifndef HAVE_STRING_H
@@ -135,25 +135,25 @@ char *strrchr(const char *, const char);
 //#define JUMP_TAG(st) TH_JUMP_TAG(GET_THREAD(), st)
 
 enum ruby_tag_type {
-    RUBY_TAG_RETURN	= 0x1,
-    RUBY_TAG_BREAK	= 0x2,
-    RUBY_TAG_NEXT	= 0x3,
-    RUBY_TAG_RETRY	= 0x4,
-    RUBY_TAG_REDO	= 0x5,
-    RUBY_TAG_RAISE	= 0x6,
-    RUBY_TAG_THROW	= 0x7,
-    RUBY_TAG_FATAL	= 0x8,
-    RUBY_TAG_MASK	= 0xf
+    RUBY_TAG_RETURN     = 0x1,
+    RUBY_TAG_BREAK      = 0x2,
+    RUBY_TAG_NEXT       = 0x3,
+    RUBY_TAG_RETRY      = 0x4,
+    RUBY_TAG_REDO       = 0x5,
+    RUBY_TAG_RAISE      = 0x6,
+    RUBY_TAG_THROW      = 0x7,
+    RUBY_TAG_FATAL      = 0x8,
+    RUBY_TAG_MASK       = 0xf
 };
-#define TAG_RETURN	RUBY_TAG_RETURN
-#define TAG_BREAK	RUBY_TAG_BREAK
-#define TAG_NEXT	RUBY_TAG_NEXT
-#define TAG_RETRY	RUBY_TAG_RETRY
-#define TAG_REDO	RUBY_TAG_REDO
-#define TAG_RAISE	RUBY_TAG_RAISE
-#define TAG_THROW	RUBY_TAG_THROW
-#define TAG_FATAL	RUBY_TAG_FATAL
-#define TAG_MASK	RUBY_TAG_MASK
+#define TAG_RETURN      RUBY_TAG_RETURN
+#define TAG_BREAK       RUBY_TAG_BREAK
+#define TAG_NEXT        RUBY_TAG_NEXT
+#define TAG_RETRY       RUBY_TAG_RETRY
+#define TAG_REDO        RUBY_TAG_REDO
+#define TAG_RAISE       RUBY_TAG_RAISE
+#define TAG_THROW       RUBY_TAG_THROW
+#define TAG_FATAL       RUBY_TAG_FATAL
+#define TAG_MASK        RUBY_TAG_MASK
 
 #define NEW_THROW_OBJECT(val, pt, st) \
   ((mrb_value)mrb_node_newnode(NODE_LIT, (mrb_value)(val), (mrb_value)(pt), (mrb_value)(st)))
@@ -208,7 +208,7 @@ NORETURN(void rb_print_undef(mrb_value, mrb_sym, int));
 NORETURN(void rb_vm_localjump_error(const char *,mrb_value, int));
 NORETURN(void rb_vm_jump_tag_but_local_jump(int, mrb_value));
 //NORETURN(void mrb_raise_method_missing(mrb_thread_t *th, int argc, mrb_value *argv,
-//				      mrb_value obj, int call_status));
+//                                    mrb_value obj, int call_status));
 
 mrb_value mrb_vm_make_jump_tag_but_local_jump(int state, mrb_value val);
 NODE *mrb_vm_cref(void);
diff --git a/src/gc.c b/src/gc.c
index e90c8a293..06360036a 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1,6 +1,6 @@
 /*
 ** gc.c - garbage collector for RiteVM
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -298,7 +298,7 @@ gc_mark_children(mrb_state *mrb, struct RBasic *obj)
   case MRB_TT_MODULE:
     {
       struct RClass *c = (struct RClass*)obj;
-  
+
       mrb_gc_mark_iv(mrb, (struct RObject*)obj);
       mrb_gc_mark_mt(mrb, c);
       mrb_gc_mark(mrb, (struct RBasic*)c->super);
@@ -353,8 +353,8 @@ gc_mark_children(mrb_state *mrb, struct RBasic *obj)
       struct RString *s = (struct RString*)obj;
 
       while (s->flags & MRB_STR_SHARED) {
-	s = s->aux.shared;
-	if (!s) break;
+        s = s->aux.shared;
+        if (!s) break;
       }
     }
     break;
@@ -441,7 +441,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj)
         d->type->dfree(mrb, d->data);
       }
     }
-	  break;
+          break;
 
   default:
     break;
@@ -594,12 +594,12 @@ incremental_sweep_phase(mrb_state *mrb, size_t limit)
 
     while (p<e) {
       if (is_dead(mrb, &p->as.basic)) {
-	if (p->as.basic.tt != MRB_TT_FREE) {
-	  obj_free(mrb, &p->as.basic);
-	  p->as.free.next = page->freelist;
-	  page->freelist = (struct RBasic*)p;
+        if (p->as.basic.tt != MRB_TT_FREE) {
+          obj_free(mrb, &p->as.basic);
+          p->as.free.next = page->freelist;
+          page->freelist = (struct RBasic*)p;
           freed++;
-	}
+        }
       }
       else {
         paint_partial_white(mrb, &p->as.basic); /* next gc target */
diff --git a/src/gc.h b/src/gc.h
index 38637d507..3c18905d3 100644
--- a/src/gc.h
+++ b/src/gc.h
@@ -1,6 +1,6 @@
 /*
 ** gc.h - garbage collector for RiteVM
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/hash.c b/src/hash.c
index b1df78a3e..078faf1d3 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -1,6 +1,6 @@
 /*
 ** hash.c - Hash class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/init.c b/src/init.c
index 869201eea..9dbdc44d1 100644
--- a/src/init.c
+++ b/src/init.c
@@ -1,6 +1,6 @@
 /*
 ** init.c - initialize mruby core
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/init_ext.c b/src/init_ext.c
index 0643bd4fd..96ee34da1 100644
--- a/src/init_ext.c
+++ b/src/init_ext.c
@@ -1,6 +1,6 @@
 /*
 ** init_ext.c - initialize extend libraries
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/kernel.c b/src/kernel.c
index eeaa0fe27..8d7b38880 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -1,6 +1,6 @@
 /*
 ** kernel.c - Kernel module
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -55,22 +55,22 @@ inspect_obj(mrb_state *mrb, mrb_value obj, mrb_value str, int recur)
 
     if (h) {
       for (k = kh_begin(h); k != kh_end(h); k++) {
-	if (kh_exist(h, k)){
-	  mrb_sym id = kh_key(h, k);
-	  mrb_value value = kh_value(h, k);
-
-	  /* need not to show internal data */
-	  if (RSTRING_PTR(str)[0] == '-') { /* first element */
-	    RSTRING_PTR(str)[0] = '#';
-	    mrb_str_cat2(mrb, str, " ");
-	  }
-	  else {
-	    mrb_str_cat2(mrb, str, ", ");
-	  }
-	  mrb_str_cat2(mrb, str, mrb_sym2name(mrb, id));
-	  mrb_str_cat2(mrb, str, "=");
-	  mrb_str_append(mrb, str, mrb_inspect(mrb, value));
-	}
+        if (kh_exist(h, k)){
+          mrb_sym id = kh_key(h, k);
+          mrb_value value = kh_value(h, k);
+
+          /* need not to show internal data */
+          if (RSTRING_PTR(str)[0] == '-') { /* first element */
+            RSTRING_PTR(str)[0] = '#';
+            mrb_str_cat2(mrb, str, " ");
+          }
+          else {
+            mrb_str_cat2(mrb, str, ", ");
+          }
+          mrb_str_cat2(mrb, str, mrb_sym2name(mrb, id));
+          mrb_str_cat2(mrb, str, "=");
+          mrb_str_append(mrb, str, mrb_inspect(mrb, value));
+        }
       }
     }
   }
@@ -398,7 +398,7 @@ init_copy(mrb_state *mrb, mrb_value dest, mrb_value obj)
             ROBJECT(dest)->iv = ROBJECT(obj)->iv;
         }
         break;
-      
+
       default:
         break;
     }
@@ -795,13 +795,13 @@ mrb_obj_instance_variables(mrb_state *mrb, mrb_value self)
     ary = mrb_ary_new(mrb);
     if (h) {
       for (i=0;i<kh_end(h);i++) {
-	if (kh_exist(h, i)) {
+        if (kh_exist(h, i)) {
           p = mrb_sym2name(mrb, kh_key(h,i));
           if (*p == '@') {
             if (mrb_type(kh_value(h, i)) != MRB_TT_UNDEF)
               mrb_ary_push(mrb, ary, mrb_str_new_cstr(mrb, p));
           }
-	}
+        }
       }
     }
     return ary;
diff --git a/src/load.c b/src/load.c
index 3b62a0e7a..23b647ab6 100644
--- a/src/load.c
+++ b/src/load.c
@@ -1,6 +1,6 @@
 /*
 ** load.c - mruby binary loader
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -412,12 +412,12 @@ read_rite_irep_record(mrb_state *mrb, unsigned char *src, mrb_irep *irep, uint32
 
       switch (tt) {                           //pool data
       case MRB_TT_FIXNUM:
-	fix_num = readint(buf, 10);
+        fix_num = readint(buf, 10);
         irep->pool[i] = mrb_fixnum_value(fix_num);
         break;
 
       case MRB_TT_FLOAT:
-	f = readfloat(buf);
+        f = readfloat(buf);
         irep->pool[i] = mrb_float_value(f);
         break;
 
diff --git a/src/method.h b/src/method.h
index 0856ffa8b..9d917cae4 100644
--- a/src/method.h
+++ b/src/method.h
@@ -1,6 +1,6 @@
 /*
 ** method.h - method structures and functions
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/minimain.c b/src/minimain.c
index 3ba5bb0b3..ffaaf0d0b 100644
--- a/src/minimain.c
+++ b/src/minimain.c
@@ -1,6 +1,6 @@
 /*
-** minimain.c - 
-** 
+** minimain.c -
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -71,21 +71,21 @@ main(int argc, char **argv)
   n = 0;
 
   fib_iseq[n++] = MKOP_AB(OP_MOVE, 2, 1);        /* r2 := r1 */
-  fib_iseq[n++] = MKOP_AsBx(OP_LOADI, 3, 3);	 /* r3 := 2 */
-  fib_iseq[n++] = MKOP_ABC(OP_LT, 2, 0, 2);	 /* r2 .< r3 */
-  fib_iseq[n++] = MKOP_AsBx(OP_JMPNOT, 2, 2);	 /* ifnot r2 :else */
-  fib_iseq[n++] = MKOP_AsBx(OP_LOADI, 2, 1);	 /* r6 := 1 */
-  fib_iseq[n++] = MKOP_A(OP_RETURN, 2);		 /* return r2 */
-  fib_iseq[n++] = MKOP_AB(OP_MOVE, 3, 0);	 /* r3 := r0  :else */
-  fib_iseq[n++] = MKOP_AB(OP_MOVE, 4, 1);	 /* r4 := r1 */
-  fib_iseq[n++] = MKOP_ABC(OP_SUBI, 4, 1, 2);	 /* r4 .- 2 */
-  fib_iseq[n++] = MKOP_ABC(OP_SEND, 3, 3, 1);	 /* r3 .fib r4 */
-  fib_iseq[n++] = MKOP_AB(OP_MOVE, 4, 0);	 /* r4 := r0 */
-  fib_iseq[n++] = MKOP_AB(OP_MOVE, 5, 1);	 /* r5 := r1 */
-  fib_iseq[n++] = MKOP_ABC(OP_SUBI, 5, 1, 1);	 /* r5 .- 1 */
-  fib_iseq[n++] = MKOP_ABC(OP_SEND, 4, 3, 1);	 /* r4 .fib :r5 */
-  fib_iseq[n++] = MKOP_ABC(OP_ADD, 3, 2, 1);	 /* r3 .+ r4 */
-  fib_iseq[n++] = MKOP_A(OP_RETURN, 3);		 /* return r3 */
+  fib_iseq[n++] = MKOP_AsBx(OP_LOADI, 3, 3);     /* r3 := 2 */
+  fib_iseq[n++] = MKOP_ABC(OP_LT, 2, 0, 2);      /* r2 .< r3 */
+  fib_iseq[n++] = MKOP_AsBx(OP_JMPNOT, 2, 2);    /* ifnot r2 :else */
+  fib_iseq[n++] = MKOP_AsBx(OP_LOADI, 2, 1);     /* r6 := 1 */
+  fib_iseq[n++] = MKOP_A(OP_RETURN, 2);          /* return r2 */
+  fib_iseq[n++] = MKOP_AB(OP_MOVE, 3, 0);        /* r3 := r0  :else */
+  fib_iseq[n++] = MKOP_AB(OP_MOVE, 4, 1);        /* r4 := r1 */
+  fib_iseq[n++] = MKOP_ABC(OP_SUBI, 4, 1, 2);    /* r4 .- 2 */
+  fib_iseq[n++] = MKOP_ABC(OP_SEND, 3, 3, 1);    /* r3 .fib r4 */
+  fib_iseq[n++] = MKOP_AB(OP_MOVE, 4, 0);        /* r4 := r0 */
+  fib_iseq[n++] = MKOP_AB(OP_MOVE, 5, 1);        /* r5 := r1 */
+  fib_iseq[n++] = MKOP_ABC(OP_SUBI, 5, 1, 1);    /* r5 .- 1 */
+  fib_iseq[n++] = MKOP_ABC(OP_SEND, 4, 3, 1);    /* r4 .fib :r5 */
+  fib_iseq[n++] = MKOP_ABC(OP_ADD, 3, 2, 1);     /* r3 .+ r4 */
+  fib_iseq[n++] = MKOP_A(OP_RETURN, 3);          /* return r3 */
   fib_irep.ilen = n;
   fib_irep.idx  = sirep+1;
 
diff --git a/src/name2ctype.h b/src/name2ctype.h
index 2248b8f7c..a62124fc4 100644
--- a/src/name2ctype.h
+++ b/src/name2ctype.h
@@ -39,14081 +39,14081 @@ error "gperf generated tables don't work with this execution character set. Plea
 #ifdef USE_UNICODE_PROPERTIES
 /* 'Any': - */
 static const OnigCodePoint CR_Any[] = {
-	1,
-	0x0000, 0x10ffff,
+        1,
+        0x0000, 0x10ffff,
 }; /* CR_Any */
 
 /* 'Assigned': - */
 static const OnigCodePoint CR_Assigned[] = {
-	485,
-	0x0000, 0x0377,
-	0x037a, 0x037e,
-	0x0384, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x03a1,
-	0x03a3, 0x0525,
-	0x0531, 0x0556,
-	0x0559, 0x055f,
-	0x0561, 0x0587,
-	0x0589, 0x058a,
-	0x0591, 0x05c7,
-	0x05d0, 0x05ea,
-	0x05f0, 0x05f4,
-	0x0600, 0x0603,
-	0x0606, 0x061b,
-	0x061e, 0x061f,
-	0x0621, 0x065e,
-	0x0660, 0x070d,
-	0x070f, 0x074a,
-	0x074d, 0x07b1,
-	0x07c0, 0x07fa,
-	0x0800, 0x082d,
-	0x0830, 0x083e,
-	0x0900, 0x0939,
-	0x093c, 0x094e,
-	0x0950, 0x0955,
-	0x0958, 0x0972,
-	0x0979, 0x097f,
-	0x0981, 0x0983,
-	0x0985, 0x098c,
-	0x098f, 0x0990,
-	0x0993, 0x09a8,
-	0x09aa, 0x09b0,
-	0x09b2, 0x09b2,
-	0x09b6, 0x09b9,
-	0x09bc, 0x09c4,
-	0x09c7, 0x09c8,
-	0x09cb, 0x09ce,
-	0x09d7, 0x09d7,
-	0x09dc, 0x09dd,
-	0x09df, 0x09e3,
-	0x09e6, 0x09fb,
-	0x0a01, 0x0a03,
-	0x0a05, 0x0a0a,
-	0x0a0f, 0x0a10,
-	0x0a13, 0x0a28,
-	0x0a2a, 0x0a30,
-	0x0a32, 0x0a33,
-	0x0a35, 0x0a36,
-	0x0a38, 0x0a39,
-	0x0a3c, 0x0a3c,
-	0x0a3e, 0x0a42,
-	0x0a47, 0x0a48,
-	0x0a4b, 0x0a4d,
-	0x0a51, 0x0a51,
-	0x0a59, 0x0a5c,
-	0x0a5e, 0x0a5e,
-	0x0a66, 0x0a75,
-	0x0a81, 0x0a83,
-	0x0a85, 0x0a8d,
-	0x0a8f, 0x0a91,
-	0x0a93, 0x0aa8,
-	0x0aaa, 0x0ab0,
-	0x0ab2, 0x0ab3,
-	0x0ab5, 0x0ab9,
-	0x0abc, 0x0ac5,
-	0x0ac7, 0x0ac9,
-	0x0acb, 0x0acd,
-	0x0ad0, 0x0ad0,
-	0x0ae0, 0x0ae3,
-	0x0ae6, 0x0aef,
-	0x0af1, 0x0af1,
-	0x0b01, 0x0b03,
-	0x0b05, 0x0b0c,
-	0x0b0f, 0x0b10,
-	0x0b13, 0x0b28,
-	0x0b2a, 0x0b30,
-	0x0b32, 0x0b33,
-	0x0b35, 0x0b39,
-	0x0b3c, 0x0b44,
-	0x0b47, 0x0b48,
-	0x0b4b, 0x0b4d,
-	0x0b56, 0x0b57,
-	0x0b5c, 0x0b5d,
-	0x0b5f, 0x0b63,
-	0x0b66, 0x0b71,
-	0x0b82, 0x0b83,
-	0x0b85, 0x0b8a,
-	0x0b8e, 0x0b90,
-	0x0b92, 0x0b95,
-	0x0b99, 0x0b9a,
-	0x0b9c, 0x0b9c,
-	0x0b9e, 0x0b9f,
-	0x0ba3, 0x0ba4,
-	0x0ba8, 0x0baa,
-	0x0bae, 0x0bb9,
-	0x0bbe, 0x0bc2,
-	0x0bc6, 0x0bc8,
-	0x0bca, 0x0bcd,
-	0x0bd0, 0x0bd0,
-	0x0bd7, 0x0bd7,
-	0x0be6, 0x0bfa,
-	0x0c01, 0x0c03,
-	0x0c05, 0x0c0c,
-	0x0c0e, 0x0c10,
-	0x0c12, 0x0c28,
-	0x0c2a, 0x0c33,
-	0x0c35, 0x0c39,
-	0x0c3d, 0x0c44,
-	0x0c46, 0x0c48,
-	0x0c4a, 0x0c4d,
-	0x0c55, 0x0c56,
-	0x0c58, 0x0c59,
-	0x0c60, 0x0c63,
-	0x0c66, 0x0c6f,
-	0x0c78, 0x0c7f,
-	0x0c82, 0x0c83,
-	0x0c85, 0x0c8c,
-	0x0c8e, 0x0c90,
-	0x0c92, 0x0ca8,
-	0x0caa, 0x0cb3,
-	0x0cb5, 0x0cb9,
-	0x0cbc, 0x0cc4,
-	0x0cc6, 0x0cc8,
-	0x0cca, 0x0ccd,
-	0x0cd5, 0x0cd6,
-	0x0cde, 0x0cde,
-	0x0ce0, 0x0ce3,
-	0x0ce6, 0x0cef,
-	0x0cf1, 0x0cf2,
-	0x0d02, 0x0d03,
-	0x0d05, 0x0d0c,
-	0x0d0e, 0x0d10,
-	0x0d12, 0x0d28,
-	0x0d2a, 0x0d39,
-	0x0d3d, 0x0d44,
-	0x0d46, 0x0d48,
-	0x0d4a, 0x0d4d,
-	0x0d57, 0x0d57,
-	0x0d60, 0x0d63,
-	0x0d66, 0x0d75,
-	0x0d79, 0x0d7f,
-	0x0d82, 0x0d83,
-	0x0d85, 0x0d96,
-	0x0d9a, 0x0db1,
-	0x0db3, 0x0dbb,
-	0x0dbd, 0x0dbd,
-	0x0dc0, 0x0dc6,
-	0x0dca, 0x0dca,
-	0x0dcf, 0x0dd4,
-	0x0dd6, 0x0dd6,
-	0x0dd8, 0x0ddf,
-	0x0df2, 0x0df4,
-	0x0e01, 0x0e3a,
-	0x0e3f, 0x0e5b,
-	0x0e81, 0x0e82,
-	0x0e84, 0x0e84,
-	0x0e87, 0x0e88,
-	0x0e8a, 0x0e8a,
-	0x0e8d, 0x0e8d,
-	0x0e94, 0x0e97,
-	0x0e99, 0x0e9f,
-	0x0ea1, 0x0ea3,
-	0x0ea5, 0x0ea5,
-	0x0ea7, 0x0ea7,
-	0x0eaa, 0x0eab,
-	0x0ead, 0x0eb9,
-	0x0ebb, 0x0ebd,
-	0x0ec0, 0x0ec4,
-	0x0ec6, 0x0ec6,
-	0x0ec8, 0x0ecd,
-	0x0ed0, 0x0ed9,
-	0x0edc, 0x0edd,
-	0x0f00, 0x0f47,
-	0x0f49, 0x0f6c,
-	0x0f71, 0x0f8b,
-	0x0f90, 0x0f97,
-	0x0f99, 0x0fbc,
-	0x0fbe, 0x0fcc,
-	0x0fce, 0x0fd8,
-	0x1000, 0x10c5,
-	0x10d0, 0x10fc,
-	0x1100, 0x1248,
-	0x124a, 0x124d,
-	0x1250, 0x1256,
-	0x1258, 0x1258,
-	0x125a, 0x125d,
-	0x1260, 0x1288,
-	0x128a, 0x128d,
-	0x1290, 0x12b0,
-	0x12b2, 0x12b5,
-	0x12b8, 0x12be,
-	0x12c0, 0x12c0,
-	0x12c2, 0x12c5,
-	0x12c8, 0x12d6,
-	0x12d8, 0x1310,
-	0x1312, 0x1315,
-	0x1318, 0x135a,
-	0x135f, 0x137c,
-	0x1380, 0x1399,
-	0x13a0, 0x13f4,
-	0x1400, 0x169c,
-	0x16a0, 0x16f0,
-	0x1700, 0x170c,
-	0x170e, 0x1714,
-	0x1720, 0x1736,
-	0x1740, 0x1753,
-	0x1760, 0x176c,
-	0x176e, 0x1770,
-	0x1772, 0x1773,
-	0x1780, 0x17dd,
-	0x17e0, 0x17e9,
-	0x17f0, 0x17f9,
-	0x1800, 0x180e,
-	0x1810, 0x1819,
-	0x1820, 0x1877,
-	0x1880, 0x18aa,
-	0x18b0, 0x18f5,
-	0x1900, 0x191c,
-	0x1920, 0x192b,
-	0x1930, 0x193b,
-	0x1940, 0x1940,
-	0x1944, 0x196d,
-	0x1970, 0x1974,
-	0x1980, 0x19ab,
-	0x19b0, 0x19c9,
-	0x19d0, 0x19da,
-	0x19de, 0x1a1b,
-	0x1a1e, 0x1a5e,
-	0x1a60, 0x1a7c,
-	0x1a7f, 0x1a89,
-	0x1a90, 0x1a99,
-	0x1aa0, 0x1aad,
-	0x1b00, 0x1b4b,
-	0x1b50, 0x1b7c,
-	0x1b80, 0x1baa,
-	0x1bae, 0x1bb9,
-	0x1c00, 0x1c37,
-	0x1c3b, 0x1c49,
-	0x1c4d, 0x1c7f,
-	0x1cd0, 0x1cf2,
-	0x1d00, 0x1de6,
-	0x1dfd, 0x1f15,
-	0x1f18, 0x1f1d,
-	0x1f20, 0x1f45,
-	0x1f48, 0x1f4d,
-	0x1f50, 0x1f57,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f7d,
-	0x1f80, 0x1fb4,
-	0x1fb6, 0x1fc4,
-	0x1fc6, 0x1fd3,
-	0x1fd6, 0x1fdb,
-	0x1fdd, 0x1fef,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ffe,
-	0x2000, 0x2064,
-	0x206a, 0x2071,
-	0x2074, 0x208e,
-	0x2090, 0x2094,
-	0x20a0, 0x20b8,
-	0x20d0, 0x20f0,
-	0x2100, 0x2189,
-	0x2190, 0x23e8,
-	0x2400, 0x2426,
-	0x2440, 0x244a,
-	0x2460, 0x26cd,
-	0x26cf, 0x26e1,
-	0x26e3, 0x26e3,
-	0x26e8, 0x26ff,
-	0x2701, 0x2704,
-	0x2706, 0x2709,
-	0x270c, 0x2727,
-	0x2729, 0x274b,
-	0x274d, 0x274d,
-	0x274f, 0x2752,
-	0x2756, 0x275e,
-	0x2761, 0x2794,
-	0x2798, 0x27af,
-	0x27b1, 0x27be,
-	0x27c0, 0x27ca,
-	0x27cc, 0x27cc,
-	0x27d0, 0x2b4c,
-	0x2b50, 0x2b59,
-	0x2c00, 0x2c2e,
-	0x2c30, 0x2c5e,
-	0x2c60, 0x2cf1,
-	0x2cf9, 0x2d25,
-	0x2d30, 0x2d65,
-	0x2d6f, 0x2d6f,
-	0x2d80, 0x2d96,
-	0x2da0, 0x2da6,
-	0x2da8, 0x2dae,
-	0x2db0, 0x2db6,
-	0x2db8, 0x2dbe,
-	0x2dc0, 0x2dc6,
-	0x2dc8, 0x2dce,
-	0x2dd0, 0x2dd6,
-	0x2dd8, 0x2dde,
-	0x2de0, 0x2e31,
-	0x2e80, 0x2e99,
-	0x2e9b, 0x2ef3,
-	0x2f00, 0x2fd5,
-	0x2ff0, 0x2ffb,
-	0x3000, 0x303f,
-	0x3041, 0x3096,
-	0x3099, 0x30ff,
-	0x3105, 0x312d,
-	0x3131, 0x318e,
-	0x3190, 0x31b7,
-	0x31c0, 0x31e3,
-	0x31f0, 0x321e,
-	0x3220, 0x32fe,
-	0x3300, 0x4db5,
-	0x4dc0, 0x9fcb,
-	0xa000, 0xa48c,
-	0xa490, 0xa4c6,
-	0xa4d0, 0xa62b,
-	0xa640, 0xa65f,
-	0xa662, 0xa673,
-	0xa67c, 0xa697,
-	0xa6a0, 0xa6f7,
-	0xa700, 0xa78c,
-	0xa7fb, 0xa82b,
-	0xa830, 0xa839,
-	0xa840, 0xa877,
-	0xa880, 0xa8c4,
-	0xa8ce, 0xa8d9,
-	0xa8e0, 0xa8fb,
-	0xa900, 0xa953,
-	0xa95f, 0xa97c,
-	0xa980, 0xa9cd,
-	0xa9cf, 0xa9d9,
-	0xa9de, 0xa9df,
-	0xaa00, 0xaa36,
-	0xaa40, 0xaa4d,
-	0xaa50, 0xaa59,
-	0xaa5c, 0xaa7b,
-	0xaa80, 0xaac2,
-	0xaadb, 0xaadf,
-	0xabc0, 0xabed,
-	0xabf0, 0xabf9,
-	0xac00, 0xd7a3,
-	0xd7b0, 0xd7c6,
-	0xd7cb, 0xd7fb,
-	0xd800, 0xfa2d,
-	0xfa30, 0xfa6d,
-	0xfa70, 0xfad9,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xfb1d, 0xfb36,
-	0xfb38, 0xfb3c,
-	0xfb3e, 0xfb3e,
-	0xfb40, 0xfb41,
-	0xfb43, 0xfb44,
-	0xfb46, 0xfbb1,
-	0xfbd3, 0xfd3f,
-	0xfd50, 0xfd8f,
-	0xfd92, 0xfdc7,
-	0xfdf0, 0xfdfd,
-	0xfe00, 0xfe19,
-	0xfe20, 0xfe26,
-	0xfe30, 0xfe52,
-	0xfe54, 0xfe66,
-	0xfe68, 0xfe6b,
-	0xfe70, 0xfe74,
-	0xfe76, 0xfefc,
-	0xfeff, 0xfeff,
-	0xff01, 0xffbe,
-	0xffc2, 0xffc7,
-	0xffca, 0xffcf,
-	0xffd2, 0xffd7,
-	0xffda, 0xffdc,
-	0xffe0, 0xffe6,
-	0xffe8, 0xffee,
-	0xfff9, 0xfffd,
-	0x10000, 0x1000b,
-	0x1000d, 0x10026,
-	0x10028, 0x1003a,
-	0x1003c, 0x1003d,
-	0x1003f, 0x1004d,
-	0x10050, 0x1005d,
-	0x10080, 0x100fa,
-	0x10100, 0x10102,
-	0x10107, 0x10133,
-	0x10137, 0x1018a,
-	0x10190, 0x1019b,
-	0x101d0, 0x101fd,
-	0x10280, 0x1029c,
-	0x102a0, 0x102d0,
-	0x10300, 0x1031e,
-	0x10320, 0x10323,
-	0x10330, 0x1034a,
-	0x10380, 0x1039d,
-	0x1039f, 0x103c3,
-	0x103c8, 0x103d5,
-	0x10400, 0x1049d,
-	0x104a0, 0x104a9,
-	0x10800, 0x10805,
-	0x10808, 0x10808,
-	0x1080a, 0x10835,
-	0x10837, 0x10838,
-	0x1083c, 0x1083c,
-	0x1083f, 0x10855,
-	0x10857, 0x1085f,
-	0x10900, 0x1091b,
-	0x1091f, 0x10939,
-	0x1093f, 0x1093f,
-	0x10a00, 0x10a03,
-	0x10a05, 0x10a06,
-	0x10a0c, 0x10a13,
-	0x10a15, 0x10a17,
-	0x10a19, 0x10a33,
-	0x10a38, 0x10a3a,
-	0x10a3f, 0x10a47,
-	0x10a50, 0x10a58,
-	0x10a60, 0x10a7f,
-	0x10b00, 0x10b35,
-	0x10b39, 0x10b55,
-	0x10b58, 0x10b72,
-	0x10b78, 0x10b7f,
-	0x10c00, 0x10c48,
-	0x10e60, 0x10e7e,
-	0x11080, 0x110c1,
-	0x12000, 0x1236e,
-	0x12400, 0x12462,
-	0x12470, 0x12473,
-	0x13000, 0x1342e,
-	0x1d000, 0x1d0f5,
-	0x1d100, 0x1d126,
-	0x1d129, 0x1d1dd,
-	0x1d200, 0x1d245,
-	0x1d300, 0x1d356,
-	0x1d360, 0x1d371,
-	0x1d400, 0x1d454,
-	0x1d456, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d51e, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d552, 0x1d6a5,
-	0x1d6a8, 0x1d7cb,
-	0x1d7ce, 0x1d7ff,
-	0x1f000, 0x1f02b,
-	0x1f030, 0x1f093,
-	0x1f100, 0x1f10a,
-	0x1f110, 0x1f12e,
-	0x1f131, 0x1f131,
-	0x1f13d, 0x1f13d,
-	0x1f13f, 0x1f13f,
-	0x1f142, 0x1f142,
-	0x1f146, 0x1f146,
-	0x1f14a, 0x1f14e,
-	0x1f157, 0x1f157,
-	0x1f15f, 0x1f15f,
-	0x1f179, 0x1f179,
-	0x1f17b, 0x1f17c,
-	0x1f17f, 0x1f17f,
-	0x1f18a, 0x1f18d,
-	0x1f190, 0x1f190,
-	0x1f200, 0x1f200,
-	0x1f210, 0x1f231,
-	0x1f240, 0x1f248,
-	0x20000, 0x2a6d6,
-	0x2a700, 0x2b734,
-	0x2f800, 0x2fa1d,
-	0xe0001, 0xe0001,
-	0xe0020, 0xe007f,
-	0xe0100, 0xe01ef,
-	0xf0000, 0xffffd,
-	0x100000, 0x10fffd,
+        485,
+        0x0000, 0x0377,
+        0x037a, 0x037e,
+        0x0384, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x03a1,
+        0x03a3, 0x0525,
+        0x0531, 0x0556,
+        0x0559, 0x055f,
+        0x0561, 0x0587,
+        0x0589, 0x058a,
+        0x0591, 0x05c7,
+        0x05d0, 0x05ea,
+        0x05f0, 0x05f4,
+        0x0600, 0x0603,
+        0x0606, 0x061b,
+        0x061e, 0x061f,
+        0x0621, 0x065e,
+        0x0660, 0x070d,
+        0x070f, 0x074a,
+        0x074d, 0x07b1,
+        0x07c0, 0x07fa,
+        0x0800, 0x082d,
+        0x0830, 0x083e,
+        0x0900, 0x0939,
+        0x093c, 0x094e,
+        0x0950, 0x0955,
+        0x0958, 0x0972,
+        0x0979, 0x097f,
+        0x0981, 0x0983,
+        0x0985, 0x098c,
+        0x098f, 0x0990,
+        0x0993, 0x09a8,
+        0x09aa, 0x09b0,
+        0x09b2, 0x09b2,
+        0x09b6, 0x09b9,
+        0x09bc, 0x09c4,
+        0x09c7, 0x09c8,
+        0x09cb, 0x09ce,
+        0x09d7, 0x09d7,
+        0x09dc, 0x09dd,
+        0x09df, 0x09e3,
+        0x09e6, 0x09fb,
+        0x0a01, 0x0a03,
+        0x0a05, 0x0a0a,
+        0x0a0f, 0x0a10,
+        0x0a13, 0x0a28,
+        0x0a2a, 0x0a30,
+        0x0a32, 0x0a33,
+        0x0a35, 0x0a36,
+        0x0a38, 0x0a39,
+        0x0a3c, 0x0a3c,
+        0x0a3e, 0x0a42,
+        0x0a47, 0x0a48,
+        0x0a4b, 0x0a4d,
+        0x0a51, 0x0a51,
+        0x0a59, 0x0a5c,
+        0x0a5e, 0x0a5e,
+        0x0a66, 0x0a75,
+        0x0a81, 0x0a83,
+        0x0a85, 0x0a8d,
+        0x0a8f, 0x0a91,
+        0x0a93, 0x0aa8,
+        0x0aaa, 0x0ab0,
+        0x0ab2, 0x0ab3,
+        0x0ab5, 0x0ab9,
+        0x0abc, 0x0ac5,
+        0x0ac7, 0x0ac9,
+        0x0acb, 0x0acd,
+        0x0ad0, 0x0ad0,
+        0x0ae0, 0x0ae3,
+        0x0ae6, 0x0aef,
+        0x0af1, 0x0af1,
+        0x0b01, 0x0b03,
+        0x0b05, 0x0b0c,
+        0x0b0f, 0x0b10,
+        0x0b13, 0x0b28,
+        0x0b2a, 0x0b30,
+        0x0b32, 0x0b33,
+        0x0b35, 0x0b39,
+        0x0b3c, 0x0b44,
+        0x0b47, 0x0b48,
+        0x0b4b, 0x0b4d,
+        0x0b56, 0x0b57,
+        0x0b5c, 0x0b5d,
+        0x0b5f, 0x0b63,
+        0x0b66, 0x0b71,
+        0x0b82, 0x0b83,
+        0x0b85, 0x0b8a,
+        0x0b8e, 0x0b90,
+        0x0b92, 0x0b95,
+        0x0b99, 0x0b9a,
+        0x0b9c, 0x0b9c,
+        0x0b9e, 0x0b9f,
+        0x0ba3, 0x0ba4,
+        0x0ba8, 0x0baa,
+        0x0bae, 0x0bb9,
+        0x0bbe, 0x0bc2,
+        0x0bc6, 0x0bc8,
+        0x0bca, 0x0bcd,
+        0x0bd0, 0x0bd0,
+        0x0bd7, 0x0bd7,
+        0x0be6, 0x0bfa,
+        0x0c01, 0x0c03,
+        0x0c05, 0x0c0c,
+        0x0c0e, 0x0c10,
+        0x0c12, 0x0c28,
+        0x0c2a, 0x0c33,
+        0x0c35, 0x0c39,
+        0x0c3d, 0x0c44,
+        0x0c46, 0x0c48,
+        0x0c4a, 0x0c4d,
+        0x0c55, 0x0c56,
+        0x0c58, 0x0c59,
+        0x0c60, 0x0c63,
+        0x0c66, 0x0c6f,
+        0x0c78, 0x0c7f,
+        0x0c82, 0x0c83,
+        0x0c85, 0x0c8c,
+        0x0c8e, 0x0c90,
+        0x0c92, 0x0ca8,
+        0x0caa, 0x0cb3,
+        0x0cb5, 0x0cb9,
+        0x0cbc, 0x0cc4,
+        0x0cc6, 0x0cc8,
+        0x0cca, 0x0ccd,
+        0x0cd5, 0x0cd6,
+        0x0cde, 0x0cde,
+        0x0ce0, 0x0ce3,
+        0x0ce6, 0x0cef,
+        0x0cf1, 0x0cf2,
+        0x0d02, 0x0d03,
+        0x0d05, 0x0d0c,
+        0x0d0e, 0x0d10,
+        0x0d12, 0x0d28,
+        0x0d2a, 0x0d39,
+        0x0d3d, 0x0d44,
+        0x0d46, 0x0d48,
+        0x0d4a, 0x0d4d,
+        0x0d57, 0x0d57,
+        0x0d60, 0x0d63,
+        0x0d66, 0x0d75,
+        0x0d79, 0x0d7f,
+        0x0d82, 0x0d83,
+        0x0d85, 0x0d96,
+        0x0d9a, 0x0db1,
+        0x0db3, 0x0dbb,
+        0x0dbd, 0x0dbd,
+        0x0dc0, 0x0dc6,
+        0x0dca, 0x0dca,
+        0x0dcf, 0x0dd4,
+        0x0dd6, 0x0dd6,
+        0x0dd8, 0x0ddf,
+        0x0df2, 0x0df4,
+        0x0e01, 0x0e3a,
+        0x0e3f, 0x0e5b,
+        0x0e81, 0x0e82,
+        0x0e84, 0x0e84,
+        0x0e87, 0x0e88,
+        0x0e8a, 0x0e8a,
+        0x0e8d, 0x0e8d,
+        0x0e94, 0x0e97,
+        0x0e99, 0x0e9f,
+        0x0ea1, 0x0ea3,
+        0x0ea5, 0x0ea5,
+        0x0ea7, 0x0ea7,
+        0x0eaa, 0x0eab,
+        0x0ead, 0x0eb9,
+        0x0ebb, 0x0ebd,
+        0x0ec0, 0x0ec4,
+        0x0ec6, 0x0ec6,
+        0x0ec8, 0x0ecd,
+        0x0ed0, 0x0ed9,
+        0x0edc, 0x0edd,
+        0x0f00, 0x0f47,
+        0x0f49, 0x0f6c,
+        0x0f71, 0x0f8b,
+        0x0f90, 0x0f97,
+        0x0f99, 0x0fbc,
+        0x0fbe, 0x0fcc,
+        0x0fce, 0x0fd8,
+        0x1000, 0x10c5,
+        0x10d0, 0x10fc,
+        0x1100, 0x1248,
+        0x124a, 0x124d,
+        0x1250, 0x1256,
+        0x1258, 0x1258,
+        0x125a, 0x125d,
+        0x1260, 0x1288,
+        0x128a, 0x128d,
+        0x1290, 0x12b0,
+        0x12b2, 0x12b5,
+        0x12b8, 0x12be,
+        0x12c0, 0x12c0,
+        0x12c2, 0x12c5,
+        0x12c8, 0x12d6,
+        0x12d8, 0x1310,
+        0x1312, 0x1315,
+        0x1318, 0x135a,
+        0x135f, 0x137c,
+        0x1380, 0x1399,
+        0x13a0, 0x13f4,
+        0x1400, 0x169c,
+        0x16a0, 0x16f0,
+        0x1700, 0x170c,
+        0x170e, 0x1714,
+        0x1720, 0x1736,
+        0x1740, 0x1753,
+        0x1760, 0x176c,
+        0x176e, 0x1770,
+        0x1772, 0x1773,
+        0x1780, 0x17dd,
+        0x17e0, 0x17e9,
+        0x17f0, 0x17f9,
+        0x1800, 0x180e,
+        0x1810, 0x1819,
+        0x1820, 0x1877,
+        0x1880, 0x18aa,
+        0x18b0, 0x18f5,
+        0x1900, 0x191c,
+        0x1920, 0x192b,
+        0x1930, 0x193b,
+        0x1940, 0x1940,
+        0x1944, 0x196d,
+        0x1970, 0x1974,
+        0x1980, 0x19ab,
+        0x19b0, 0x19c9,
+        0x19d0, 0x19da,
+        0x19de, 0x1a1b,
+        0x1a1e, 0x1a5e,
+        0x1a60, 0x1a7c,
+        0x1a7f, 0x1a89,
+        0x1a90, 0x1a99,
+        0x1aa0, 0x1aad,
+        0x1b00, 0x1b4b,
+        0x1b50, 0x1b7c,
+        0x1b80, 0x1baa,
+        0x1bae, 0x1bb9,
+        0x1c00, 0x1c37,
+        0x1c3b, 0x1c49,
+        0x1c4d, 0x1c7f,
+        0x1cd0, 0x1cf2,
+        0x1d00, 0x1de6,
+        0x1dfd, 0x1f15,
+        0x1f18, 0x1f1d,
+        0x1f20, 0x1f45,
+        0x1f48, 0x1f4d,
+        0x1f50, 0x1f57,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f7d,
+        0x1f80, 0x1fb4,
+        0x1fb6, 0x1fc4,
+        0x1fc6, 0x1fd3,
+        0x1fd6, 0x1fdb,
+        0x1fdd, 0x1fef,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ffe,
+        0x2000, 0x2064,
+        0x206a, 0x2071,
+        0x2074, 0x208e,
+        0x2090, 0x2094,
+        0x20a0, 0x20b8,
+        0x20d0, 0x20f0,
+        0x2100, 0x2189,
+        0x2190, 0x23e8,
+        0x2400, 0x2426,
+        0x2440, 0x244a,
+        0x2460, 0x26cd,
+        0x26cf, 0x26e1,
+        0x26e3, 0x26e3,
+        0x26e8, 0x26ff,
+        0x2701, 0x2704,
+        0x2706, 0x2709,
+        0x270c, 0x2727,
+        0x2729, 0x274b,
+        0x274d, 0x274d,
+        0x274f, 0x2752,
+        0x2756, 0x275e,
+        0x2761, 0x2794,
+        0x2798, 0x27af,
+        0x27b1, 0x27be,
+        0x27c0, 0x27ca,
+        0x27cc, 0x27cc,
+        0x27d0, 0x2b4c,
+        0x2b50, 0x2b59,
+        0x2c00, 0x2c2e,
+        0x2c30, 0x2c5e,
+        0x2c60, 0x2cf1,
+        0x2cf9, 0x2d25,
+        0x2d30, 0x2d65,
+        0x2d6f, 0x2d6f,
+        0x2d80, 0x2d96,
+        0x2da0, 0x2da6,
+        0x2da8, 0x2dae,
+        0x2db0, 0x2db6,
+        0x2db8, 0x2dbe,
+        0x2dc0, 0x2dc6,
+        0x2dc8, 0x2dce,
+        0x2dd0, 0x2dd6,
+        0x2dd8, 0x2dde,
+        0x2de0, 0x2e31,
+        0x2e80, 0x2e99,
+        0x2e9b, 0x2ef3,
+        0x2f00, 0x2fd5,
+        0x2ff0, 0x2ffb,
+        0x3000, 0x303f,
+        0x3041, 0x3096,
+        0x3099, 0x30ff,
+        0x3105, 0x312d,
+        0x3131, 0x318e,
+        0x3190, 0x31b7,
+        0x31c0, 0x31e3,
+        0x31f0, 0x321e,
+        0x3220, 0x32fe,
+        0x3300, 0x4db5,
+        0x4dc0, 0x9fcb,
+        0xa000, 0xa48c,
+        0xa490, 0xa4c6,
+        0xa4d0, 0xa62b,
+        0xa640, 0xa65f,
+        0xa662, 0xa673,
+        0xa67c, 0xa697,
+        0xa6a0, 0xa6f7,
+        0xa700, 0xa78c,
+        0xa7fb, 0xa82b,
+        0xa830, 0xa839,
+        0xa840, 0xa877,
+        0xa880, 0xa8c4,
+        0xa8ce, 0xa8d9,
+        0xa8e0, 0xa8fb,
+        0xa900, 0xa953,
+        0xa95f, 0xa97c,
+        0xa980, 0xa9cd,
+        0xa9cf, 0xa9d9,
+        0xa9de, 0xa9df,
+        0xaa00, 0xaa36,
+        0xaa40, 0xaa4d,
+        0xaa50, 0xaa59,
+        0xaa5c, 0xaa7b,
+        0xaa80, 0xaac2,
+        0xaadb, 0xaadf,
+        0xabc0, 0xabed,
+        0xabf0, 0xabf9,
+        0xac00, 0xd7a3,
+        0xd7b0, 0xd7c6,
+        0xd7cb, 0xd7fb,
+        0xd800, 0xfa2d,
+        0xfa30, 0xfa6d,
+        0xfa70, 0xfad9,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xfb1d, 0xfb36,
+        0xfb38, 0xfb3c,
+        0xfb3e, 0xfb3e,
+        0xfb40, 0xfb41,
+        0xfb43, 0xfb44,
+        0xfb46, 0xfbb1,
+        0xfbd3, 0xfd3f,
+        0xfd50, 0xfd8f,
+        0xfd92, 0xfdc7,
+        0xfdf0, 0xfdfd,
+        0xfe00, 0xfe19,
+        0xfe20, 0xfe26,
+        0xfe30, 0xfe52,
+        0xfe54, 0xfe66,
+        0xfe68, 0xfe6b,
+        0xfe70, 0xfe74,
+        0xfe76, 0xfefc,
+        0xfeff, 0xfeff,
+        0xff01, 0xffbe,
+        0xffc2, 0xffc7,
+        0xffca, 0xffcf,
+        0xffd2, 0xffd7,
+        0xffda, 0xffdc,
+        0xffe0, 0xffe6,
+        0xffe8, 0xffee,
+        0xfff9, 0xfffd,
+        0x10000, 0x1000b,
+        0x1000d, 0x10026,
+        0x10028, 0x1003a,
+        0x1003c, 0x1003d,
+        0x1003f, 0x1004d,
+        0x10050, 0x1005d,
+        0x10080, 0x100fa,
+        0x10100, 0x10102,
+        0x10107, 0x10133,
+        0x10137, 0x1018a,
+        0x10190, 0x1019b,
+        0x101d0, 0x101fd,
+        0x10280, 0x1029c,
+        0x102a0, 0x102d0,
+        0x10300, 0x1031e,
+        0x10320, 0x10323,
+        0x10330, 0x1034a,
+        0x10380, 0x1039d,
+        0x1039f, 0x103c3,
+        0x103c8, 0x103d5,
+        0x10400, 0x1049d,
+        0x104a0, 0x104a9,
+        0x10800, 0x10805,
+        0x10808, 0x10808,
+        0x1080a, 0x10835,
+        0x10837, 0x10838,
+        0x1083c, 0x1083c,
+        0x1083f, 0x10855,
+        0x10857, 0x1085f,
+        0x10900, 0x1091b,
+        0x1091f, 0x10939,
+        0x1093f, 0x1093f,
+        0x10a00, 0x10a03,
+        0x10a05, 0x10a06,
+        0x10a0c, 0x10a13,
+        0x10a15, 0x10a17,
+        0x10a19, 0x10a33,
+        0x10a38, 0x10a3a,
+        0x10a3f, 0x10a47,
+        0x10a50, 0x10a58,
+        0x10a60, 0x10a7f,
+        0x10b00, 0x10b35,
+        0x10b39, 0x10b55,
+        0x10b58, 0x10b72,
+        0x10b78, 0x10b7f,
+        0x10c00, 0x10c48,
+        0x10e60, 0x10e7e,
+        0x11080, 0x110c1,
+        0x12000, 0x1236e,
+        0x12400, 0x12462,
+        0x12470, 0x12473,
+        0x13000, 0x1342e,
+        0x1d000, 0x1d0f5,
+        0x1d100, 0x1d126,
+        0x1d129, 0x1d1dd,
+        0x1d200, 0x1d245,
+        0x1d300, 0x1d356,
+        0x1d360, 0x1d371,
+        0x1d400, 0x1d454,
+        0x1d456, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d51e, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d552, 0x1d6a5,
+        0x1d6a8, 0x1d7cb,
+        0x1d7ce, 0x1d7ff,
+        0x1f000, 0x1f02b,
+        0x1f030, 0x1f093,
+        0x1f100, 0x1f10a,
+        0x1f110, 0x1f12e,
+        0x1f131, 0x1f131,
+        0x1f13d, 0x1f13d,
+        0x1f13f, 0x1f13f,
+        0x1f142, 0x1f142,
+        0x1f146, 0x1f146,
+        0x1f14a, 0x1f14e,
+        0x1f157, 0x1f157,
+        0x1f15f, 0x1f15f,
+        0x1f179, 0x1f179,
+        0x1f17b, 0x1f17c,
+        0x1f17f, 0x1f17f,
+        0x1f18a, 0x1f18d,
+        0x1f190, 0x1f190,
+        0x1f200, 0x1f200,
+        0x1f210, 0x1f231,
+        0x1f240, 0x1f248,
+        0x20000, 0x2a6d6,
+        0x2a700, 0x2b734,
+        0x2f800, 0x2fa1d,
+        0xe0001, 0xe0001,
+        0xe0020, 0xe007f,
+        0xe0100, 0xe01ef,
+        0xf0000, 0xffffd,
+        0x100000, 0x10fffd,
 }; /* CR_Assigned */
 
 /* 'C': Major Category */
 static const OnigCodePoint CR_C[] = {
-	20,
-	0x0000, 0x001f,
-	0x007f, 0x009f,
-	0x00ad, 0x00ad,
-	0x0600, 0x0603,
-	0x06dd, 0x06dd,
-	0x070f, 0x070f,
-	0x17b4, 0x17b5,
-	0x200b, 0x200f,
-	0x202a, 0x202e,
-	0x2060, 0x2064,
-	0x206a, 0x206f,
-	0xd800, 0xf8ff,
-	0xfeff, 0xfeff,
-	0xfff9, 0xfffb,
-	0x110bd, 0x110bd,
-	0x1d173, 0x1d17a,
-	0xe0001, 0xe0001,
-	0xe0020, 0xe007f,
-	0xf0000, 0xffffd,
-	0x100000, 0x10ffff,
+        20,
+        0x0000, 0x001f,
+        0x007f, 0x009f,
+        0x00ad, 0x00ad,
+        0x0600, 0x0603,
+        0x06dd, 0x06dd,
+        0x070f, 0x070f,
+        0x17b4, 0x17b5,
+        0x200b, 0x200f,
+        0x202a, 0x202e,
+        0x2060, 0x2064,
+        0x206a, 0x206f,
+        0xd800, 0xf8ff,
+        0xfeff, 0xfeff,
+        0xfff9, 0xfffb,
+        0x110bd, 0x110bd,
+        0x1d173, 0x1d17a,
+        0xe0001, 0xe0001,
+        0xe0020, 0xe007f,
+        0xf0000, 0xffffd,
+        0x100000, 0x10ffff,
 }; /* CR_C */
 
 /* 'Cc': General Category */
 static const OnigCodePoint CR_Cc[] = {
-	2,
-	0x0000, 0x001f,
-	0x007f, 0x009f,
+        2,
+        0x0000, 0x001f,
+        0x007f, 0x009f,
 }; /* CR_Cc */
 
 /* 'Cf': General Category */
 static const OnigCodePoint CR_Cf[] = {
-	15,
-	0x00ad, 0x00ad,
-	0x0600, 0x0603,
-	0x06dd, 0x06dd,
-	0x070f, 0x070f,
-	0x17b4, 0x17b5,
-	0x200b, 0x200f,
-	0x202a, 0x202e,
-	0x2060, 0x2064,
-	0x206a, 0x206f,
-	0xfeff, 0xfeff,
-	0xfff9, 0xfffb,
-	0x110bd, 0x110bd,
-	0x1d173, 0x1d17a,
-	0xe0001, 0xe0001,
-	0xe0020, 0xe007f,
+        15,
+        0x00ad, 0x00ad,
+        0x0600, 0x0603,
+        0x06dd, 0x06dd,
+        0x070f, 0x070f,
+        0x17b4, 0x17b5,
+        0x200b, 0x200f,
+        0x202a, 0x202e,
+        0x2060, 0x2064,
+        0x206a, 0x206f,
+        0xfeff, 0xfeff,
+        0xfff9, 0xfffb,
+        0x110bd, 0x110bd,
+        0x1d173, 0x1d17a,
+        0xe0001, 0xe0001,
+        0xe0020, 0xe007f,
 }; /* CR_Cf */
 
 /* 'Cn': General Category */
 static const OnigCodePoint CR_Cn[] = {
-	485,
-	0x0378, 0x0379,
-	0x037f, 0x0383,
-	0x038b, 0x038b,
-	0x038d, 0x038d,
-	0x03a2, 0x03a2,
-	0x0526, 0x0530,
-	0x0557, 0x0558,
-	0x0560, 0x0560,
-	0x0588, 0x0588,
-	0x058b, 0x0590,
-	0x05c8, 0x05cf,
-	0x05eb, 0x05ef,
-	0x05f5, 0x05ff,
-	0x0604, 0x0605,
-	0x061c, 0x061d,
-	0x0620, 0x0620,
-	0x065f, 0x065f,
-	0x070e, 0x070e,
-	0x074b, 0x074c,
-	0x07b2, 0x07bf,
-	0x07fb, 0x07ff,
-	0x082e, 0x082f,
-	0x083f, 0x08ff,
-	0x093a, 0x093b,
-	0x094f, 0x094f,
-	0x0956, 0x0957,
-	0x0973, 0x0978,
-	0x0980, 0x0980,
-	0x0984, 0x0984,
-	0x098d, 0x098e,
-	0x0991, 0x0992,
-	0x09a9, 0x09a9,
-	0x09b1, 0x09b1,
-	0x09b3, 0x09b5,
-	0x09ba, 0x09bb,
-	0x09c5, 0x09c6,
-	0x09c9, 0x09ca,
-	0x09cf, 0x09d6,
-	0x09d8, 0x09db,
-	0x09de, 0x09de,
-	0x09e4, 0x09e5,
-	0x09fc, 0x0a00,
-	0x0a04, 0x0a04,
-	0x0a0b, 0x0a0e,
-	0x0a11, 0x0a12,
-	0x0a29, 0x0a29,
-	0x0a31, 0x0a31,
-	0x0a34, 0x0a34,
-	0x0a37, 0x0a37,
-	0x0a3a, 0x0a3b,
-	0x0a3d, 0x0a3d,
-	0x0a43, 0x0a46,
-	0x0a49, 0x0a4a,
-	0x0a4e, 0x0a50,
-	0x0a52, 0x0a58,
-	0x0a5d, 0x0a5d,
-	0x0a5f, 0x0a65,
-	0x0a76, 0x0a80,
-	0x0a84, 0x0a84,
-	0x0a8e, 0x0a8e,
-	0x0a92, 0x0a92,
-	0x0aa9, 0x0aa9,
-	0x0ab1, 0x0ab1,
-	0x0ab4, 0x0ab4,
-	0x0aba, 0x0abb,
-	0x0ac6, 0x0ac6,
-	0x0aca, 0x0aca,
-	0x0ace, 0x0acf,
-	0x0ad1, 0x0adf,
-	0x0ae4, 0x0ae5,
-	0x0af0, 0x0af0,
-	0x0af2, 0x0b00,
-	0x0b04, 0x0b04,
-	0x0b0d, 0x0b0e,
-	0x0b11, 0x0b12,
-	0x0b29, 0x0b29,
-	0x0b31, 0x0b31,
-	0x0b34, 0x0b34,
-	0x0b3a, 0x0b3b,
-	0x0b45, 0x0b46,
-	0x0b49, 0x0b4a,
-	0x0b4e, 0x0b55,
-	0x0b58, 0x0b5b,
-	0x0b5e, 0x0b5e,
-	0x0b64, 0x0b65,
-	0x0b72, 0x0b81,
-	0x0b84, 0x0b84,
-	0x0b8b, 0x0b8d,
-	0x0b91, 0x0b91,
-	0x0b96, 0x0b98,
-	0x0b9b, 0x0b9b,
-	0x0b9d, 0x0b9d,
-	0x0ba0, 0x0ba2,
-	0x0ba5, 0x0ba7,
-	0x0bab, 0x0bad,
-	0x0bba, 0x0bbd,
-	0x0bc3, 0x0bc5,
-	0x0bc9, 0x0bc9,
-	0x0bce, 0x0bcf,
-	0x0bd1, 0x0bd6,
-	0x0bd8, 0x0be5,
-	0x0bfb, 0x0c00,
-	0x0c04, 0x0c04,
-	0x0c0d, 0x0c0d,
-	0x0c11, 0x0c11,
-	0x0c29, 0x0c29,
-	0x0c34, 0x0c34,
-	0x0c3a, 0x0c3c,
-	0x0c45, 0x0c45,
-	0x0c49, 0x0c49,
-	0x0c4e, 0x0c54,
-	0x0c57, 0x0c57,
-	0x0c5a, 0x0c5f,
-	0x0c64, 0x0c65,
-	0x0c70, 0x0c77,
-	0x0c80, 0x0c81,
-	0x0c84, 0x0c84,
-	0x0c8d, 0x0c8d,
-	0x0c91, 0x0c91,
-	0x0ca9, 0x0ca9,
-	0x0cb4, 0x0cb4,
-	0x0cba, 0x0cbb,
-	0x0cc5, 0x0cc5,
-	0x0cc9, 0x0cc9,
-	0x0cce, 0x0cd4,
-	0x0cd7, 0x0cdd,
-	0x0cdf, 0x0cdf,
-	0x0ce4, 0x0ce5,
-	0x0cf0, 0x0cf0,
-	0x0cf3, 0x0d01,
-	0x0d04, 0x0d04,
-	0x0d0d, 0x0d0d,
-	0x0d11, 0x0d11,
-	0x0d29, 0x0d29,
-	0x0d3a, 0x0d3c,
-	0x0d45, 0x0d45,
-	0x0d49, 0x0d49,
-	0x0d4e, 0x0d56,
-	0x0d58, 0x0d5f,
-	0x0d64, 0x0d65,
-	0x0d76, 0x0d78,
-	0x0d80, 0x0d81,
-	0x0d84, 0x0d84,
-	0x0d97, 0x0d99,
-	0x0db2, 0x0db2,
-	0x0dbc, 0x0dbc,
-	0x0dbe, 0x0dbf,
-	0x0dc7, 0x0dc9,
-	0x0dcb, 0x0dce,
-	0x0dd5, 0x0dd5,
-	0x0dd7, 0x0dd7,
-	0x0de0, 0x0df1,
-	0x0df5, 0x0e00,
-	0x0e3b, 0x0e3e,
-	0x0e5c, 0x0e80,
-	0x0e83, 0x0e83,
-	0x0e85, 0x0e86,
-	0x0e89, 0x0e89,
-	0x0e8b, 0x0e8c,
-	0x0e8e, 0x0e93,
-	0x0e98, 0x0e98,
-	0x0ea0, 0x0ea0,
-	0x0ea4, 0x0ea4,
-	0x0ea6, 0x0ea6,
-	0x0ea8, 0x0ea9,
-	0x0eac, 0x0eac,
-	0x0eba, 0x0eba,
-	0x0ebe, 0x0ebf,
-	0x0ec5, 0x0ec5,
-	0x0ec7, 0x0ec7,
-	0x0ece, 0x0ecf,
-	0x0eda, 0x0edb,
-	0x0ede, 0x0eff,
-	0x0f48, 0x0f48,
-	0x0f6d, 0x0f70,
-	0x0f8c, 0x0f8f,
-	0x0f98, 0x0f98,
-	0x0fbd, 0x0fbd,
-	0x0fcd, 0x0fcd,
-	0x0fd9, 0x0fff,
-	0x10c6, 0x10cf,
-	0x10fd, 0x10ff,
-	0x1249, 0x1249,
-	0x124e, 0x124f,
-	0x1257, 0x1257,
-	0x1259, 0x1259,
-	0x125e, 0x125f,
-	0x1289, 0x1289,
-	0x128e, 0x128f,
-	0x12b1, 0x12b1,
-	0x12b6, 0x12b7,
-	0x12bf, 0x12bf,
-	0x12c1, 0x12c1,
-	0x12c6, 0x12c7,
-	0x12d7, 0x12d7,
-	0x1311, 0x1311,
-	0x1316, 0x1317,
-	0x135b, 0x135e,
-	0x137d, 0x137f,
-	0x139a, 0x139f,
-	0x13f5, 0x13ff,
-	0x169d, 0x169f,
-	0x16f1, 0x16ff,
-	0x170d, 0x170d,
-	0x1715, 0x171f,
-	0x1737, 0x173f,
-	0x1754, 0x175f,
-	0x176d, 0x176d,
-	0x1771, 0x1771,
-	0x1774, 0x177f,
-	0x17de, 0x17df,
-	0x17ea, 0x17ef,
-	0x17fa, 0x17ff,
-	0x180f, 0x180f,
-	0x181a, 0x181f,
-	0x1878, 0x187f,
-	0x18ab, 0x18af,
-	0x18f6, 0x18ff,
-	0x191d, 0x191f,
-	0x192c, 0x192f,
-	0x193c, 0x193f,
-	0x1941, 0x1943,
-	0x196e, 0x196f,
-	0x1975, 0x197f,
-	0x19ac, 0x19af,
-	0x19ca, 0x19cf,
-	0x19db, 0x19dd,
-	0x1a1c, 0x1a1d,
-	0x1a5f, 0x1a5f,
-	0x1a7d, 0x1a7e,
-	0x1a8a, 0x1a8f,
-	0x1a9a, 0x1a9f,
-	0x1aae, 0x1aff,
-	0x1b4c, 0x1b4f,
-	0x1b7d, 0x1b7f,
-	0x1bab, 0x1bad,
-	0x1bba, 0x1bff,
-	0x1c38, 0x1c3a,
-	0x1c4a, 0x1c4c,
-	0x1c80, 0x1ccf,
-	0x1cf3, 0x1cff,
-	0x1de7, 0x1dfc,
-	0x1f16, 0x1f17,
-	0x1f1e, 0x1f1f,
-	0x1f46, 0x1f47,
-	0x1f4e, 0x1f4f,
-	0x1f58, 0x1f58,
-	0x1f5a, 0x1f5a,
-	0x1f5c, 0x1f5c,
-	0x1f5e, 0x1f5e,
-	0x1f7e, 0x1f7f,
-	0x1fb5, 0x1fb5,
-	0x1fc5, 0x1fc5,
-	0x1fd4, 0x1fd5,
-	0x1fdc, 0x1fdc,
-	0x1ff0, 0x1ff1,
-	0x1ff5, 0x1ff5,
-	0x1fff, 0x1fff,
-	0x2065, 0x2069,
-	0x2072, 0x2073,
-	0x208f, 0x208f,
-	0x2095, 0x209f,
-	0x20b9, 0x20cf,
-	0x20f1, 0x20ff,
-	0x218a, 0x218f,
-	0x23e9, 0x23ff,
-	0x2427, 0x243f,
-	0x244b, 0x245f,
-	0x26ce, 0x26ce,
-	0x26e2, 0x26e2,
-	0x26e4, 0x26e7,
-	0x2700, 0x2700,
-	0x2705, 0x2705,
-	0x270a, 0x270b,
-	0x2728, 0x2728,
-	0x274c, 0x274c,
-	0x274e, 0x274e,
-	0x2753, 0x2755,
-	0x275f, 0x2760,
-	0x2795, 0x2797,
-	0x27b0, 0x27b0,
-	0x27bf, 0x27bf,
-	0x27cb, 0x27cb,
-	0x27cd, 0x27cf,
-	0x2b4d, 0x2b4f,
-	0x2b5a, 0x2bff,
-	0x2c2f, 0x2c2f,
-	0x2c5f, 0x2c5f,
-	0x2cf2, 0x2cf8,
-	0x2d26, 0x2d2f,
-	0x2d66, 0x2d6e,
-	0x2d70, 0x2d7f,
-	0x2d97, 0x2d9f,
-	0x2da7, 0x2da7,
-	0x2daf, 0x2daf,
-	0x2db7, 0x2db7,
-	0x2dbf, 0x2dbf,
-	0x2dc7, 0x2dc7,
-	0x2dcf, 0x2dcf,
-	0x2dd7, 0x2dd7,
-	0x2ddf, 0x2ddf,
-	0x2e32, 0x2e7f,
-	0x2e9a, 0x2e9a,
-	0x2ef4, 0x2eff,
-	0x2fd6, 0x2fef,
-	0x2ffc, 0x2fff,
-	0x3040, 0x3040,
-	0x3097, 0x3098,
-	0x3100, 0x3104,
-	0x312e, 0x3130,
-	0x318f, 0x318f,
-	0x31b8, 0x31bf,
-	0x31e4, 0x31ef,
-	0x321f, 0x321f,
-	0x32ff, 0x32ff,
-	0x4db6, 0x4dbf,
-	0x9fcc, 0x9fff,
-	0xa48d, 0xa48f,
-	0xa4c7, 0xa4cf,
-	0xa62c, 0xa63f,
-	0xa660, 0xa661,
-	0xa674, 0xa67b,
-	0xa698, 0xa69f,
-	0xa6f8, 0xa6ff,
-	0xa78d, 0xa7fa,
-	0xa82c, 0xa82f,
-	0xa83a, 0xa83f,
-	0xa878, 0xa87f,
-	0xa8c5, 0xa8cd,
-	0xa8da, 0xa8df,
-	0xa8fc, 0xa8ff,
-	0xa954, 0xa95e,
-	0xa97d, 0xa97f,
-	0xa9ce, 0xa9ce,
-	0xa9da, 0xa9dd,
-	0xa9e0, 0xa9ff,
-	0xaa37, 0xaa3f,
-	0xaa4e, 0xaa4f,
-	0xaa5a, 0xaa5b,
-	0xaa7c, 0xaa7f,
-	0xaac3, 0xaada,
-	0xaae0, 0xabbf,
-	0xabee, 0xabef,
-	0xabfa, 0xabff,
-	0xd7a4, 0xd7af,
-	0xd7c7, 0xd7ca,
-	0xd7fc, 0xd7ff,
-	0xfa2e, 0xfa2f,
-	0xfa6e, 0xfa6f,
-	0xfada, 0xfaff,
-	0xfb07, 0xfb12,
-	0xfb18, 0xfb1c,
-	0xfb37, 0xfb37,
-	0xfb3d, 0xfb3d,
-	0xfb3f, 0xfb3f,
-	0xfb42, 0xfb42,
-	0xfb45, 0xfb45,
-	0xfbb2, 0xfbd2,
-	0xfd40, 0xfd4f,
-	0xfd90, 0xfd91,
-	0xfdc8, 0xfdef,
-	0xfdfe, 0xfdff,
-	0xfe1a, 0xfe1f,
-	0xfe27, 0xfe2f,
-	0xfe53, 0xfe53,
-	0xfe67, 0xfe67,
-	0xfe6c, 0xfe6f,
-	0xfe75, 0xfe75,
-	0xfefd, 0xfefe,
-	0xff00, 0xff00,
-	0xffbf, 0xffc1,
-	0xffc8, 0xffc9,
-	0xffd0, 0xffd1,
-	0xffd8, 0xffd9,
-	0xffdd, 0xffdf,
-	0xffe7, 0xffe7,
-	0xffef, 0xfff8,
-	0xfffe, 0xffff,
-	0x1000c, 0x1000c,
-	0x10027, 0x10027,
-	0x1003b, 0x1003b,
-	0x1003e, 0x1003e,
-	0x1004e, 0x1004f,
-	0x1005e, 0x1007f,
-	0x100fb, 0x100ff,
-	0x10103, 0x10106,
-	0x10134, 0x10136,
-	0x1018b, 0x1018f,
-	0x1019c, 0x101cf,
-	0x101fe, 0x1027f,
-	0x1029d, 0x1029f,
-	0x102d1, 0x102ff,
-	0x1031f, 0x1031f,
-	0x10324, 0x1032f,
-	0x1034b, 0x1037f,
-	0x1039e, 0x1039e,
-	0x103c4, 0x103c7,
-	0x103d6, 0x103ff,
-	0x1049e, 0x1049f,
-	0x104aa, 0x107ff,
-	0x10806, 0x10807,
-	0x10809, 0x10809,
-	0x10836, 0x10836,
-	0x10839, 0x1083b,
-	0x1083d, 0x1083e,
-	0x10856, 0x10856,
-	0x10860, 0x108ff,
-	0x1091c, 0x1091e,
-	0x1093a, 0x1093e,
-	0x10940, 0x109ff,
-	0x10a04, 0x10a04,
-	0x10a07, 0x10a0b,
-	0x10a14, 0x10a14,
-	0x10a18, 0x10a18,
-	0x10a34, 0x10a37,
-	0x10a3b, 0x10a3e,
-	0x10a48, 0x10a4f,
-	0x10a59, 0x10a5f,
-	0x10a80, 0x10aff,
-	0x10b36, 0x10b38,
-	0x10b56, 0x10b57,
-	0x10b73, 0x10b77,
-	0x10b80, 0x10bff,
-	0x10c49, 0x10e5f,
-	0x10e7f, 0x1107f,
-	0x110c2, 0x11fff,
-	0x1236f, 0x123ff,
-	0x12463, 0x1246f,
-	0x12474, 0x12fff,
-	0x1342f, 0x1cfff,
-	0x1d0f6, 0x1d0ff,
-	0x1d127, 0x1d128,
-	0x1d1de, 0x1d1ff,
-	0x1d246, 0x1d2ff,
-	0x1d357, 0x1d35f,
-	0x1d372, 0x1d3ff,
-	0x1d455, 0x1d455,
-	0x1d49d, 0x1d49d,
-	0x1d4a0, 0x1d4a1,
-	0x1d4a3, 0x1d4a4,
-	0x1d4a7, 0x1d4a8,
-	0x1d4ad, 0x1d4ad,
-	0x1d4ba, 0x1d4ba,
-	0x1d4bc, 0x1d4bc,
-	0x1d4c4, 0x1d4c4,
-	0x1d506, 0x1d506,
-	0x1d50b, 0x1d50c,
-	0x1d515, 0x1d515,
-	0x1d51d, 0x1d51d,
-	0x1d53a, 0x1d53a,
-	0x1d53f, 0x1d53f,
-	0x1d545, 0x1d545,
-	0x1d547, 0x1d549,
-	0x1d551, 0x1d551,
-	0x1d6a6, 0x1d6a7,
-	0x1d7cc, 0x1d7cd,
-	0x1d800, 0x1efff,
-	0x1f02c, 0x1f02f,
-	0x1f094, 0x1f0ff,
-	0x1f10b, 0x1f10f,
-	0x1f12f, 0x1f130,
-	0x1f132, 0x1f13c,
-	0x1f13e, 0x1f13e,
-	0x1f140, 0x1f141,
-	0x1f143, 0x1f145,
-	0x1f147, 0x1f149,
-	0x1f14f, 0x1f156,
-	0x1f158, 0x1f15e,
-	0x1f160, 0x1f178,
-	0x1f17a, 0x1f17a,
-	0x1f17d, 0x1f17e,
-	0x1f180, 0x1f189,
-	0x1f18e, 0x1f18f,
-	0x1f191, 0x1f1ff,
-	0x1f201, 0x1f20f,
-	0x1f232, 0x1f23f,
-	0x1f249, 0x1ffff,
-	0x2a6d7, 0x2a6ff,
-	0x2b735, 0x2f7ff,
-	0x2fa1e, 0xe0000,
-	0xe0002, 0xe001f,
-	0xe0080, 0xe00ff,
-	0xe01f0, 0xeffff,
-	0xffffe, 0xfffff,
-	0x10fffe, 0x10ffff,
+        485,
+        0x0378, 0x0379,
+        0x037f, 0x0383,
+        0x038b, 0x038b,
+        0x038d, 0x038d,
+        0x03a2, 0x03a2,
+        0x0526, 0x0530,
+        0x0557, 0x0558,
+        0x0560, 0x0560,
+        0x0588, 0x0588,
+        0x058b, 0x0590,
+        0x05c8, 0x05cf,
+        0x05eb, 0x05ef,
+        0x05f5, 0x05ff,
+        0x0604, 0x0605,
+        0x061c, 0x061d,
+        0x0620, 0x0620,
+        0x065f, 0x065f,
+        0x070e, 0x070e,
+        0x074b, 0x074c,
+        0x07b2, 0x07bf,
+        0x07fb, 0x07ff,
+        0x082e, 0x082f,
+        0x083f, 0x08ff,
+        0x093a, 0x093b,
+        0x094f, 0x094f,
+        0x0956, 0x0957,
+        0x0973, 0x0978,
+        0x0980, 0x0980,
+        0x0984, 0x0984,
+        0x098d, 0x098e,
+        0x0991, 0x0992,
+        0x09a9, 0x09a9,
+        0x09b1, 0x09b1,
+        0x09b3, 0x09b5,
+        0x09ba, 0x09bb,
+        0x09c5, 0x09c6,
+        0x09c9, 0x09ca,
+        0x09cf, 0x09d6,
+        0x09d8, 0x09db,
+        0x09de, 0x09de,
+        0x09e4, 0x09e5,
+        0x09fc, 0x0a00,
+        0x0a04, 0x0a04,
+        0x0a0b, 0x0a0e,
+        0x0a11, 0x0a12,
+        0x0a29, 0x0a29,
+        0x0a31, 0x0a31,
+        0x0a34, 0x0a34,
+        0x0a37, 0x0a37,
+        0x0a3a, 0x0a3b,
+        0x0a3d, 0x0a3d,
+        0x0a43, 0x0a46,
+        0x0a49, 0x0a4a,
+        0x0a4e, 0x0a50,
+        0x0a52, 0x0a58,
+        0x0a5d, 0x0a5d,
+        0x0a5f, 0x0a65,
+        0x0a76, 0x0a80,
+        0x0a84, 0x0a84,
+        0x0a8e, 0x0a8e,
+        0x0a92, 0x0a92,
+        0x0aa9, 0x0aa9,
+        0x0ab1, 0x0ab1,
+        0x0ab4, 0x0ab4,
+        0x0aba, 0x0abb,
+        0x0ac6, 0x0ac6,
+        0x0aca, 0x0aca,
+        0x0ace, 0x0acf,
+        0x0ad1, 0x0adf,
+        0x0ae4, 0x0ae5,
+        0x0af0, 0x0af0,
+        0x0af2, 0x0b00,
+        0x0b04, 0x0b04,
+        0x0b0d, 0x0b0e,
+        0x0b11, 0x0b12,
+        0x0b29, 0x0b29,
+        0x0b31, 0x0b31,
+        0x0b34, 0x0b34,
+        0x0b3a, 0x0b3b,
+        0x0b45, 0x0b46,
+        0x0b49, 0x0b4a,
+        0x0b4e, 0x0b55,
+        0x0b58, 0x0b5b,
+        0x0b5e, 0x0b5e,
+        0x0b64, 0x0b65,
+        0x0b72, 0x0b81,
+        0x0b84, 0x0b84,
+        0x0b8b, 0x0b8d,
+        0x0b91, 0x0b91,
+        0x0b96, 0x0b98,
+        0x0b9b, 0x0b9b,
+        0x0b9d, 0x0b9d,
+        0x0ba0, 0x0ba2,
+        0x0ba5, 0x0ba7,
+        0x0bab, 0x0bad,
+        0x0bba, 0x0bbd,
+        0x0bc3, 0x0bc5,
+        0x0bc9, 0x0bc9,
+        0x0bce, 0x0bcf,
+        0x0bd1, 0x0bd6,
+        0x0bd8, 0x0be5,
+        0x0bfb, 0x0c00,
+        0x0c04, 0x0c04,
+        0x0c0d, 0x0c0d,
+        0x0c11, 0x0c11,
+        0x0c29, 0x0c29,
+        0x0c34, 0x0c34,
+        0x0c3a, 0x0c3c,
+        0x0c45, 0x0c45,
+        0x0c49, 0x0c49,
+        0x0c4e, 0x0c54,
+        0x0c57, 0x0c57,
+        0x0c5a, 0x0c5f,
+        0x0c64, 0x0c65,
+        0x0c70, 0x0c77,
+        0x0c80, 0x0c81,
+        0x0c84, 0x0c84,
+        0x0c8d, 0x0c8d,
+        0x0c91, 0x0c91,
+        0x0ca9, 0x0ca9,
+        0x0cb4, 0x0cb4,
+        0x0cba, 0x0cbb,
+        0x0cc5, 0x0cc5,
+        0x0cc9, 0x0cc9,
+        0x0cce, 0x0cd4,
+        0x0cd7, 0x0cdd,
+        0x0cdf, 0x0cdf,
+        0x0ce4, 0x0ce5,
+        0x0cf0, 0x0cf0,
+        0x0cf3, 0x0d01,
+        0x0d04, 0x0d04,
+        0x0d0d, 0x0d0d,
+        0x0d11, 0x0d11,
+        0x0d29, 0x0d29,
+        0x0d3a, 0x0d3c,
+        0x0d45, 0x0d45,
+        0x0d49, 0x0d49,
+        0x0d4e, 0x0d56,
+        0x0d58, 0x0d5f,
+        0x0d64, 0x0d65,
+        0x0d76, 0x0d78,
+        0x0d80, 0x0d81,
+        0x0d84, 0x0d84,
+        0x0d97, 0x0d99,
+        0x0db2, 0x0db2,
+        0x0dbc, 0x0dbc,
+        0x0dbe, 0x0dbf,
+        0x0dc7, 0x0dc9,
+        0x0dcb, 0x0dce,
+        0x0dd5, 0x0dd5,
+        0x0dd7, 0x0dd7,
+        0x0de0, 0x0df1,
+        0x0df5, 0x0e00,
+        0x0e3b, 0x0e3e,
+        0x0e5c, 0x0e80,
+        0x0e83, 0x0e83,
+        0x0e85, 0x0e86,
+        0x0e89, 0x0e89,
+        0x0e8b, 0x0e8c,
+        0x0e8e, 0x0e93,
+        0x0e98, 0x0e98,
+        0x0ea0, 0x0ea0,
+        0x0ea4, 0x0ea4,
+        0x0ea6, 0x0ea6,
+        0x0ea8, 0x0ea9,
+        0x0eac, 0x0eac,
+        0x0eba, 0x0eba,
+        0x0ebe, 0x0ebf,
+        0x0ec5, 0x0ec5,
+        0x0ec7, 0x0ec7,
+        0x0ece, 0x0ecf,
+        0x0eda, 0x0edb,
+        0x0ede, 0x0eff,
+        0x0f48, 0x0f48,
+        0x0f6d, 0x0f70,
+        0x0f8c, 0x0f8f,
+        0x0f98, 0x0f98,
+        0x0fbd, 0x0fbd,
+        0x0fcd, 0x0fcd,
+        0x0fd9, 0x0fff,
+        0x10c6, 0x10cf,
+        0x10fd, 0x10ff,
+        0x1249, 0x1249,
+        0x124e, 0x124f,
+        0x1257, 0x1257,
+        0x1259, 0x1259,
+        0x125e, 0x125f,
+        0x1289, 0x1289,
+        0x128e, 0x128f,
+        0x12b1, 0x12b1,
+        0x12b6, 0x12b7,
+        0x12bf, 0x12bf,
+        0x12c1, 0x12c1,
+        0x12c6, 0x12c7,
+        0x12d7, 0x12d7,
+        0x1311, 0x1311,
+        0x1316, 0x1317,
+        0x135b, 0x135e,
+        0x137d, 0x137f,
+        0x139a, 0x139f,
+        0x13f5, 0x13ff,
+        0x169d, 0x169f,
+        0x16f1, 0x16ff,
+        0x170d, 0x170d,
+        0x1715, 0x171f,
+        0x1737, 0x173f,
+        0x1754, 0x175f,
+        0x176d, 0x176d,
+        0x1771, 0x1771,
+        0x1774, 0x177f,
+        0x17de, 0x17df,
+        0x17ea, 0x17ef,
+        0x17fa, 0x17ff,
+        0x180f, 0x180f,
+        0x181a, 0x181f,
+        0x1878, 0x187f,
+        0x18ab, 0x18af,
+        0x18f6, 0x18ff,
+        0x191d, 0x191f,
+        0x192c, 0x192f,
+        0x193c, 0x193f,
+        0x1941, 0x1943,
+        0x196e, 0x196f,
+        0x1975, 0x197f,
+        0x19ac, 0x19af,
+        0x19ca, 0x19cf,
+        0x19db, 0x19dd,
+        0x1a1c, 0x1a1d,
+        0x1a5f, 0x1a5f,
+        0x1a7d, 0x1a7e,
+        0x1a8a, 0x1a8f,
+        0x1a9a, 0x1a9f,
+        0x1aae, 0x1aff,
+        0x1b4c, 0x1b4f,
+        0x1b7d, 0x1b7f,
+        0x1bab, 0x1bad,
+        0x1bba, 0x1bff,
+        0x1c38, 0x1c3a,
+        0x1c4a, 0x1c4c,
+        0x1c80, 0x1ccf,
+        0x1cf3, 0x1cff,
+        0x1de7, 0x1dfc,
+        0x1f16, 0x1f17,
+        0x1f1e, 0x1f1f,
+        0x1f46, 0x1f47,
+        0x1f4e, 0x1f4f,
+        0x1f58, 0x1f58,
+        0x1f5a, 0x1f5a,
+        0x1f5c, 0x1f5c,
+        0x1f5e, 0x1f5e,
+        0x1f7e, 0x1f7f,
+        0x1fb5, 0x1fb5,
+        0x1fc5, 0x1fc5,
+        0x1fd4, 0x1fd5,
+        0x1fdc, 0x1fdc,
+        0x1ff0, 0x1ff1,
+        0x1ff5, 0x1ff5,
+        0x1fff, 0x1fff,
+        0x2065, 0x2069,
+        0x2072, 0x2073,
+        0x208f, 0x208f,
+        0x2095, 0x209f,
+        0x20b9, 0x20cf,
+        0x20f1, 0x20ff,
+        0x218a, 0x218f,
+        0x23e9, 0x23ff,
+        0x2427, 0x243f,
+        0x244b, 0x245f,
+        0x26ce, 0x26ce,
+        0x26e2, 0x26e2,
+        0x26e4, 0x26e7,
+        0x2700, 0x2700,
+        0x2705, 0x2705,
+        0x270a, 0x270b,
+        0x2728, 0x2728,
+        0x274c, 0x274c,
+        0x274e, 0x274e,
+        0x2753, 0x2755,
+        0x275f, 0x2760,
+        0x2795, 0x2797,
+        0x27b0, 0x27b0,
+        0x27bf, 0x27bf,
+        0x27cb, 0x27cb,
+        0x27cd, 0x27cf,
+        0x2b4d, 0x2b4f,
+        0x2b5a, 0x2bff,
+        0x2c2f, 0x2c2f,
+        0x2c5f, 0x2c5f,
+        0x2cf2, 0x2cf8,
+        0x2d26, 0x2d2f,
+        0x2d66, 0x2d6e,
+        0x2d70, 0x2d7f,
+        0x2d97, 0x2d9f,
+        0x2da7, 0x2da7,
+        0x2daf, 0x2daf,
+        0x2db7, 0x2db7,
+        0x2dbf, 0x2dbf,
+        0x2dc7, 0x2dc7,
+        0x2dcf, 0x2dcf,
+        0x2dd7, 0x2dd7,
+        0x2ddf, 0x2ddf,
+        0x2e32, 0x2e7f,
+        0x2e9a, 0x2e9a,
+        0x2ef4, 0x2eff,
+        0x2fd6, 0x2fef,
+        0x2ffc, 0x2fff,
+        0x3040, 0x3040,
+        0x3097, 0x3098,
+        0x3100, 0x3104,
+        0x312e, 0x3130,
+        0x318f, 0x318f,
+        0x31b8, 0x31bf,
+        0x31e4, 0x31ef,
+        0x321f, 0x321f,
+        0x32ff, 0x32ff,
+        0x4db6, 0x4dbf,
+        0x9fcc, 0x9fff,
+        0xa48d, 0xa48f,
+        0xa4c7, 0xa4cf,
+        0xa62c, 0xa63f,
+        0xa660, 0xa661,
+        0xa674, 0xa67b,
+        0xa698, 0xa69f,
+        0xa6f8, 0xa6ff,
+        0xa78d, 0xa7fa,
+        0xa82c, 0xa82f,
+        0xa83a, 0xa83f,
+        0xa878, 0xa87f,
+        0xa8c5, 0xa8cd,
+        0xa8da, 0xa8df,
+        0xa8fc, 0xa8ff,
+        0xa954, 0xa95e,
+        0xa97d, 0xa97f,
+        0xa9ce, 0xa9ce,
+        0xa9da, 0xa9dd,
+        0xa9e0, 0xa9ff,
+        0xaa37, 0xaa3f,
+        0xaa4e, 0xaa4f,
+        0xaa5a, 0xaa5b,
+        0xaa7c, 0xaa7f,
+        0xaac3, 0xaada,
+        0xaae0, 0xabbf,
+        0xabee, 0xabef,
+        0xabfa, 0xabff,
+        0xd7a4, 0xd7af,
+        0xd7c7, 0xd7ca,
+        0xd7fc, 0xd7ff,
+        0xfa2e, 0xfa2f,
+        0xfa6e, 0xfa6f,
+        0xfada, 0xfaff,
+        0xfb07, 0xfb12,
+        0xfb18, 0xfb1c,
+        0xfb37, 0xfb37,
+        0xfb3d, 0xfb3d,
+        0xfb3f, 0xfb3f,
+        0xfb42, 0xfb42,
+        0xfb45, 0xfb45,
+        0xfbb2, 0xfbd2,
+        0xfd40, 0xfd4f,
+        0xfd90, 0xfd91,
+        0xfdc8, 0xfdef,
+        0xfdfe, 0xfdff,
+        0xfe1a, 0xfe1f,
+        0xfe27, 0xfe2f,
+        0xfe53, 0xfe53,
+        0xfe67, 0xfe67,
+        0xfe6c, 0xfe6f,
+        0xfe75, 0xfe75,
+        0xfefd, 0xfefe,
+        0xff00, 0xff00,
+        0xffbf, 0xffc1,
+        0xffc8, 0xffc9,
+        0xffd0, 0xffd1,
+        0xffd8, 0xffd9,
+        0xffdd, 0xffdf,
+        0xffe7, 0xffe7,
+        0xffef, 0xfff8,
+        0xfffe, 0xffff,
+        0x1000c, 0x1000c,
+        0x10027, 0x10027,
+        0x1003b, 0x1003b,
+        0x1003e, 0x1003e,
+        0x1004e, 0x1004f,
+        0x1005e, 0x1007f,
+        0x100fb, 0x100ff,
+        0x10103, 0x10106,
+        0x10134, 0x10136,
+        0x1018b, 0x1018f,
+        0x1019c, 0x101cf,
+        0x101fe, 0x1027f,
+        0x1029d, 0x1029f,
+        0x102d1, 0x102ff,
+        0x1031f, 0x1031f,
+        0x10324, 0x1032f,
+        0x1034b, 0x1037f,
+        0x1039e, 0x1039e,
+        0x103c4, 0x103c7,
+        0x103d6, 0x103ff,
+        0x1049e, 0x1049f,
+        0x104aa, 0x107ff,
+        0x10806, 0x10807,
+        0x10809, 0x10809,
+        0x10836, 0x10836,
+        0x10839, 0x1083b,
+        0x1083d, 0x1083e,
+        0x10856, 0x10856,
+        0x10860, 0x108ff,
+        0x1091c, 0x1091e,
+        0x1093a, 0x1093e,
+        0x10940, 0x109ff,
+        0x10a04, 0x10a04,
+        0x10a07, 0x10a0b,
+        0x10a14, 0x10a14,
+        0x10a18, 0x10a18,
+        0x10a34, 0x10a37,
+        0x10a3b, 0x10a3e,
+        0x10a48, 0x10a4f,
+        0x10a59, 0x10a5f,
+        0x10a80, 0x10aff,
+        0x10b36, 0x10b38,
+        0x10b56, 0x10b57,
+        0x10b73, 0x10b77,
+        0x10b80, 0x10bff,
+        0x10c49, 0x10e5f,
+        0x10e7f, 0x1107f,
+        0x110c2, 0x11fff,
+        0x1236f, 0x123ff,
+        0x12463, 0x1246f,
+        0x12474, 0x12fff,
+        0x1342f, 0x1cfff,
+        0x1d0f6, 0x1d0ff,
+        0x1d127, 0x1d128,
+        0x1d1de, 0x1d1ff,
+        0x1d246, 0x1d2ff,
+        0x1d357, 0x1d35f,
+        0x1d372, 0x1d3ff,
+        0x1d455, 0x1d455,
+        0x1d49d, 0x1d49d,
+        0x1d4a0, 0x1d4a1,
+        0x1d4a3, 0x1d4a4,
+        0x1d4a7, 0x1d4a8,
+        0x1d4ad, 0x1d4ad,
+        0x1d4ba, 0x1d4ba,
+        0x1d4bc, 0x1d4bc,
+        0x1d4c4, 0x1d4c4,
+        0x1d506, 0x1d506,
+        0x1d50b, 0x1d50c,
+        0x1d515, 0x1d515,
+        0x1d51d, 0x1d51d,
+        0x1d53a, 0x1d53a,
+        0x1d53f, 0x1d53f,
+        0x1d545, 0x1d545,
+        0x1d547, 0x1d549,
+        0x1d551, 0x1d551,
+        0x1d6a6, 0x1d6a7,
+        0x1d7cc, 0x1d7cd,
+        0x1d800, 0x1efff,
+        0x1f02c, 0x1f02f,
+        0x1f094, 0x1f0ff,
+        0x1f10b, 0x1f10f,
+        0x1f12f, 0x1f130,
+        0x1f132, 0x1f13c,
+        0x1f13e, 0x1f13e,
+        0x1f140, 0x1f141,
+        0x1f143, 0x1f145,
+        0x1f147, 0x1f149,
+        0x1f14f, 0x1f156,
+        0x1f158, 0x1f15e,
+        0x1f160, 0x1f178,
+        0x1f17a, 0x1f17a,
+        0x1f17d, 0x1f17e,
+        0x1f180, 0x1f189,
+        0x1f18e, 0x1f18f,
+        0x1f191, 0x1f1ff,
+        0x1f201, 0x1f20f,
+        0x1f232, 0x1f23f,
+        0x1f249, 0x1ffff,
+        0x2a6d7, 0x2a6ff,
+        0x2b735, 0x2f7ff,
+        0x2fa1e, 0xe0000,
+        0xe0002, 0xe001f,
+        0xe0080, 0xe00ff,
+        0xe01f0, 0xeffff,
+        0xffffe, 0xfffff,
+        0x10fffe, 0x10ffff,
 }; /* CR_Cn */
 
 /* 'Co': General Category */
 static const OnigCodePoint CR_Co[] = {
-	3,
-	0xe000, 0xf8ff,
-	0xf0000, 0xffffd,
-	0x100000, 0x10fffd,
+        3,
+        0xe000, 0xf8ff,
+        0xf0000, 0xffffd,
+        0x100000, 0x10fffd,
 }; /* CR_Co */
 
 /* 'Cs': General Category */
 static const OnigCodePoint CR_Cs[] = {
-	1,
-	0xd800, 0xdfff,
+        1,
+        0xd800, 0xdfff,
 }; /* CR_Cs */
 
 /* 'L': Major Category */
 static const OnigCodePoint CR_L[] = {
-	422,
-	0x0041, 0x005a,
-	0x0061, 0x007a,
-	0x00aa, 0x00aa,
-	0x00b5, 0x00b5,
-	0x00ba, 0x00ba,
-	0x00c0, 0x00d6,
-	0x00d8, 0x00f6,
-	0x00f8, 0x02c1,
-	0x02c6, 0x02d1,
-	0x02e0, 0x02e4,
-	0x02ec, 0x02ec,
-	0x02ee, 0x02ee,
-	0x0370, 0x0374,
-	0x0376, 0x0377,
-	0x037a, 0x037d,
-	0x0386, 0x0386,
-	0x0388, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x03a1,
-	0x03a3, 0x03f5,
-	0x03f7, 0x0481,
-	0x048a, 0x0525,
-	0x0531, 0x0556,
-	0x0559, 0x0559,
-	0x0561, 0x0587,
-	0x05d0, 0x05ea,
-	0x05f0, 0x05f2,
-	0x0621, 0x064a,
-	0x066e, 0x066f,
-	0x0671, 0x06d3,
-	0x06d5, 0x06d5,
-	0x06e5, 0x06e6,
-	0x06ee, 0x06ef,
-	0x06fa, 0x06fc,
-	0x06ff, 0x06ff,
-	0x0710, 0x0710,
-	0x0712, 0x072f,
-	0x074d, 0x07a5,
-	0x07b1, 0x07b1,
-	0x07ca, 0x07ea,
-	0x07f4, 0x07f5,
-	0x07fa, 0x07fa,
-	0x0800, 0x0815,
-	0x081a, 0x081a,
-	0x0824, 0x0824,
-	0x0828, 0x0828,
-	0x0904, 0x0939,
-	0x093d, 0x093d,
-	0x0950, 0x0950,
-	0x0958, 0x0961,
-	0x0971, 0x0972,
-	0x0979, 0x097f,
-	0x0985, 0x098c,
-	0x098f, 0x0990,
-	0x0993, 0x09a8,
-	0x09aa, 0x09b0,
-	0x09b2, 0x09b2,
-	0x09b6, 0x09b9,
-	0x09bd, 0x09bd,
-	0x09ce, 0x09ce,
-	0x09dc, 0x09dd,
-	0x09df, 0x09e1,
-	0x09f0, 0x09f1,
-	0x0a05, 0x0a0a,
-	0x0a0f, 0x0a10,
-	0x0a13, 0x0a28,
-	0x0a2a, 0x0a30,
-	0x0a32, 0x0a33,
-	0x0a35, 0x0a36,
-	0x0a38, 0x0a39,
-	0x0a59, 0x0a5c,
-	0x0a5e, 0x0a5e,
-	0x0a72, 0x0a74,
-	0x0a85, 0x0a8d,
-	0x0a8f, 0x0a91,
-	0x0a93, 0x0aa8,
-	0x0aaa, 0x0ab0,
-	0x0ab2, 0x0ab3,
-	0x0ab5, 0x0ab9,
-	0x0abd, 0x0abd,
-	0x0ad0, 0x0ad0,
-	0x0ae0, 0x0ae1,
-	0x0b05, 0x0b0c,
-	0x0b0f, 0x0b10,
-	0x0b13, 0x0b28,
-	0x0b2a, 0x0b30,
-	0x0b32, 0x0b33,
-	0x0b35, 0x0b39,
-	0x0b3d, 0x0b3d,
-	0x0b5c, 0x0b5d,
-	0x0b5f, 0x0b61,
-	0x0b71, 0x0b71,
-	0x0b83, 0x0b83,
-	0x0b85, 0x0b8a,
-	0x0b8e, 0x0b90,
-	0x0b92, 0x0b95,
-	0x0b99, 0x0b9a,
-	0x0b9c, 0x0b9c,
-	0x0b9e, 0x0b9f,
-	0x0ba3, 0x0ba4,
-	0x0ba8, 0x0baa,
-	0x0bae, 0x0bb9,
-	0x0bd0, 0x0bd0,
-	0x0c05, 0x0c0c,
-	0x0c0e, 0x0c10,
-	0x0c12, 0x0c28,
-	0x0c2a, 0x0c33,
-	0x0c35, 0x0c39,
-	0x0c3d, 0x0c3d,
-	0x0c58, 0x0c59,
-	0x0c60, 0x0c61,
-	0x0c85, 0x0c8c,
-	0x0c8e, 0x0c90,
-	0x0c92, 0x0ca8,
-	0x0caa, 0x0cb3,
-	0x0cb5, 0x0cb9,
-	0x0cbd, 0x0cbd,
-	0x0cde, 0x0cde,
-	0x0ce0, 0x0ce1,
-	0x0d05, 0x0d0c,
-	0x0d0e, 0x0d10,
-	0x0d12, 0x0d28,
-	0x0d2a, 0x0d39,
-	0x0d3d, 0x0d3d,
-	0x0d60, 0x0d61,
-	0x0d7a, 0x0d7f,
-	0x0d85, 0x0d96,
-	0x0d9a, 0x0db1,
-	0x0db3, 0x0dbb,
-	0x0dbd, 0x0dbd,
-	0x0dc0, 0x0dc6,
-	0x0e01, 0x0e30,
-	0x0e32, 0x0e33,
-	0x0e40, 0x0e46,
-	0x0e81, 0x0e82,
-	0x0e84, 0x0e84,
-	0x0e87, 0x0e88,
-	0x0e8a, 0x0e8a,
-	0x0e8d, 0x0e8d,
-	0x0e94, 0x0e97,
-	0x0e99, 0x0e9f,
-	0x0ea1, 0x0ea3,
-	0x0ea5, 0x0ea5,
-	0x0ea7, 0x0ea7,
-	0x0eaa, 0x0eab,
-	0x0ead, 0x0eb0,
-	0x0eb2, 0x0eb3,
-	0x0ebd, 0x0ebd,
-	0x0ec0, 0x0ec4,
-	0x0ec6, 0x0ec6,
-	0x0edc, 0x0edd,
-	0x0f00, 0x0f00,
-	0x0f40, 0x0f47,
-	0x0f49, 0x0f6c,
-	0x0f88, 0x0f8b,
-	0x1000, 0x102a,
-	0x103f, 0x103f,
-	0x1050, 0x1055,
-	0x105a, 0x105d,
-	0x1061, 0x1061,
-	0x1065, 0x1066,
-	0x106e, 0x1070,
-	0x1075, 0x1081,
-	0x108e, 0x108e,
-	0x10a0, 0x10c5,
-	0x10d0, 0x10fa,
-	0x10fc, 0x10fc,
-	0x1100, 0x1248,
-	0x124a, 0x124d,
-	0x1250, 0x1256,
-	0x1258, 0x1258,
-	0x125a, 0x125d,
-	0x1260, 0x1288,
-	0x128a, 0x128d,
-	0x1290, 0x12b0,
-	0x12b2, 0x12b5,
-	0x12b8, 0x12be,
-	0x12c0, 0x12c0,
-	0x12c2, 0x12c5,
-	0x12c8, 0x12d6,
-	0x12d8, 0x1310,
-	0x1312, 0x1315,
-	0x1318, 0x135a,
-	0x1380, 0x138f,
-	0x13a0, 0x13f4,
-	0x1401, 0x166c,
-	0x166f, 0x167f,
-	0x1681, 0x169a,
-	0x16a0, 0x16ea,
-	0x1700, 0x170c,
-	0x170e, 0x1711,
-	0x1720, 0x1731,
-	0x1740, 0x1751,
-	0x1760, 0x176c,
-	0x176e, 0x1770,
-	0x1780, 0x17b3,
-	0x17d7, 0x17d7,
-	0x17dc, 0x17dc,
-	0x1820, 0x1877,
-	0x1880, 0x18a8,
-	0x18aa, 0x18aa,
-	0x18b0, 0x18f5,
-	0x1900, 0x191c,
-	0x1950, 0x196d,
-	0x1970, 0x1974,
-	0x1980, 0x19ab,
-	0x19c1, 0x19c7,
-	0x1a00, 0x1a16,
-	0x1a20, 0x1a54,
-	0x1aa7, 0x1aa7,
-	0x1b05, 0x1b33,
-	0x1b45, 0x1b4b,
-	0x1b83, 0x1ba0,
-	0x1bae, 0x1baf,
-	0x1c00, 0x1c23,
-	0x1c4d, 0x1c4f,
-	0x1c5a, 0x1c7d,
-	0x1ce9, 0x1cec,
-	0x1cee, 0x1cf1,
-	0x1d00, 0x1dbf,
-	0x1e00, 0x1f15,
-	0x1f18, 0x1f1d,
-	0x1f20, 0x1f45,
-	0x1f48, 0x1f4d,
-	0x1f50, 0x1f57,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f7d,
-	0x1f80, 0x1fb4,
-	0x1fb6, 0x1fbc,
-	0x1fbe, 0x1fbe,
-	0x1fc2, 0x1fc4,
-	0x1fc6, 0x1fcc,
-	0x1fd0, 0x1fd3,
-	0x1fd6, 0x1fdb,
-	0x1fe0, 0x1fec,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ffc,
-	0x2071, 0x2071,
-	0x207f, 0x207f,
-	0x2090, 0x2094,
-	0x2102, 0x2102,
-	0x2107, 0x2107,
-	0x210a, 0x2113,
-	0x2115, 0x2115,
-	0x2119, 0x211d,
-	0x2124, 0x2124,
-	0x2126, 0x2126,
-	0x2128, 0x2128,
-	0x212a, 0x212d,
-	0x212f, 0x2139,
-	0x213c, 0x213f,
-	0x2145, 0x2149,
-	0x214e, 0x214e,
-	0x2183, 0x2184,
-	0x2c00, 0x2c2e,
-	0x2c30, 0x2c5e,
-	0x2c60, 0x2ce4,
-	0x2ceb, 0x2cee,
-	0x2d00, 0x2d25,
-	0x2d30, 0x2d65,
-	0x2d6f, 0x2d6f,
-	0x2d80, 0x2d96,
-	0x2da0, 0x2da6,
-	0x2da8, 0x2dae,
-	0x2db0, 0x2db6,
-	0x2db8, 0x2dbe,
-	0x2dc0, 0x2dc6,
-	0x2dc8, 0x2dce,
-	0x2dd0, 0x2dd6,
-	0x2dd8, 0x2dde,
-	0x2e2f, 0x2e2f,
-	0x3005, 0x3006,
-	0x3031, 0x3035,
-	0x303b, 0x303c,
-	0x3041, 0x3096,
-	0x309d, 0x309f,
-	0x30a1, 0x30fa,
-	0x30fc, 0x30ff,
-	0x3105, 0x312d,
-	0x3131, 0x318e,
-	0x31a0, 0x31b7,
-	0x31f0, 0x31ff,
-	0x3400, 0x4db5,
-	0x4e00, 0x9fcb,
-	0xa000, 0xa48c,
-	0xa4d0, 0xa4fd,
-	0xa500, 0xa60c,
-	0xa610, 0xa61f,
-	0xa62a, 0xa62b,
-	0xa640, 0xa65f,
-	0xa662, 0xa66e,
-	0xa67f, 0xa697,
-	0xa6a0, 0xa6e5,
-	0xa717, 0xa71f,
-	0xa722, 0xa788,
-	0xa78b, 0xa78c,
-	0xa7fb, 0xa801,
-	0xa803, 0xa805,
-	0xa807, 0xa80a,
-	0xa80c, 0xa822,
-	0xa840, 0xa873,
-	0xa882, 0xa8b3,
-	0xa8f2, 0xa8f7,
-	0xa8fb, 0xa8fb,
-	0xa90a, 0xa925,
-	0xa930, 0xa946,
-	0xa960, 0xa97c,
-	0xa984, 0xa9b2,
-	0xa9cf, 0xa9cf,
-	0xaa00, 0xaa28,
-	0xaa40, 0xaa42,
-	0xaa44, 0xaa4b,
-	0xaa60, 0xaa76,
-	0xaa7a, 0xaa7a,
-	0xaa80, 0xaaaf,
-	0xaab1, 0xaab1,
-	0xaab5, 0xaab6,
-	0xaab9, 0xaabd,
-	0xaac0, 0xaac0,
-	0xaac2, 0xaac2,
-	0xaadb, 0xaadd,
-	0xabc0, 0xabe2,
-	0xac00, 0xd7a3,
-	0xd7b0, 0xd7c6,
-	0xd7cb, 0xd7fb,
-	0xf900, 0xfa2d,
-	0xfa30, 0xfa6d,
-	0xfa70, 0xfad9,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xfb1d, 0xfb1d,
-	0xfb1f, 0xfb28,
-	0xfb2a, 0xfb36,
-	0xfb38, 0xfb3c,
-	0xfb3e, 0xfb3e,
-	0xfb40, 0xfb41,
-	0xfb43, 0xfb44,
-	0xfb46, 0xfbb1,
-	0xfbd3, 0xfd3d,
-	0xfd50, 0xfd8f,
-	0xfd92, 0xfdc7,
-	0xfdf0, 0xfdfb,
-	0xfe70, 0xfe74,
-	0xfe76, 0xfefc,
-	0xff21, 0xff3a,
-	0xff41, 0xff5a,
-	0xff66, 0xffbe,
-	0xffc2, 0xffc7,
-	0xffca, 0xffcf,
-	0xffd2, 0xffd7,
-	0xffda, 0xffdc,
-	0x10000, 0x1000b,
-	0x1000d, 0x10026,
-	0x10028, 0x1003a,
-	0x1003c, 0x1003d,
-	0x1003f, 0x1004d,
-	0x10050, 0x1005d,
-	0x10080, 0x100fa,
-	0x10280, 0x1029c,
-	0x102a0, 0x102d0,
-	0x10300, 0x1031e,
-	0x10330, 0x10340,
-	0x10342, 0x10349,
-	0x10380, 0x1039d,
-	0x103a0, 0x103c3,
-	0x103c8, 0x103cf,
-	0x10400, 0x1049d,
-	0x10800, 0x10805,
-	0x10808, 0x10808,
-	0x1080a, 0x10835,
-	0x10837, 0x10838,
-	0x1083c, 0x1083c,
-	0x1083f, 0x10855,
-	0x10900, 0x10915,
-	0x10920, 0x10939,
-	0x10a00, 0x10a00,
-	0x10a10, 0x10a13,
-	0x10a15, 0x10a17,
-	0x10a19, 0x10a33,
-	0x10a60, 0x10a7c,
-	0x10b00, 0x10b35,
-	0x10b40, 0x10b55,
-	0x10b60, 0x10b72,
-	0x10c00, 0x10c48,
-	0x11083, 0x110af,
-	0x12000, 0x1236e,
-	0x13000, 0x1342e,
-	0x1d400, 0x1d454,
-	0x1d456, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d51e, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d552, 0x1d6a5,
-	0x1d6a8, 0x1d6c0,
-	0x1d6c2, 0x1d6da,
-	0x1d6dc, 0x1d6fa,
-	0x1d6fc, 0x1d714,
-	0x1d716, 0x1d734,
-	0x1d736, 0x1d74e,
-	0x1d750, 0x1d76e,
-	0x1d770, 0x1d788,
-	0x1d78a, 0x1d7a8,
-	0x1d7aa, 0x1d7c2,
-	0x1d7c4, 0x1d7cb,
-	0x20000, 0x2a6d6,
-	0x2a700, 0x2b734,
-	0x2f800, 0x2fa1d,
+        422,
+        0x0041, 0x005a,
+        0x0061, 0x007a,
+        0x00aa, 0x00aa,
+        0x00b5, 0x00b5,
+        0x00ba, 0x00ba,
+        0x00c0, 0x00d6,
+        0x00d8, 0x00f6,
+        0x00f8, 0x02c1,
+        0x02c6, 0x02d1,
+        0x02e0, 0x02e4,
+        0x02ec, 0x02ec,
+        0x02ee, 0x02ee,
+        0x0370, 0x0374,
+        0x0376, 0x0377,
+        0x037a, 0x037d,
+        0x0386, 0x0386,
+        0x0388, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x03a1,
+        0x03a3, 0x03f5,
+        0x03f7, 0x0481,
+        0x048a, 0x0525,
+        0x0531, 0x0556,
+        0x0559, 0x0559,
+        0x0561, 0x0587,
+        0x05d0, 0x05ea,
+        0x05f0, 0x05f2,
+        0x0621, 0x064a,
+        0x066e, 0x066f,
+        0x0671, 0x06d3,
+        0x06d5, 0x06d5,
+        0x06e5, 0x06e6,
+        0x06ee, 0x06ef,
+        0x06fa, 0x06fc,
+        0x06ff, 0x06ff,
+        0x0710, 0x0710,
+        0x0712, 0x072f,
+        0x074d, 0x07a5,
+        0x07b1, 0x07b1,
+        0x07ca, 0x07ea,
+        0x07f4, 0x07f5,
+        0x07fa, 0x07fa,
+        0x0800, 0x0815,
+        0x081a, 0x081a,
+        0x0824, 0x0824,
+        0x0828, 0x0828,
+        0x0904, 0x0939,
+        0x093d, 0x093d,
+        0x0950, 0x0950,
+        0x0958, 0x0961,
+        0x0971, 0x0972,
+        0x0979, 0x097f,
+        0x0985, 0x098c,
+        0x098f, 0x0990,
+        0x0993, 0x09a8,
+        0x09aa, 0x09b0,
+        0x09b2, 0x09b2,
+        0x09b6, 0x09b9,
+        0x09bd, 0x09bd,
+        0x09ce, 0x09ce,
+        0x09dc, 0x09dd,
+        0x09df, 0x09e1,
+        0x09f0, 0x09f1,
+        0x0a05, 0x0a0a,
+        0x0a0f, 0x0a10,
+        0x0a13, 0x0a28,
+        0x0a2a, 0x0a30,
+        0x0a32, 0x0a33,
+        0x0a35, 0x0a36,
+        0x0a38, 0x0a39,
+        0x0a59, 0x0a5c,
+        0x0a5e, 0x0a5e,
+        0x0a72, 0x0a74,
+        0x0a85, 0x0a8d,
+        0x0a8f, 0x0a91,
+        0x0a93, 0x0aa8,
+        0x0aaa, 0x0ab0,
+        0x0ab2, 0x0ab3,
+        0x0ab5, 0x0ab9,
+        0x0abd, 0x0abd,
+        0x0ad0, 0x0ad0,
+        0x0ae0, 0x0ae1,
+        0x0b05, 0x0b0c,
+        0x0b0f, 0x0b10,
+        0x0b13, 0x0b28,
+        0x0b2a, 0x0b30,
+        0x0b32, 0x0b33,
+        0x0b35, 0x0b39,
+        0x0b3d, 0x0b3d,
+        0x0b5c, 0x0b5d,
+        0x0b5f, 0x0b61,
+        0x0b71, 0x0b71,
+        0x0b83, 0x0b83,
+        0x0b85, 0x0b8a,
+        0x0b8e, 0x0b90,
+        0x0b92, 0x0b95,
+        0x0b99, 0x0b9a,
+        0x0b9c, 0x0b9c,
+        0x0b9e, 0x0b9f,
+        0x0ba3, 0x0ba4,
+        0x0ba8, 0x0baa,
+        0x0bae, 0x0bb9,
+        0x0bd0, 0x0bd0,
+        0x0c05, 0x0c0c,
+        0x0c0e, 0x0c10,
+        0x0c12, 0x0c28,
+        0x0c2a, 0x0c33,
+        0x0c35, 0x0c39,
+        0x0c3d, 0x0c3d,
+        0x0c58, 0x0c59,
+        0x0c60, 0x0c61,
+        0x0c85, 0x0c8c,
+        0x0c8e, 0x0c90,
+        0x0c92, 0x0ca8,
+        0x0caa, 0x0cb3,
+        0x0cb5, 0x0cb9,
+        0x0cbd, 0x0cbd,
+        0x0cde, 0x0cde,
+        0x0ce0, 0x0ce1,
+        0x0d05, 0x0d0c,
+        0x0d0e, 0x0d10,
+        0x0d12, 0x0d28,
+        0x0d2a, 0x0d39,
+        0x0d3d, 0x0d3d,
+        0x0d60, 0x0d61,
+        0x0d7a, 0x0d7f,
+        0x0d85, 0x0d96,
+        0x0d9a, 0x0db1,
+        0x0db3, 0x0dbb,
+        0x0dbd, 0x0dbd,
+        0x0dc0, 0x0dc6,
+        0x0e01, 0x0e30,
+        0x0e32, 0x0e33,
+        0x0e40, 0x0e46,
+        0x0e81, 0x0e82,
+        0x0e84, 0x0e84,
+        0x0e87, 0x0e88,
+        0x0e8a, 0x0e8a,
+        0x0e8d, 0x0e8d,
+        0x0e94, 0x0e97,
+        0x0e99, 0x0e9f,
+        0x0ea1, 0x0ea3,
+        0x0ea5, 0x0ea5,
+        0x0ea7, 0x0ea7,
+        0x0eaa, 0x0eab,
+        0x0ead, 0x0eb0,
+        0x0eb2, 0x0eb3,
+        0x0ebd, 0x0ebd,
+        0x0ec0, 0x0ec4,
+        0x0ec6, 0x0ec6,
+        0x0edc, 0x0edd,
+        0x0f00, 0x0f00,
+        0x0f40, 0x0f47,
+        0x0f49, 0x0f6c,
+        0x0f88, 0x0f8b,
+        0x1000, 0x102a,
+        0x103f, 0x103f,
+        0x1050, 0x1055,
+        0x105a, 0x105d,
+        0x1061, 0x1061,
+        0x1065, 0x1066,
+        0x106e, 0x1070,
+        0x1075, 0x1081,
+        0x108e, 0x108e,
+        0x10a0, 0x10c5,
+        0x10d0, 0x10fa,
+        0x10fc, 0x10fc,
+        0x1100, 0x1248,
+        0x124a, 0x124d,
+        0x1250, 0x1256,
+        0x1258, 0x1258,
+        0x125a, 0x125d,
+        0x1260, 0x1288,
+        0x128a, 0x128d,
+        0x1290, 0x12b0,
+        0x12b2, 0x12b5,
+        0x12b8, 0x12be,
+        0x12c0, 0x12c0,
+        0x12c2, 0x12c5,
+        0x12c8, 0x12d6,
+        0x12d8, 0x1310,
+        0x1312, 0x1315,
+        0x1318, 0x135a,
+        0x1380, 0x138f,
+        0x13a0, 0x13f4,
+        0x1401, 0x166c,
+        0x166f, 0x167f,
+        0x1681, 0x169a,
+        0x16a0, 0x16ea,
+        0x1700, 0x170c,
+        0x170e, 0x1711,
+        0x1720, 0x1731,
+        0x1740, 0x1751,
+        0x1760, 0x176c,
+        0x176e, 0x1770,
+        0x1780, 0x17b3,
+        0x17d7, 0x17d7,
+        0x17dc, 0x17dc,
+        0x1820, 0x1877,
+        0x1880, 0x18a8,
+        0x18aa, 0x18aa,
+        0x18b0, 0x18f5,
+        0x1900, 0x191c,
+        0x1950, 0x196d,
+        0x1970, 0x1974,
+        0x1980, 0x19ab,
+        0x19c1, 0x19c7,
+        0x1a00, 0x1a16,
+        0x1a20, 0x1a54,
+        0x1aa7, 0x1aa7,
+        0x1b05, 0x1b33,
+        0x1b45, 0x1b4b,
+        0x1b83, 0x1ba0,
+        0x1bae, 0x1baf,
+        0x1c00, 0x1c23,
+        0x1c4d, 0x1c4f,
+        0x1c5a, 0x1c7d,
+        0x1ce9, 0x1cec,
+        0x1cee, 0x1cf1,
+        0x1d00, 0x1dbf,
+        0x1e00, 0x1f15,
+        0x1f18, 0x1f1d,
+        0x1f20, 0x1f45,
+        0x1f48, 0x1f4d,
+        0x1f50, 0x1f57,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f7d,
+        0x1f80, 0x1fb4,
+        0x1fb6, 0x1fbc,
+        0x1fbe, 0x1fbe,
+        0x1fc2, 0x1fc4,
+        0x1fc6, 0x1fcc,
+        0x1fd0, 0x1fd3,
+        0x1fd6, 0x1fdb,
+        0x1fe0, 0x1fec,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ffc,
+        0x2071, 0x2071,
+        0x207f, 0x207f,
+        0x2090, 0x2094,
+        0x2102, 0x2102,
+        0x2107, 0x2107,
+        0x210a, 0x2113,
+        0x2115, 0x2115,
+        0x2119, 0x211d,
+        0x2124, 0x2124,
+        0x2126, 0x2126,
+        0x2128, 0x2128,
+        0x212a, 0x212d,
+        0x212f, 0x2139,
+        0x213c, 0x213f,
+        0x2145, 0x2149,
+        0x214e, 0x214e,
+        0x2183, 0x2184,
+        0x2c00, 0x2c2e,
+        0x2c30, 0x2c5e,
+        0x2c60, 0x2ce4,
+        0x2ceb, 0x2cee,
+        0x2d00, 0x2d25,
+        0x2d30, 0x2d65,
+        0x2d6f, 0x2d6f,
+        0x2d80, 0x2d96,
+        0x2da0, 0x2da6,
+        0x2da8, 0x2dae,
+        0x2db0, 0x2db6,
+        0x2db8, 0x2dbe,
+        0x2dc0, 0x2dc6,
+        0x2dc8, 0x2dce,
+        0x2dd0, 0x2dd6,
+        0x2dd8, 0x2dde,
+        0x2e2f, 0x2e2f,
+        0x3005, 0x3006,
+        0x3031, 0x3035,
+        0x303b, 0x303c,
+        0x3041, 0x3096,
+        0x309d, 0x309f,
+        0x30a1, 0x30fa,
+        0x30fc, 0x30ff,
+        0x3105, 0x312d,
+        0x3131, 0x318e,
+        0x31a0, 0x31b7,
+        0x31f0, 0x31ff,
+        0x3400, 0x4db5,
+        0x4e00, 0x9fcb,
+        0xa000, 0xa48c,
+        0xa4d0, 0xa4fd,
+        0xa500, 0xa60c,
+        0xa610, 0xa61f,
+        0xa62a, 0xa62b,
+        0xa640, 0xa65f,
+        0xa662, 0xa66e,
+        0xa67f, 0xa697,
+        0xa6a0, 0xa6e5,
+        0xa717, 0xa71f,
+        0xa722, 0xa788,
+        0xa78b, 0xa78c,
+        0xa7fb, 0xa801,
+        0xa803, 0xa805,
+        0xa807, 0xa80a,
+        0xa80c, 0xa822,
+        0xa840, 0xa873,
+        0xa882, 0xa8b3,
+        0xa8f2, 0xa8f7,
+        0xa8fb, 0xa8fb,
+        0xa90a, 0xa925,
+        0xa930, 0xa946,
+        0xa960, 0xa97c,
+        0xa984, 0xa9b2,
+        0xa9cf, 0xa9cf,
+        0xaa00, 0xaa28,
+        0xaa40, 0xaa42,
+        0xaa44, 0xaa4b,
+        0xaa60, 0xaa76,
+        0xaa7a, 0xaa7a,
+        0xaa80, 0xaaaf,
+        0xaab1, 0xaab1,
+        0xaab5, 0xaab6,
+        0xaab9, 0xaabd,
+        0xaac0, 0xaac0,
+        0xaac2, 0xaac2,
+        0xaadb, 0xaadd,
+        0xabc0, 0xabe2,
+        0xac00, 0xd7a3,
+        0xd7b0, 0xd7c6,
+        0xd7cb, 0xd7fb,
+        0xf900, 0xfa2d,
+        0xfa30, 0xfa6d,
+        0xfa70, 0xfad9,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xfb1d, 0xfb1d,
+        0xfb1f, 0xfb28,
+        0xfb2a, 0xfb36,
+        0xfb38, 0xfb3c,
+        0xfb3e, 0xfb3e,
+        0xfb40, 0xfb41,
+        0xfb43, 0xfb44,
+        0xfb46, 0xfbb1,
+        0xfbd3, 0xfd3d,
+        0xfd50, 0xfd8f,
+        0xfd92, 0xfdc7,
+        0xfdf0, 0xfdfb,
+        0xfe70, 0xfe74,
+        0xfe76, 0xfefc,
+        0xff21, 0xff3a,
+        0xff41, 0xff5a,
+        0xff66, 0xffbe,
+        0xffc2, 0xffc7,
+        0xffca, 0xffcf,
+        0xffd2, 0xffd7,
+        0xffda, 0xffdc,
+        0x10000, 0x1000b,
+        0x1000d, 0x10026,
+        0x10028, 0x1003a,
+        0x1003c, 0x1003d,
+        0x1003f, 0x1004d,
+        0x10050, 0x1005d,
+        0x10080, 0x100fa,
+        0x10280, 0x1029c,
+        0x102a0, 0x102d0,
+        0x10300, 0x1031e,
+        0x10330, 0x10340,
+        0x10342, 0x10349,
+        0x10380, 0x1039d,
+        0x103a0, 0x103c3,
+        0x103c8, 0x103cf,
+        0x10400, 0x1049d,
+        0x10800, 0x10805,
+        0x10808, 0x10808,
+        0x1080a, 0x10835,
+        0x10837, 0x10838,
+        0x1083c, 0x1083c,
+        0x1083f, 0x10855,
+        0x10900, 0x10915,
+        0x10920, 0x10939,
+        0x10a00, 0x10a00,
+        0x10a10, 0x10a13,
+        0x10a15, 0x10a17,
+        0x10a19, 0x10a33,
+        0x10a60, 0x10a7c,
+        0x10b00, 0x10b35,
+        0x10b40, 0x10b55,
+        0x10b60, 0x10b72,
+        0x10c00, 0x10c48,
+        0x11083, 0x110af,
+        0x12000, 0x1236e,
+        0x13000, 0x1342e,
+        0x1d400, 0x1d454,
+        0x1d456, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d51e, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d552, 0x1d6a5,
+        0x1d6a8, 0x1d6c0,
+        0x1d6c2, 0x1d6da,
+        0x1d6dc, 0x1d6fa,
+        0x1d6fc, 0x1d714,
+        0x1d716, 0x1d734,
+        0x1d736, 0x1d74e,
+        0x1d750, 0x1d76e,
+        0x1d770, 0x1d788,
+        0x1d78a, 0x1d7a8,
+        0x1d7aa, 0x1d7c2,
+        0x1d7c4, 0x1d7cb,
+        0x20000, 0x2a6d6,
+        0x2a700, 0x2b734,
+        0x2f800, 0x2fa1d,
 }; /* CR_L */
 
 /* 'Ll': General Category */
 static const OnigCodePoint CR_Ll[] = {
-	599,
-	0x0061, 0x007a,
-	0x00aa, 0x00aa,
-	0x00b5, 0x00b5,
-	0x00ba, 0x00ba,
-	0x00df, 0x00f6,
-	0x00f8, 0x00ff,
-	0x0101, 0x0101,
-	0x0103, 0x0103,
-	0x0105, 0x0105,
-	0x0107, 0x0107,
-	0x0109, 0x0109,
-	0x010b, 0x010b,
-	0x010d, 0x010d,
-	0x010f, 0x010f,
-	0x0111, 0x0111,
-	0x0113, 0x0113,
-	0x0115, 0x0115,
-	0x0117, 0x0117,
-	0x0119, 0x0119,
-	0x011b, 0x011b,
-	0x011d, 0x011d,
-	0x011f, 0x011f,
-	0x0121, 0x0121,
-	0x0123, 0x0123,
-	0x0125, 0x0125,
-	0x0127, 0x0127,
-	0x0129, 0x0129,
-	0x012b, 0x012b,
-	0x012d, 0x012d,
-	0x012f, 0x012f,
-	0x0131, 0x0131,
-	0x0133, 0x0133,
-	0x0135, 0x0135,
-	0x0137, 0x0138,
-	0x013a, 0x013a,
-	0x013c, 0x013c,
-	0x013e, 0x013e,
-	0x0140, 0x0140,
-	0x0142, 0x0142,
-	0x0144, 0x0144,
-	0x0146, 0x0146,
-	0x0148, 0x0149,
-	0x014b, 0x014b,
-	0x014d, 0x014d,
-	0x014f, 0x014f,
-	0x0151, 0x0151,
-	0x0153, 0x0153,
-	0x0155, 0x0155,
-	0x0157, 0x0157,
-	0x0159, 0x0159,
-	0x015b, 0x015b,
-	0x015d, 0x015d,
-	0x015f, 0x015f,
-	0x0161, 0x0161,
-	0x0163, 0x0163,
-	0x0165, 0x0165,
-	0x0167, 0x0167,
-	0x0169, 0x0169,
-	0x016b, 0x016b,
-	0x016d, 0x016d,
-	0x016f, 0x016f,
-	0x0171, 0x0171,
-	0x0173, 0x0173,
-	0x0175, 0x0175,
-	0x0177, 0x0177,
-	0x017a, 0x017a,
-	0x017c, 0x017c,
-	0x017e, 0x0180,
-	0x0183, 0x0183,
-	0x0185, 0x0185,
-	0x0188, 0x0188,
-	0x018c, 0x018d,
-	0x0192, 0x0192,
-	0x0195, 0x0195,
-	0x0199, 0x019b,
-	0x019e, 0x019e,
-	0x01a1, 0x01a1,
-	0x01a3, 0x01a3,
-	0x01a5, 0x01a5,
-	0x01a8, 0x01a8,
-	0x01aa, 0x01ab,
-	0x01ad, 0x01ad,
-	0x01b0, 0x01b0,
-	0x01b4, 0x01b4,
-	0x01b6, 0x01b6,
-	0x01b9, 0x01ba,
-	0x01bd, 0x01bf,
-	0x01c6, 0x01c6,
-	0x01c9, 0x01c9,
-	0x01cc, 0x01cc,
-	0x01ce, 0x01ce,
-	0x01d0, 0x01d0,
-	0x01d2, 0x01d2,
-	0x01d4, 0x01d4,
-	0x01d6, 0x01d6,
-	0x01d8, 0x01d8,
-	0x01da, 0x01da,
-	0x01dc, 0x01dd,
-	0x01df, 0x01df,
-	0x01e1, 0x01e1,
-	0x01e3, 0x01e3,
-	0x01e5, 0x01e5,
-	0x01e7, 0x01e7,
-	0x01e9, 0x01e9,
-	0x01eb, 0x01eb,
-	0x01ed, 0x01ed,
-	0x01ef, 0x01f0,
-	0x01f3, 0x01f3,
-	0x01f5, 0x01f5,
-	0x01f9, 0x01f9,
-	0x01fb, 0x01fb,
-	0x01fd, 0x01fd,
-	0x01ff, 0x01ff,
-	0x0201, 0x0201,
-	0x0203, 0x0203,
-	0x0205, 0x0205,
-	0x0207, 0x0207,
-	0x0209, 0x0209,
-	0x020b, 0x020b,
-	0x020d, 0x020d,
-	0x020f, 0x020f,
-	0x0211, 0x0211,
-	0x0213, 0x0213,
-	0x0215, 0x0215,
-	0x0217, 0x0217,
-	0x0219, 0x0219,
-	0x021b, 0x021b,
-	0x021d, 0x021d,
-	0x021f, 0x021f,
-	0x0221, 0x0221,
-	0x0223, 0x0223,
-	0x0225, 0x0225,
-	0x0227, 0x0227,
-	0x0229, 0x0229,
-	0x022b, 0x022b,
-	0x022d, 0x022d,
-	0x022f, 0x022f,
-	0x0231, 0x0231,
-	0x0233, 0x0239,
-	0x023c, 0x023c,
-	0x023f, 0x0240,
-	0x0242, 0x0242,
-	0x0247, 0x0247,
-	0x0249, 0x0249,
-	0x024b, 0x024b,
-	0x024d, 0x024d,
-	0x024f, 0x0293,
-	0x0295, 0x02af,
-	0x0371, 0x0371,
-	0x0373, 0x0373,
-	0x0377, 0x0377,
-	0x037b, 0x037d,
-	0x0390, 0x0390,
-	0x03ac, 0x03ce,
-	0x03d0, 0x03d1,
-	0x03d5, 0x03d7,
-	0x03d9, 0x03d9,
-	0x03db, 0x03db,
-	0x03dd, 0x03dd,
-	0x03df, 0x03df,
-	0x03e1, 0x03e1,
-	0x03e3, 0x03e3,
-	0x03e5, 0x03e5,
-	0x03e7, 0x03e7,
-	0x03e9, 0x03e9,
-	0x03eb, 0x03eb,
-	0x03ed, 0x03ed,
-	0x03ef, 0x03f3,
-	0x03f5, 0x03f5,
-	0x03f8, 0x03f8,
-	0x03fb, 0x03fc,
-	0x0430, 0x045f,
-	0x0461, 0x0461,
-	0x0463, 0x0463,
-	0x0465, 0x0465,
-	0x0467, 0x0467,
-	0x0469, 0x0469,
-	0x046b, 0x046b,
-	0x046d, 0x046d,
-	0x046f, 0x046f,
-	0x0471, 0x0471,
-	0x0473, 0x0473,
-	0x0475, 0x0475,
-	0x0477, 0x0477,
-	0x0479, 0x0479,
-	0x047b, 0x047b,
-	0x047d, 0x047d,
-	0x047f, 0x047f,
-	0x0481, 0x0481,
-	0x048b, 0x048b,
-	0x048d, 0x048d,
-	0x048f, 0x048f,
-	0x0491, 0x0491,
-	0x0493, 0x0493,
-	0x0495, 0x0495,
-	0x0497, 0x0497,
-	0x0499, 0x0499,
-	0x049b, 0x049b,
-	0x049d, 0x049d,
-	0x049f, 0x049f,
-	0x04a1, 0x04a1,
-	0x04a3, 0x04a3,
-	0x04a5, 0x04a5,
-	0x04a7, 0x04a7,
-	0x04a9, 0x04a9,
-	0x04ab, 0x04ab,
-	0x04ad, 0x04ad,
-	0x04af, 0x04af,
-	0x04b1, 0x04b1,
-	0x04b3, 0x04b3,
-	0x04b5, 0x04b5,
-	0x04b7, 0x04b7,
-	0x04b9, 0x04b9,
-	0x04bb, 0x04bb,
-	0x04bd, 0x04bd,
-	0x04bf, 0x04bf,
-	0x04c2, 0x04c2,
-	0x04c4, 0x04c4,
-	0x04c6, 0x04c6,
-	0x04c8, 0x04c8,
-	0x04ca, 0x04ca,
-	0x04cc, 0x04cc,
-	0x04ce, 0x04cf,
-	0x04d1, 0x04d1,
-	0x04d3, 0x04d3,
-	0x04d5, 0x04d5,
-	0x04d7, 0x04d7,
-	0x04d9, 0x04d9,
-	0x04db, 0x04db,
-	0x04dd, 0x04dd,
-	0x04df, 0x04df,
-	0x04e1, 0x04e1,
-	0x04e3, 0x04e3,
-	0x04e5, 0x04e5,
-	0x04e7, 0x04e7,
-	0x04e9, 0x04e9,
-	0x04eb, 0x04eb,
-	0x04ed, 0x04ed,
-	0x04ef, 0x04ef,
-	0x04f1, 0x04f1,
-	0x04f3, 0x04f3,
-	0x04f5, 0x04f5,
-	0x04f7, 0x04f7,
-	0x04f9, 0x04f9,
-	0x04fb, 0x04fb,
-	0x04fd, 0x04fd,
-	0x04ff, 0x04ff,
-	0x0501, 0x0501,
-	0x0503, 0x0503,
-	0x0505, 0x0505,
-	0x0507, 0x0507,
-	0x0509, 0x0509,
-	0x050b, 0x050b,
-	0x050d, 0x050d,
-	0x050f, 0x050f,
-	0x0511, 0x0511,
-	0x0513, 0x0513,
-	0x0515, 0x0515,
-	0x0517, 0x0517,
-	0x0519, 0x0519,
-	0x051b, 0x051b,
-	0x051d, 0x051d,
-	0x051f, 0x051f,
-	0x0521, 0x0521,
-	0x0523, 0x0523,
-	0x0525, 0x0525,
-	0x0561, 0x0587,
-	0x1d00, 0x1d2b,
-	0x1d62, 0x1d77,
-	0x1d79, 0x1d9a,
-	0x1e01, 0x1e01,
-	0x1e03, 0x1e03,
-	0x1e05, 0x1e05,
-	0x1e07, 0x1e07,
-	0x1e09, 0x1e09,
-	0x1e0b, 0x1e0b,
-	0x1e0d, 0x1e0d,
-	0x1e0f, 0x1e0f,
-	0x1e11, 0x1e11,
-	0x1e13, 0x1e13,
-	0x1e15, 0x1e15,
-	0x1e17, 0x1e17,
-	0x1e19, 0x1e19,
-	0x1e1b, 0x1e1b,
-	0x1e1d, 0x1e1d,
-	0x1e1f, 0x1e1f,
-	0x1e21, 0x1e21,
-	0x1e23, 0x1e23,
-	0x1e25, 0x1e25,
-	0x1e27, 0x1e27,
-	0x1e29, 0x1e29,
-	0x1e2b, 0x1e2b,
-	0x1e2d, 0x1e2d,
-	0x1e2f, 0x1e2f,
-	0x1e31, 0x1e31,
-	0x1e33, 0x1e33,
-	0x1e35, 0x1e35,
-	0x1e37, 0x1e37,
-	0x1e39, 0x1e39,
-	0x1e3b, 0x1e3b,
-	0x1e3d, 0x1e3d,
-	0x1e3f, 0x1e3f,
-	0x1e41, 0x1e41,
-	0x1e43, 0x1e43,
-	0x1e45, 0x1e45,
-	0x1e47, 0x1e47,
-	0x1e49, 0x1e49,
-	0x1e4b, 0x1e4b,
-	0x1e4d, 0x1e4d,
-	0x1e4f, 0x1e4f,
-	0x1e51, 0x1e51,
-	0x1e53, 0x1e53,
-	0x1e55, 0x1e55,
-	0x1e57, 0x1e57,
-	0x1e59, 0x1e59,
-	0x1e5b, 0x1e5b,
-	0x1e5d, 0x1e5d,
-	0x1e5f, 0x1e5f,
-	0x1e61, 0x1e61,
-	0x1e63, 0x1e63,
-	0x1e65, 0x1e65,
-	0x1e67, 0x1e67,
-	0x1e69, 0x1e69,
-	0x1e6b, 0x1e6b,
-	0x1e6d, 0x1e6d,
-	0x1e6f, 0x1e6f,
-	0x1e71, 0x1e71,
-	0x1e73, 0x1e73,
-	0x1e75, 0x1e75,
-	0x1e77, 0x1e77,
-	0x1e79, 0x1e79,
-	0x1e7b, 0x1e7b,
-	0x1e7d, 0x1e7d,
-	0x1e7f, 0x1e7f,
-	0x1e81, 0x1e81,
-	0x1e83, 0x1e83,
-	0x1e85, 0x1e85,
-	0x1e87, 0x1e87,
-	0x1e89, 0x1e89,
-	0x1e8b, 0x1e8b,
-	0x1e8d, 0x1e8d,
-	0x1e8f, 0x1e8f,
-	0x1e91, 0x1e91,
-	0x1e93, 0x1e93,
-	0x1e95, 0x1e9d,
-	0x1e9f, 0x1e9f,
-	0x1ea1, 0x1ea1,
-	0x1ea3, 0x1ea3,
-	0x1ea5, 0x1ea5,
-	0x1ea7, 0x1ea7,
-	0x1ea9, 0x1ea9,
-	0x1eab, 0x1eab,
-	0x1ead, 0x1ead,
-	0x1eaf, 0x1eaf,
-	0x1eb1, 0x1eb1,
-	0x1eb3, 0x1eb3,
-	0x1eb5, 0x1eb5,
-	0x1eb7, 0x1eb7,
-	0x1eb9, 0x1eb9,
-	0x1ebb, 0x1ebb,
-	0x1ebd, 0x1ebd,
-	0x1ebf, 0x1ebf,
-	0x1ec1, 0x1ec1,
-	0x1ec3, 0x1ec3,
-	0x1ec5, 0x1ec5,
-	0x1ec7, 0x1ec7,
-	0x1ec9, 0x1ec9,
-	0x1ecb, 0x1ecb,
-	0x1ecd, 0x1ecd,
-	0x1ecf, 0x1ecf,
-	0x1ed1, 0x1ed1,
-	0x1ed3, 0x1ed3,
-	0x1ed5, 0x1ed5,
-	0x1ed7, 0x1ed7,
-	0x1ed9, 0x1ed9,
-	0x1edb, 0x1edb,
-	0x1edd, 0x1edd,
-	0x1edf, 0x1edf,
-	0x1ee1, 0x1ee1,
-	0x1ee3, 0x1ee3,
-	0x1ee5, 0x1ee5,
-	0x1ee7, 0x1ee7,
-	0x1ee9, 0x1ee9,
-	0x1eeb, 0x1eeb,
-	0x1eed, 0x1eed,
-	0x1eef, 0x1eef,
-	0x1ef1, 0x1ef1,
-	0x1ef3, 0x1ef3,
-	0x1ef5, 0x1ef5,
-	0x1ef7, 0x1ef7,
-	0x1ef9, 0x1ef9,
-	0x1efb, 0x1efb,
-	0x1efd, 0x1efd,
-	0x1eff, 0x1f07,
-	0x1f10, 0x1f15,
-	0x1f20, 0x1f27,
-	0x1f30, 0x1f37,
-	0x1f40, 0x1f45,
-	0x1f50, 0x1f57,
-	0x1f60, 0x1f67,
-	0x1f70, 0x1f7d,
-	0x1f80, 0x1f87,
-	0x1f90, 0x1f97,
-	0x1fa0, 0x1fa7,
-	0x1fb0, 0x1fb4,
-	0x1fb6, 0x1fb7,
-	0x1fbe, 0x1fbe,
-	0x1fc2, 0x1fc4,
-	0x1fc6, 0x1fc7,
-	0x1fd0, 0x1fd3,
-	0x1fd6, 0x1fd7,
-	0x1fe0, 0x1fe7,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ff7,
-	0x210a, 0x210a,
-	0x210e, 0x210f,
-	0x2113, 0x2113,
-	0x212f, 0x212f,
-	0x2134, 0x2134,
-	0x2139, 0x2139,
-	0x213c, 0x213d,
-	0x2146, 0x2149,
-	0x214e, 0x214e,
-	0x2184, 0x2184,
-	0x2c30, 0x2c5e,
-	0x2c61, 0x2c61,
-	0x2c65, 0x2c66,
-	0x2c68, 0x2c68,
-	0x2c6a, 0x2c6a,
-	0x2c6c, 0x2c6c,
-	0x2c71, 0x2c71,
-	0x2c73, 0x2c74,
-	0x2c76, 0x2c7c,
-	0x2c81, 0x2c81,
-	0x2c83, 0x2c83,
-	0x2c85, 0x2c85,
-	0x2c87, 0x2c87,
-	0x2c89, 0x2c89,
-	0x2c8b, 0x2c8b,
-	0x2c8d, 0x2c8d,
-	0x2c8f, 0x2c8f,
-	0x2c91, 0x2c91,
-	0x2c93, 0x2c93,
-	0x2c95, 0x2c95,
-	0x2c97, 0x2c97,
-	0x2c99, 0x2c99,
-	0x2c9b, 0x2c9b,
-	0x2c9d, 0x2c9d,
-	0x2c9f, 0x2c9f,
-	0x2ca1, 0x2ca1,
-	0x2ca3, 0x2ca3,
-	0x2ca5, 0x2ca5,
-	0x2ca7, 0x2ca7,
-	0x2ca9, 0x2ca9,
-	0x2cab, 0x2cab,
-	0x2cad, 0x2cad,
-	0x2caf, 0x2caf,
-	0x2cb1, 0x2cb1,
-	0x2cb3, 0x2cb3,
-	0x2cb5, 0x2cb5,
-	0x2cb7, 0x2cb7,
-	0x2cb9, 0x2cb9,
-	0x2cbb, 0x2cbb,
-	0x2cbd, 0x2cbd,
-	0x2cbf, 0x2cbf,
-	0x2cc1, 0x2cc1,
-	0x2cc3, 0x2cc3,
-	0x2cc5, 0x2cc5,
-	0x2cc7, 0x2cc7,
-	0x2cc9, 0x2cc9,
-	0x2ccb, 0x2ccb,
-	0x2ccd, 0x2ccd,
-	0x2ccf, 0x2ccf,
-	0x2cd1, 0x2cd1,
-	0x2cd3, 0x2cd3,
-	0x2cd5, 0x2cd5,
-	0x2cd7, 0x2cd7,
-	0x2cd9, 0x2cd9,
-	0x2cdb, 0x2cdb,
-	0x2cdd, 0x2cdd,
-	0x2cdf, 0x2cdf,
-	0x2ce1, 0x2ce1,
-	0x2ce3, 0x2ce4,
-	0x2cec, 0x2cec,
-	0x2cee, 0x2cee,
-	0x2d00, 0x2d25,
-	0xa641, 0xa641,
-	0xa643, 0xa643,
-	0xa645, 0xa645,
-	0xa647, 0xa647,
-	0xa649, 0xa649,
-	0xa64b, 0xa64b,
-	0xa64d, 0xa64d,
-	0xa64f, 0xa64f,
-	0xa651, 0xa651,
-	0xa653, 0xa653,
-	0xa655, 0xa655,
-	0xa657, 0xa657,
-	0xa659, 0xa659,
-	0xa65b, 0xa65b,
-	0xa65d, 0xa65d,
-	0xa65f, 0xa65f,
-	0xa663, 0xa663,
-	0xa665, 0xa665,
-	0xa667, 0xa667,
-	0xa669, 0xa669,
-	0xa66b, 0xa66b,
-	0xa66d, 0xa66d,
-	0xa681, 0xa681,
-	0xa683, 0xa683,
-	0xa685, 0xa685,
-	0xa687, 0xa687,
-	0xa689, 0xa689,
-	0xa68b, 0xa68b,
-	0xa68d, 0xa68d,
-	0xa68f, 0xa68f,
-	0xa691, 0xa691,
-	0xa693, 0xa693,
-	0xa695, 0xa695,
-	0xa697, 0xa697,
-	0xa723, 0xa723,
-	0xa725, 0xa725,
-	0xa727, 0xa727,
-	0xa729, 0xa729,
-	0xa72b, 0xa72b,
-	0xa72d, 0xa72d,
-	0xa72f, 0xa731,
-	0xa733, 0xa733,
-	0xa735, 0xa735,
-	0xa737, 0xa737,
-	0xa739, 0xa739,
-	0xa73b, 0xa73b,
-	0xa73d, 0xa73d,
-	0xa73f, 0xa73f,
-	0xa741, 0xa741,
-	0xa743, 0xa743,
-	0xa745, 0xa745,
-	0xa747, 0xa747,
-	0xa749, 0xa749,
-	0xa74b, 0xa74b,
-	0xa74d, 0xa74d,
-	0xa74f, 0xa74f,
-	0xa751, 0xa751,
-	0xa753, 0xa753,
-	0xa755, 0xa755,
-	0xa757, 0xa757,
-	0xa759, 0xa759,
-	0xa75b, 0xa75b,
-	0xa75d, 0xa75d,
-	0xa75f, 0xa75f,
-	0xa761, 0xa761,
-	0xa763, 0xa763,
-	0xa765, 0xa765,
-	0xa767, 0xa767,
-	0xa769, 0xa769,
-	0xa76b, 0xa76b,
-	0xa76d, 0xa76d,
-	0xa76f, 0xa76f,
-	0xa771, 0xa778,
-	0xa77a, 0xa77a,
-	0xa77c, 0xa77c,
-	0xa77f, 0xa77f,
-	0xa781, 0xa781,
-	0xa783, 0xa783,
-	0xa785, 0xa785,
-	0xa787, 0xa787,
-	0xa78c, 0xa78c,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xff41, 0xff5a,
-	0x10428, 0x1044f,
-	0x1d41a, 0x1d433,
-	0x1d44e, 0x1d454,
-	0x1d456, 0x1d467,
-	0x1d482, 0x1d49b,
-	0x1d4b6, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d4cf,
-	0x1d4ea, 0x1d503,
-	0x1d51e, 0x1d537,
-	0x1d552, 0x1d56b,
-	0x1d586, 0x1d59f,
-	0x1d5ba, 0x1d5d3,
-	0x1d5ee, 0x1d607,
-	0x1d622, 0x1d63b,
-	0x1d656, 0x1d66f,
-	0x1d68a, 0x1d6a5,
-	0x1d6c2, 0x1d6da,
-	0x1d6dc, 0x1d6e1,
-	0x1d6fc, 0x1d714,
-	0x1d716, 0x1d71b,
-	0x1d736, 0x1d74e,
-	0x1d750, 0x1d755,
-	0x1d770, 0x1d788,
-	0x1d78a, 0x1d78f,
-	0x1d7aa, 0x1d7c2,
-	0x1d7c4, 0x1d7c9,
-	0x1d7cb, 0x1d7cb,
+        599,
+        0x0061, 0x007a,
+        0x00aa, 0x00aa,
+        0x00b5, 0x00b5,
+        0x00ba, 0x00ba,
+        0x00df, 0x00f6,
+        0x00f8, 0x00ff,
+        0x0101, 0x0101,
+        0x0103, 0x0103,
+        0x0105, 0x0105,
+        0x0107, 0x0107,
+        0x0109, 0x0109,
+        0x010b, 0x010b,
+        0x010d, 0x010d,
+        0x010f, 0x010f,
+        0x0111, 0x0111,
+        0x0113, 0x0113,
+        0x0115, 0x0115,
+        0x0117, 0x0117,
+        0x0119, 0x0119,
+        0x011b, 0x011b,
+        0x011d, 0x011d,
+        0x011f, 0x011f,
+        0x0121, 0x0121,
+        0x0123, 0x0123,
+        0x0125, 0x0125,
+        0x0127, 0x0127,
+        0x0129, 0x0129,
+        0x012b, 0x012b,
+        0x012d, 0x012d,
+        0x012f, 0x012f,
+        0x0131, 0x0131,
+        0x0133, 0x0133,
+        0x0135, 0x0135,
+        0x0137, 0x0138,
+        0x013a, 0x013a,
+        0x013c, 0x013c,
+        0x013e, 0x013e,
+        0x0140, 0x0140,
+        0x0142, 0x0142,
+        0x0144, 0x0144,
+        0x0146, 0x0146,
+        0x0148, 0x0149,
+        0x014b, 0x014b,
+        0x014d, 0x014d,
+        0x014f, 0x014f,
+        0x0151, 0x0151,
+        0x0153, 0x0153,
+        0x0155, 0x0155,
+        0x0157, 0x0157,
+        0x0159, 0x0159,
+        0x015b, 0x015b,
+        0x015d, 0x015d,
+        0x015f, 0x015f,
+        0x0161, 0x0161,
+        0x0163, 0x0163,
+        0x0165, 0x0165,
+        0x0167, 0x0167,
+        0x0169, 0x0169,
+        0x016b, 0x016b,
+        0x016d, 0x016d,
+        0x016f, 0x016f,
+        0x0171, 0x0171,
+        0x0173, 0x0173,
+        0x0175, 0x0175,
+        0x0177, 0x0177,
+        0x017a, 0x017a,
+        0x017c, 0x017c,
+        0x017e, 0x0180,
+        0x0183, 0x0183,
+        0x0185, 0x0185,
+        0x0188, 0x0188,
+        0x018c, 0x018d,
+        0x0192, 0x0192,
+        0x0195, 0x0195,
+        0x0199, 0x019b,
+        0x019e, 0x019e,
+        0x01a1, 0x01a1,
+        0x01a3, 0x01a3,
+        0x01a5, 0x01a5,
+        0x01a8, 0x01a8,
+        0x01aa, 0x01ab,
+        0x01ad, 0x01ad,
+        0x01b0, 0x01b0,
+        0x01b4, 0x01b4,
+        0x01b6, 0x01b6,
+        0x01b9, 0x01ba,
+        0x01bd, 0x01bf,
+        0x01c6, 0x01c6,
+        0x01c9, 0x01c9,
+        0x01cc, 0x01cc,
+        0x01ce, 0x01ce,
+        0x01d0, 0x01d0,
+        0x01d2, 0x01d2,
+        0x01d4, 0x01d4,
+        0x01d6, 0x01d6,
+        0x01d8, 0x01d8,
+        0x01da, 0x01da,
+        0x01dc, 0x01dd,
+        0x01df, 0x01df,
+        0x01e1, 0x01e1,
+        0x01e3, 0x01e3,
+        0x01e5, 0x01e5,
+        0x01e7, 0x01e7,
+        0x01e9, 0x01e9,
+        0x01eb, 0x01eb,
+        0x01ed, 0x01ed,
+        0x01ef, 0x01f0,
+        0x01f3, 0x01f3,
+        0x01f5, 0x01f5,
+        0x01f9, 0x01f9,
+        0x01fb, 0x01fb,
+        0x01fd, 0x01fd,
+        0x01ff, 0x01ff,
+        0x0201, 0x0201,
+        0x0203, 0x0203,
+        0x0205, 0x0205,
+        0x0207, 0x0207,
+        0x0209, 0x0209,
+        0x020b, 0x020b,
+        0x020d, 0x020d,
+        0x020f, 0x020f,
+        0x0211, 0x0211,
+        0x0213, 0x0213,
+        0x0215, 0x0215,
+        0x0217, 0x0217,
+        0x0219, 0x0219,
+        0x021b, 0x021b,
+        0x021d, 0x021d,
+        0x021f, 0x021f,
+        0x0221, 0x0221,
+        0x0223, 0x0223,
+        0x0225, 0x0225,
+        0x0227, 0x0227,
+        0x0229, 0x0229,
+        0x022b, 0x022b,
+        0x022d, 0x022d,
+        0x022f, 0x022f,
+        0x0231, 0x0231,
+        0x0233, 0x0239,
+        0x023c, 0x023c,
+        0x023f, 0x0240,
+        0x0242, 0x0242,
+        0x0247, 0x0247,
+        0x0249, 0x0249,
+        0x024b, 0x024b,
+        0x024d, 0x024d,
+        0x024f, 0x0293,
+        0x0295, 0x02af,
+        0x0371, 0x0371,
+        0x0373, 0x0373,
+        0x0377, 0x0377,
+        0x037b, 0x037d,
+        0x0390, 0x0390,
+        0x03ac, 0x03ce,
+        0x03d0, 0x03d1,
+        0x03d5, 0x03d7,
+        0x03d9, 0x03d9,
+        0x03db, 0x03db,
+        0x03dd, 0x03dd,
+        0x03df, 0x03df,
+        0x03e1, 0x03e1,
+        0x03e3, 0x03e3,
+        0x03e5, 0x03e5,
+        0x03e7, 0x03e7,
+        0x03e9, 0x03e9,
+        0x03eb, 0x03eb,
+        0x03ed, 0x03ed,
+        0x03ef, 0x03f3,
+        0x03f5, 0x03f5,
+        0x03f8, 0x03f8,
+        0x03fb, 0x03fc,
+        0x0430, 0x045f,
+        0x0461, 0x0461,
+        0x0463, 0x0463,
+        0x0465, 0x0465,
+        0x0467, 0x0467,
+        0x0469, 0x0469,
+        0x046b, 0x046b,
+        0x046d, 0x046d,
+        0x046f, 0x046f,
+        0x0471, 0x0471,
+        0x0473, 0x0473,
+        0x0475, 0x0475,
+        0x0477, 0x0477,
+        0x0479, 0x0479,
+        0x047b, 0x047b,
+        0x047d, 0x047d,
+        0x047f, 0x047f,
+        0x0481, 0x0481,
+        0x048b, 0x048b,
+        0x048d, 0x048d,
+        0x048f, 0x048f,
+        0x0491, 0x0491,
+        0x0493, 0x0493,
+        0x0495, 0x0495,
+        0x0497, 0x0497,
+        0x0499, 0x0499,
+        0x049b, 0x049b,
+        0x049d, 0x049d,
+        0x049f, 0x049f,
+        0x04a1, 0x04a1,
+        0x04a3, 0x04a3,
+        0x04a5, 0x04a5,
+        0x04a7, 0x04a7,
+        0x04a9, 0x04a9,
+        0x04ab, 0x04ab,
+        0x04ad, 0x04ad,
+        0x04af, 0x04af,
+        0x04b1, 0x04b1,
+        0x04b3, 0x04b3,
+        0x04b5, 0x04b5,
+        0x04b7, 0x04b7,
+        0x04b9, 0x04b9,
+        0x04bb, 0x04bb,
+        0x04bd, 0x04bd,
+        0x04bf, 0x04bf,
+        0x04c2, 0x04c2,
+        0x04c4, 0x04c4,
+        0x04c6, 0x04c6,
+        0x04c8, 0x04c8,
+        0x04ca, 0x04ca,
+        0x04cc, 0x04cc,
+        0x04ce, 0x04cf,
+        0x04d1, 0x04d1,
+        0x04d3, 0x04d3,
+        0x04d5, 0x04d5,
+        0x04d7, 0x04d7,
+        0x04d9, 0x04d9,
+        0x04db, 0x04db,
+        0x04dd, 0x04dd,
+        0x04df, 0x04df,
+        0x04e1, 0x04e1,
+        0x04e3, 0x04e3,
+        0x04e5, 0x04e5,
+        0x04e7, 0x04e7,
+        0x04e9, 0x04e9,
+        0x04eb, 0x04eb,
+        0x04ed, 0x04ed,
+        0x04ef, 0x04ef,
+        0x04f1, 0x04f1,
+        0x04f3, 0x04f3,
+        0x04f5, 0x04f5,
+        0x04f7, 0x04f7,
+        0x04f9, 0x04f9,
+        0x04fb, 0x04fb,
+        0x04fd, 0x04fd,
+        0x04ff, 0x04ff,
+        0x0501, 0x0501,
+        0x0503, 0x0503,
+        0x0505, 0x0505,
+        0x0507, 0x0507,
+        0x0509, 0x0509,
+        0x050b, 0x050b,
+        0x050d, 0x050d,
+        0x050f, 0x050f,
+        0x0511, 0x0511,
+        0x0513, 0x0513,
+        0x0515, 0x0515,
+        0x0517, 0x0517,
+        0x0519, 0x0519,
+        0x051b, 0x051b,
+        0x051d, 0x051d,
+        0x051f, 0x051f,
+        0x0521, 0x0521,
+        0x0523, 0x0523,
+        0x0525, 0x0525,
+        0x0561, 0x0587,
+        0x1d00, 0x1d2b,
+        0x1d62, 0x1d77,
+        0x1d79, 0x1d9a,
+        0x1e01, 0x1e01,
+        0x1e03, 0x1e03,
+        0x1e05, 0x1e05,
+        0x1e07, 0x1e07,
+        0x1e09, 0x1e09,
+        0x1e0b, 0x1e0b,
+        0x1e0d, 0x1e0d,
+        0x1e0f, 0x1e0f,
+        0x1e11, 0x1e11,
+        0x1e13, 0x1e13,
+        0x1e15, 0x1e15,
+        0x1e17, 0x1e17,
+        0x1e19, 0x1e19,
+        0x1e1b, 0x1e1b,
+        0x1e1d, 0x1e1d,
+        0x1e1f, 0x1e1f,
+        0x1e21, 0x1e21,
+        0x1e23, 0x1e23,
+        0x1e25, 0x1e25,
+        0x1e27, 0x1e27,
+        0x1e29, 0x1e29,
+        0x1e2b, 0x1e2b,
+        0x1e2d, 0x1e2d,
+        0x1e2f, 0x1e2f,
+        0x1e31, 0x1e31,
+        0x1e33, 0x1e33,
+        0x1e35, 0x1e35,
+        0x1e37, 0x1e37,
+        0x1e39, 0x1e39,
+        0x1e3b, 0x1e3b,
+        0x1e3d, 0x1e3d,
+        0x1e3f, 0x1e3f,
+        0x1e41, 0x1e41,
+        0x1e43, 0x1e43,
+        0x1e45, 0x1e45,
+        0x1e47, 0x1e47,
+        0x1e49, 0x1e49,
+        0x1e4b, 0x1e4b,
+        0x1e4d, 0x1e4d,
+        0x1e4f, 0x1e4f,
+        0x1e51, 0x1e51,
+        0x1e53, 0x1e53,
+        0x1e55, 0x1e55,
+        0x1e57, 0x1e57,
+        0x1e59, 0x1e59,
+        0x1e5b, 0x1e5b,
+        0x1e5d, 0x1e5d,
+        0x1e5f, 0x1e5f,
+        0x1e61, 0x1e61,
+        0x1e63, 0x1e63,
+        0x1e65, 0x1e65,
+        0x1e67, 0x1e67,
+        0x1e69, 0x1e69,
+        0x1e6b, 0x1e6b,
+        0x1e6d, 0x1e6d,
+        0x1e6f, 0x1e6f,
+        0x1e71, 0x1e71,
+        0x1e73, 0x1e73,
+        0x1e75, 0x1e75,
+        0x1e77, 0x1e77,
+        0x1e79, 0x1e79,
+        0x1e7b, 0x1e7b,
+        0x1e7d, 0x1e7d,
+        0x1e7f, 0x1e7f,
+        0x1e81, 0x1e81,
+        0x1e83, 0x1e83,
+        0x1e85, 0x1e85,
+        0x1e87, 0x1e87,
+        0x1e89, 0x1e89,
+        0x1e8b, 0x1e8b,
+        0x1e8d, 0x1e8d,
+        0x1e8f, 0x1e8f,
+        0x1e91, 0x1e91,
+        0x1e93, 0x1e93,
+        0x1e95, 0x1e9d,
+        0x1e9f, 0x1e9f,
+        0x1ea1, 0x1ea1,
+        0x1ea3, 0x1ea3,
+        0x1ea5, 0x1ea5,
+        0x1ea7, 0x1ea7,
+        0x1ea9, 0x1ea9,
+        0x1eab, 0x1eab,
+        0x1ead, 0x1ead,
+        0x1eaf, 0x1eaf,
+        0x1eb1, 0x1eb1,
+        0x1eb3, 0x1eb3,
+        0x1eb5, 0x1eb5,
+        0x1eb7, 0x1eb7,
+        0x1eb9, 0x1eb9,
+        0x1ebb, 0x1ebb,
+        0x1ebd, 0x1ebd,
+        0x1ebf, 0x1ebf,
+        0x1ec1, 0x1ec1,
+        0x1ec3, 0x1ec3,
+        0x1ec5, 0x1ec5,
+        0x1ec7, 0x1ec7,
+        0x1ec9, 0x1ec9,
+        0x1ecb, 0x1ecb,
+        0x1ecd, 0x1ecd,
+        0x1ecf, 0x1ecf,
+        0x1ed1, 0x1ed1,
+        0x1ed3, 0x1ed3,
+        0x1ed5, 0x1ed5,
+        0x1ed7, 0x1ed7,
+        0x1ed9, 0x1ed9,
+        0x1edb, 0x1edb,
+        0x1edd, 0x1edd,
+        0x1edf, 0x1edf,
+        0x1ee1, 0x1ee1,
+        0x1ee3, 0x1ee3,
+        0x1ee5, 0x1ee5,
+        0x1ee7, 0x1ee7,
+        0x1ee9, 0x1ee9,
+        0x1eeb, 0x1eeb,
+        0x1eed, 0x1eed,
+        0x1eef, 0x1eef,
+        0x1ef1, 0x1ef1,
+        0x1ef3, 0x1ef3,
+        0x1ef5, 0x1ef5,
+        0x1ef7, 0x1ef7,
+        0x1ef9, 0x1ef9,
+        0x1efb, 0x1efb,
+        0x1efd, 0x1efd,
+        0x1eff, 0x1f07,
+        0x1f10, 0x1f15,
+        0x1f20, 0x1f27,
+        0x1f30, 0x1f37,
+        0x1f40, 0x1f45,
+        0x1f50, 0x1f57,
+        0x1f60, 0x1f67,
+        0x1f70, 0x1f7d,
+        0x1f80, 0x1f87,
+        0x1f90, 0x1f97,
+        0x1fa0, 0x1fa7,
+        0x1fb0, 0x1fb4,
+        0x1fb6, 0x1fb7,
+        0x1fbe, 0x1fbe,
+        0x1fc2, 0x1fc4,
+        0x1fc6, 0x1fc7,
+        0x1fd0, 0x1fd3,
+        0x1fd6, 0x1fd7,
+        0x1fe0, 0x1fe7,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ff7,
+        0x210a, 0x210a,
+        0x210e, 0x210f,
+        0x2113, 0x2113,
+        0x212f, 0x212f,
+        0x2134, 0x2134,
+        0x2139, 0x2139,
+        0x213c, 0x213d,
+        0x2146, 0x2149,
+        0x214e, 0x214e,
+        0x2184, 0x2184,
+        0x2c30, 0x2c5e,
+        0x2c61, 0x2c61,
+        0x2c65, 0x2c66,
+        0x2c68, 0x2c68,
+        0x2c6a, 0x2c6a,
+        0x2c6c, 0x2c6c,
+        0x2c71, 0x2c71,
+        0x2c73, 0x2c74,
+        0x2c76, 0x2c7c,
+        0x2c81, 0x2c81,
+        0x2c83, 0x2c83,
+        0x2c85, 0x2c85,
+        0x2c87, 0x2c87,
+        0x2c89, 0x2c89,
+        0x2c8b, 0x2c8b,
+        0x2c8d, 0x2c8d,
+        0x2c8f, 0x2c8f,
+        0x2c91, 0x2c91,
+        0x2c93, 0x2c93,
+        0x2c95, 0x2c95,
+        0x2c97, 0x2c97,
+        0x2c99, 0x2c99,
+        0x2c9b, 0x2c9b,
+        0x2c9d, 0x2c9d,
+        0x2c9f, 0x2c9f,
+        0x2ca1, 0x2ca1,
+        0x2ca3, 0x2ca3,
+        0x2ca5, 0x2ca5,
+        0x2ca7, 0x2ca7,
+        0x2ca9, 0x2ca9,
+        0x2cab, 0x2cab,
+        0x2cad, 0x2cad,
+        0x2caf, 0x2caf,
+        0x2cb1, 0x2cb1,
+        0x2cb3, 0x2cb3,
+        0x2cb5, 0x2cb5,
+        0x2cb7, 0x2cb7,
+        0x2cb9, 0x2cb9,
+        0x2cbb, 0x2cbb,
+        0x2cbd, 0x2cbd,
+        0x2cbf, 0x2cbf,
+        0x2cc1, 0x2cc1,
+        0x2cc3, 0x2cc3,
+        0x2cc5, 0x2cc5,
+        0x2cc7, 0x2cc7,
+        0x2cc9, 0x2cc9,
+        0x2ccb, 0x2ccb,
+        0x2ccd, 0x2ccd,
+        0x2ccf, 0x2ccf,
+        0x2cd1, 0x2cd1,
+        0x2cd3, 0x2cd3,
+        0x2cd5, 0x2cd5,
+        0x2cd7, 0x2cd7,
+        0x2cd9, 0x2cd9,
+        0x2cdb, 0x2cdb,
+        0x2cdd, 0x2cdd,
+        0x2cdf, 0x2cdf,
+        0x2ce1, 0x2ce1,
+        0x2ce3, 0x2ce4,
+        0x2cec, 0x2cec,
+        0x2cee, 0x2cee,
+        0x2d00, 0x2d25,
+        0xa641, 0xa641,
+        0xa643, 0xa643,
+        0xa645, 0xa645,
+        0xa647, 0xa647,
+        0xa649, 0xa649,
+        0xa64b, 0xa64b,
+        0xa64d, 0xa64d,
+        0xa64f, 0xa64f,
+        0xa651, 0xa651,
+        0xa653, 0xa653,
+        0xa655, 0xa655,
+        0xa657, 0xa657,
+        0xa659, 0xa659,
+        0xa65b, 0xa65b,
+        0xa65d, 0xa65d,
+        0xa65f, 0xa65f,
+        0xa663, 0xa663,
+        0xa665, 0xa665,
+        0xa667, 0xa667,
+        0xa669, 0xa669,
+        0xa66b, 0xa66b,
+        0xa66d, 0xa66d,
+        0xa681, 0xa681,
+        0xa683, 0xa683,
+        0xa685, 0xa685,
+        0xa687, 0xa687,
+        0xa689, 0xa689,
+        0xa68b, 0xa68b,
+        0xa68d, 0xa68d,
+        0xa68f, 0xa68f,
+        0xa691, 0xa691,
+        0xa693, 0xa693,
+        0xa695, 0xa695,
+        0xa697, 0xa697,
+        0xa723, 0xa723,
+        0xa725, 0xa725,
+        0xa727, 0xa727,
+        0xa729, 0xa729,
+        0xa72b, 0xa72b,
+        0xa72d, 0xa72d,
+        0xa72f, 0xa731,
+        0xa733, 0xa733,
+        0xa735, 0xa735,
+        0xa737, 0xa737,
+        0xa739, 0xa739,
+        0xa73b, 0xa73b,
+        0xa73d, 0xa73d,
+        0xa73f, 0xa73f,
+        0xa741, 0xa741,
+        0xa743, 0xa743,
+        0xa745, 0xa745,
+        0xa747, 0xa747,
+        0xa749, 0xa749,
+        0xa74b, 0xa74b,
+        0xa74d, 0xa74d,
+        0xa74f, 0xa74f,
+        0xa751, 0xa751,
+        0xa753, 0xa753,
+        0xa755, 0xa755,
+        0xa757, 0xa757,
+        0xa759, 0xa759,
+        0xa75b, 0xa75b,
+        0xa75d, 0xa75d,
+        0xa75f, 0xa75f,
+        0xa761, 0xa761,
+        0xa763, 0xa763,
+        0xa765, 0xa765,
+        0xa767, 0xa767,
+        0xa769, 0xa769,
+        0xa76b, 0xa76b,
+        0xa76d, 0xa76d,
+        0xa76f, 0xa76f,
+        0xa771, 0xa778,
+        0xa77a, 0xa77a,
+        0xa77c, 0xa77c,
+        0xa77f, 0xa77f,
+        0xa781, 0xa781,
+        0xa783, 0xa783,
+        0xa785, 0xa785,
+        0xa787, 0xa787,
+        0xa78c, 0xa78c,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xff41, 0xff5a,
+        0x10428, 0x1044f,
+        0x1d41a, 0x1d433,
+        0x1d44e, 0x1d454,
+        0x1d456, 0x1d467,
+        0x1d482, 0x1d49b,
+        0x1d4b6, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d4cf,
+        0x1d4ea, 0x1d503,
+        0x1d51e, 0x1d537,
+        0x1d552, 0x1d56b,
+        0x1d586, 0x1d59f,
+        0x1d5ba, 0x1d5d3,
+        0x1d5ee, 0x1d607,
+        0x1d622, 0x1d63b,
+        0x1d656, 0x1d66f,
+        0x1d68a, 0x1d6a5,
+        0x1d6c2, 0x1d6da,
+        0x1d6dc, 0x1d6e1,
+        0x1d6fc, 0x1d714,
+        0x1d716, 0x1d71b,
+        0x1d736, 0x1d74e,
+        0x1d750, 0x1d755,
+        0x1d770, 0x1d788,
+        0x1d78a, 0x1d78f,
+        0x1d7aa, 0x1d7c2,
+        0x1d7c4, 0x1d7c9,
+        0x1d7cb, 0x1d7cb,
 }; /* CR_Ll */
 
 /* 'Lm': General Category */
 static const OnigCodePoint CR_Lm[] = {
-	49,
-	0x02b0, 0x02c1,
-	0x02c6, 0x02d1,
-	0x02e0, 0x02e4,
-	0x02ec, 0x02ec,
-	0x02ee, 0x02ee,
-	0x0374, 0x0374,
-	0x037a, 0x037a,
-	0x0559, 0x0559,
-	0x0640, 0x0640,
-	0x06e5, 0x06e6,
-	0x07f4, 0x07f5,
-	0x07fa, 0x07fa,
-	0x081a, 0x081a,
-	0x0824, 0x0824,
-	0x0828, 0x0828,
-	0x0971, 0x0971,
-	0x0e46, 0x0e46,
-	0x0ec6, 0x0ec6,
-	0x10fc, 0x10fc,
-	0x17d7, 0x17d7,
-	0x1843, 0x1843,
-	0x1aa7, 0x1aa7,
-	0x1c78, 0x1c7d,
-	0x1d2c, 0x1d61,
-	0x1d78, 0x1d78,
-	0x1d9b, 0x1dbf,
-	0x2071, 0x2071,
-	0x207f, 0x207f,
-	0x2090, 0x2094,
-	0x2c7d, 0x2c7d,
-	0x2d6f, 0x2d6f,
-	0x2e2f, 0x2e2f,
-	0x3005, 0x3005,
-	0x3031, 0x3035,
-	0x303b, 0x303b,
-	0x309d, 0x309e,
-	0x30fc, 0x30fe,
-	0xa015, 0xa015,
-	0xa4f8, 0xa4fd,
-	0xa60c, 0xa60c,
-	0xa67f, 0xa67f,
-	0xa717, 0xa71f,
-	0xa770, 0xa770,
-	0xa788, 0xa788,
-	0xa9cf, 0xa9cf,
-	0xaa70, 0xaa70,
-	0xaadd, 0xaadd,
-	0xff70, 0xff70,
-	0xff9e, 0xff9f,
+        49,
+        0x02b0, 0x02c1,
+        0x02c6, 0x02d1,
+        0x02e0, 0x02e4,
+        0x02ec, 0x02ec,
+        0x02ee, 0x02ee,
+        0x0374, 0x0374,
+        0x037a, 0x037a,
+        0x0559, 0x0559,
+        0x0640, 0x0640,
+        0x06e5, 0x06e6,
+        0x07f4, 0x07f5,
+        0x07fa, 0x07fa,
+        0x081a, 0x081a,
+        0x0824, 0x0824,
+        0x0828, 0x0828,
+        0x0971, 0x0971,
+        0x0e46, 0x0e46,
+        0x0ec6, 0x0ec6,
+        0x10fc, 0x10fc,
+        0x17d7, 0x17d7,
+        0x1843, 0x1843,
+        0x1aa7, 0x1aa7,
+        0x1c78, 0x1c7d,
+        0x1d2c, 0x1d61,
+        0x1d78, 0x1d78,
+        0x1d9b, 0x1dbf,
+        0x2071, 0x2071,
+        0x207f, 0x207f,
+        0x2090, 0x2094,
+        0x2c7d, 0x2c7d,
+        0x2d6f, 0x2d6f,
+        0x2e2f, 0x2e2f,
+        0x3005, 0x3005,
+        0x3031, 0x3035,
+        0x303b, 0x303b,
+        0x309d, 0x309e,
+        0x30fc, 0x30fe,
+        0xa015, 0xa015,
+        0xa4f8, 0xa4fd,
+        0xa60c, 0xa60c,
+        0xa67f, 0xa67f,
+        0xa717, 0xa71f,
+        0xa770, 0xa770,
+        0xa788, 0xa788,
+        0xa9cf, 0xa9cf,
+        0xaa70, 0xaa70,
+        0xaadd, 0xaadd,
+        0xff70, 0xff70,
+        0xff9e, 0xff9f,
 }; /* CR_Lm */
 
 /* 'Lo': General Category */
 static const OnigCodePoint CR_Lo[] = {
-	311,
-	0x01bb, 0x01bb,
-	0x01c0, 0x01c3,
-	0x0294, 0x0294,
-	0x05d0, 0x05ea,
-	0x05f0, 0x05f2,
-	0x0621, 0x063f,
-	0x0641, 0x064a,
-	0x066e, 0x066f,
-	0x0671, 0x06d3,
-	0x06d5, 0x06d5,
-	0x06ee, 0x06ef,
-	0x06fa, 0x06fc,
-	0x06ff, 0x06ff,
-	0x0710, 0x0710,
-	0x0712, 0x072f,
-	0x074d, 0x07a5,
-	0x07b1, 0x07b1,
-	0x07ca, 0x07ea,
-	0x0800, 0x0815,
-	0x0904, 0x0939,
-	0x093d, 0x093d,
-	0x0950, 0x0950,
-	0x0958, 0x0961,
-	0x0972, 0x0972,
-	0x0979, 0x097f,
-	0x0985, 0x098c,
-	0x098f, 0x0990,
-	0x0993, 0x09a8,
-	0x09aa, 0x09b0,
-	0x09b2, 0x09b2,
-	0x09b6, 0x09b9,
-	0x09bd, 0x09bd,
-	0x09ce, 0x09ce,
-	0x09dc, 0x09dd,
-	0x09df, 0x09e1,
-	0x09f0, 0x09f1,
-	0x0a05, 0x0a0a,
-	0x0a0f, 0x0a10,
-	0x0a13, 0x0a28,
-	0x0a2a, 0x0a30,
-	0x0a32, 0x0a33,
-	0x0a35, 0x0a36,
-	0x0a38, 0x0a39,
-	0x0a59, 0x0a5c,
-	0x0a5e, 0x0a5e,
-	0x0a72, 0x0a74,
-	0x0a85, 0x0a8d,
-	0x0a8f, 0x0a91,
-	0x0a93, 0x0aa8,
-	0x0aaa, 0x0ab0,
-	0x0ab2, 0x0ab3,
-	0x0ab5, 0x0ab9,
-	0x0abd, 0x0abd,
-	0x0ad0, 0x0ad0,
-	0x0ae0, 0x0ae1,
-	0x0b05, 0x0b0c,
-	0x0b0f, 0x0b10,
-	0x0b13, 0x0b28,
-	0x0b2a, 0x0b30,
-	0x0b32, 0x0b33,
-	0x0b35, 0x0b39,
-	0x0b3d, 0x0b3d,
-	0x0b5c, 0x0b5d,
-	0x0b5f, 0x0b61,
-	0x0b71, 0x0b71,
-	0x0b83, 0x0b83,
-	0x0b85, 0x0b8a,
-	0x0b8e, 0x0b90,
-	0x0b92, 0x0b95,
-	0x0b99, 0x0b9a,
-	0x0b9c, 0x0b9c,
-	0x0b9e, 0x0b9f,
-	0x0ba3, 0x0ba4,
-	0x0ba8, 0x0baa,
-	0x0bae, 0x0bb9,
-	0x0bd0, 0x0bd0,
-	0x0c05, 0x0c0c,
-	0x0c0e, 0x0c10,
-	0x0c12, 0x0c28,
-	0x0c2a, 0x0c33,
-	0x0c35, 0x0c39,
-	0x0c3d, 0x0c3d,
-	0x0c58, 0x0c59,
-	0x0c60, 0x0c61,
-	0x0c85, 0x0c8c,
-	0x0c8e, 0x0c90,
-	0x0c92, 0x0ca8,
-	0x0caa, 0x0cb3,
-	0x0cb5, 0x0cb9,
-	0x0cbd, 0x0cbd,
-	0x0cde, 0x0cde,
-	0x0ce0, 0x0ce1,
-	0x0d05, 0x0d0c,
-	0x0d0e, 0x0d10,
-	0x0d12, 0x0d28,
-	0x0d2a, 0x0d39,
-	0x0d3d, 0x0d3d,
-	0x0d60, 0x0d61,
-	0x0d7a, 0x0d7f,
-	0x0d85, 0x0d96,
-	0x0d9a, 0x0db1,
-	0x0db3, 0x0dbb,
-	0x0dbd, 0x0dbd,
-	0x0dc0, 0x0dc6,
-	0x0e01, 0x0e30,
-	0x0e32, 0x0e33,
-	0x0e40, 0x0e45,
-	0x0e81, 0x0e82,
-	0x0e84, 0x0e84,
-	0x0e87, 0x0e88,
-	0x0e8a, 0x0e8a,
-	0x0e8d, 0x0e8d,
-	0x0e94, 0x0e97,
-	0x0e99, 0x0e9f,
-	0x0ea1, 0x0ea3,
-	0x0ea5, 0x0ea5,
-	0x0ea7, 0x0ea7,
-	0x0eaa, 0x0eab,
-	0x0ead, 0x0eb0,
-	0x0eb2, 0x0eb3,
-	0x0ebd, 0x0ebd,
-	0x0ec0, 0x0ec4,
-	0x0edc, 0x0edd,
-	0x0f00, 0x0f00,
-	0x0f40, 0x0f47,
-	0x0f49, 0x0f6c,
-	0x0f88, 0x0f8b,
-	0x1000, 0x102a,
-	0x103f, 0x103f,
-	0x1050, 0x1055,
-	0x105a, 0x105d,
-	0x1061, 0x1061,
-	0x1065, 0x1066,
-	0x106e, 0x1070,
-	0x1075, 0x1081,
-	0x108e, 0x108e,
-	0x10d0, 0x10fa,
-	0x1100, 0x1248,
-	0x124a, 0x124d,
-	0x1250, 0x1256,
-	0x1258, 0x1258,
-	0x125a, 0x125d,
-	0x1260, 0x1288,
-	0x128a, 0x128d,
-	0x1290, 0x12b0,
-	0x12b2, 0x12b5,
-	0x12b8, 0x12be,
-	0x12c0, 0x12c0,
-	0x12c2, 0x12c5,
-	0x12c8, 0x12d6,
-	0x12d8, 0x1310,
-	0x1312, 0x1315,
-	0x1318, 0x135a,
-	0x1380, 0x138f,
-	0x13a0, 0x13f4,
-	0x1401, 0x166c,
-	0x166f, 0x167f,
-	0x1681, 0x169a,
-	0x16a0, 0x16ea,
-	0x1700, 0x170c,
-	0x170e, 0x1711,
-	0x1720, 0x1731,
-	0x1740, 0x1751,
-	0x1760, 0x176c,
-	0x176e, 0x1770,
-	0x1780, 0x17b3,
-	0x17dc, 0x17dc,
-	0x1820, 0x1842,
-	0x1844, 0x1877,
-	0x1880, 0x18a8,
-	0x18aa, 0x18aa,
-	0x18b0, 0x18f5,
-	0x1900, 0x191c,
-	0x1950, 0x196d,
-	0x1970, 0x1974,
-	0x1980, 0x19ab,
-	0x19c1, 0x19c7,
-	0x1a00, 0x1a16,
-	0x1a20, 0x1a54,
-	0x1b05, 0x1b33,
-	0x1b45, 0x1b4b,
-	0x1b83, 0x1ba0,
-	0x1bae, 0x1baf,
-	0x1c00, 0x1c23,
-	0x1c4d, 0x1c4f,
-	0x1c5a, 0x1c77,
-	0x1ce9, 0x1cec,
-	0x1cee, 0x1cf1,
-	0x2135, 0x2138,
-	0x2d30, 0x2d65,
-	0x2d80, 0x2d96,
-	0x2da0, 0x2da6,
-	0x2da8, 0x2dae,
-	0x2db0, 0x2db6,
-	0x2db8, 0x2dbe,
-	0x2dc0, 0x2dc6,
-	0x2dc8, 0x2dce,
-	0x2dd0, 0x2dd6,
-	0x2dd8, 0x2dde,
-	0x3006, 0x3006,
-	0x303c, 0x303c,
-	0x3041, 0x3096,
-	0x309f, 0x309f,
-	0x30a1, 0x30fa,
-	0x30ff, 0x30ff,
-	0x3105, 0x312d,
-	0x3131, 0x318e,
-	0x31a0, 0x31b7,
-	0x31f0, 0x31ff,
-	0x3400, 0x4db5,
-	0x4e00, 0x9fcb,
-	0xa000, 0xa014,
-	0xa016, 0xa48c,
-	0xa4d0, 0xa4f7,
-	0xa500, 0xa60b,
-	0xa610, 0xa61f,
-	0xa62a, 0xa62b,
-	0xa66e, 0xa66e,
-	0xa6a0, 0xa6e5,
-	0xa7fb, 0xa801,
-	0xa803, 0xa805,
-	0xa807, 0xa80a,
-	0xa80c, 0xa822,
-	0xa840, 0xa873,
-	0xa882, 0xa8b3,
-	0xa8f2, 0xa8f7,
-	0xa8fb, 0xa8fb,
-	0xa90a, 0xa925,
-	0xa930, 0xa946,
-	0xa960, 0xa97c,
-	0xa984, 0xa9b2,
-	0xaa00, 0xaa28,
-	0xaa40, 0xaa42,
-	0xaa44, 0xaa4b,
-	0xaa60, 0xaa6f,
-	0xaa71, 0xaa76,
-	0xaa7a, 0xaa7a,
-	0xaa80, 0xaaaf,
-	0xaab1, 0xaab1,
-	0xaab5, 0xaab6,
-	0xaab9, 0xaabd,
-	0xaac0, 0xaac0,
-	0xaac2, 0xaac2,
-	0xaadb, 0xaadc,
-	0xabc0, 0xabe2,
-	0xac00, 0xd7a3,
-	0xd7b0, 0xd7c6,
-	0xd7cb, 0xd7fb,
-	0xf900, 0xfa2d,
-	0xfa30, 0xfa6d,
-	0xfa70, 0xfad9,
-	0xfb1d, 0xfb1d,
-	0xfb1f, 0xfb28,
-	0xfb2a, 0xfb36,
-	0xfb38, 0xfb3c,
-	0xfb3e, 0xfb3e,
-	0xfb40, 0xfb41,
-	0xfb43, 0xfb44,
-	0xfb46, 0xfbb1,
-	0xfbd3, 0xfd3d,
-	0xfd50, 0xfd8f,
-	0xfd92, 0xfdc7,
-	0xfdf0, 0xfdfb,
-	0xfe70, 0xfe74,
-	0xfe76, 0xfefc,
-	0xff66, 0xff6f,
-	0xff71, 0xff9d,
-	0xffa0, 0xffbe,
-	0xffc2, 0xffc7,
-	0xffca, 0xffcf,
-	0xffd2, 0xffd7,
-	0xffda, 0xffdc,
-	0x10000, 0x1000b,
-	0x1000d, 0x10026,
-	0x10028, 0x1003a,
-	0x1003c, 0x1003d,
-	0x1003f, 0x1004d,
-	0x10050, 0x1005d,
-	0x10080, 0x100fa,
-	0x10280, 0x1029c,
-	0x102a0, 0x102d0,
-	0x10300, 0x1031e,
-	0x10330, 0x10340,
-	0x10342, 0x10349,
-	0x10380, 0x1039d,
-	0x103a0, 0x103c3,
-	0x103c8, 0x103cf,
-	0x10450, 0x1049d,
-	0x10800, 0x10805,
-	0x10808, 0x10808,
-	0x1080a, 0x10835,
-	0x10837, 0x10838,
-	0x1083c, 0x1083c,
-	0x1083f, 0x10855,
-	0x10900, 0x10915,
-	0x10920, 0x10939,
-	0x10a00, 0x10a00,
-	0x10a10, 0x10a13,
-	0x10a15, 0x10a17,
-	0x10a19, 0x10a33,
-	0x10a60, 0x10a7c,
-	0x10b00, 0x10b35,
-	0x10b40, 0x10b55,
-	0x10b60, 0x10b72,
-	0x10c00, 0x10c48,
-	0x11083, 0x110af,
-	0x12000, 0x1236e,
-	0x13000, 0x1342e,
-	0x20000, 0x2a6d6,
-	0x2a700, 0x2b734,
-	0x2f800, 0x2fa1d,
+        311,
+        0x01bb, 0x01bb,
+        0x01c0, 0x01c3,
+        0x0294, 0x0294,
+        0x05d0, 0x05ea,
+        0x05f0, 0x05f2,
+        0x0621, 0x063f,
+        0x0641, 0x064a,
+        0x066e, 0x066f,
+        0x0671, 0x06d3,
+        0x06d5, 0x06d5,
+        0x06ee, 0x06ef,
+        0x06fa, 0x06fc,
+        0x06ff, 0x06ff,
+        0x0710, 0x0710,
+        0x0712, 0x072f,
+        0x074d, 0x07a5,
+        0x07b1, 0x07b1,
+        0x07ca, 0x07ea,
+        0x0800, 0x0815,
+        0x0904, 0x0939,
+        0x093d, 0x093d,
+        0x0950, 0x0950,
+        0x0958, 0x0961,
+        0x0972, 0x0972,
+        0x0979, 0x097f,
+        0x0985, 0x098c,
+        0x098f, 0x0990,
+        0x0993, 0x09a8,
+        0x09aa, 0x09b0,
+        0x09b2, 0x09b2,
+        0x09b6, 0x09b9,
+        0x09bd, 0x09bd,
+        0x09ce, 0x09ce,
+        0x09dc, 0x09dd,
+        0x09df, 0x09e1,
+        0x09f0, 0x09f1,
+        0x0a05, 0x0a0a,
+        0x0a0f, 0x0a10,
+        0x0a13, 0x0a28,
+        0x0a2a, 0x0a30,
+        0x0a32, 0x0a33,
+        0x0a35, 0x0a36,
+        0x0a38, 0x0a39,
+        0x0a59, 0x0a5c,
+        0x0a5e, 0x0a5e,
+        0x0a72, 0x0a74,
+        0x0a85, 0x0a8d,
+        0x0a8f, 0x0a91,
+        0x0a93, 0x0aa8,
+        0x0aaa, 0x0ab0,
+        0x0ab2, 0x0ab3,
+        0x0ab5, 0x0ab9,
+        0x0abd, 0x0abd,
+        0x0ad0, 0x0ad0,
+        0x0ae0, 0x0ae1,
+        0x0b05, 0x0b0c,
+        0x0b0f, 0x0b10,
+        0x0b13, 0x0b28,
+        0x0b2a, 0x0b30,
+        0x0b32, 0x0b33,
+        0x0b35, 0x0b39,
+        0x0b3d, 0x0b3d,
+        0x0b5c, 0x0b5d,
+        0x0b5f, 0x0b61,
+        0x0b71, 0x0b71,
+        0x0b83, 0x0b83,
+        0x0b85, 0x0b8a,
+        0x0b8e, 0x0b90,
+        0x0b92, 0x0b95,
+        0x0b99, 0x0b9a,
+        0x0b9c, 0x0b9c,
+        0x0b9e, 0x0b9f,
+        0x0ba3, 0x0ba4,
+        0x0ba8, 0x0baa,
+        0x0bae, 0x0bb9,
+        0x0bd0, 0x0bd0,
+        0x0c05, 0x0c0c,
+        0x0c0e, 0x0c10,
+        0x0c12, 0x0c28,
+        0x0c2a, 0x0c33,
+        0x0c35, 0x0c39,
+        0x0c3d, 0x0c3d,
+        0x0c58, 0x0c59,
+        0x0c60, 0x0c61,
+        0x0c85, 0x0c8c,
+        0x0c8e, 0x0c90,
+        0x0c92, 0x0ca8,
+        0x0caa, 0x0cb3,
+        0x0cb5, 0x0cb9,
+        0x0cbd, 0x0cbd,
+        0x0cde, 0x0cde,
+        0x0ce0, 0x0ce1,
+        0x0d05, 0x0d0c,
+        0x0d0e, 0x0d10,
+        0x0d12, 0x0d28,
+        0x0d2a, 0x0d39,
+        0x0d3d, 0x0d3d,
+        0x0d60, 0x0d61,
+        0x0d7a, 0x0d7f,
+        0x0d85, 0x0d96,
+        0x0d9a, 0x0db1,
+        0x0db3, 0x0dbb,
+        0x0dbd, 0x0dbd,
+        0x0dc0, 0x0dc6,
+        0x0e01, 0x0e30,
+        0x0e32, 0x0e33,
+        0x0e40, 0x0e45,
+        0x0e81, 0x0e82,
+        0x0e84, 0x0e84,
+        0x0e87, 0x0e88,
+        0x0e8a, 0x0e8a,
+        0x0e8d, 0x0e8d,
+        0x0e94, 0x0e97,
+        0x0e99, 0x0e9f,
+        0x0ea1, 0x0ea3,
+        0x0ea5, 0x0ea5,
+        0x0ea7, 0x0ea7,
+        0x0eaa, 0x0eab,
+        0x0ead, 0x0eb0,
+        0x0eb2, 0x0eb3,
+        0x0ebd, 0x0ebd,
+        0x0ec0, 0x0ec4,
+        0x0edc, 0x0edd,
+        0x0f00, 0x0f00,
+        0x0f40, 0x0f47,
+        0x0f49, 0x0f6c,
+        0x0f88, 0x0f8b,
+        0x1000, 0x102a,
+        0x103f, 0x103f,
+        0x1050, 0x1055,
+        0x105a, 0x105d,
+        0x1061, 0x1061,
+        0x1065, 0x1066,
+        0x106e, 0x1070,
+        0x1075, 0x1081,
+        0x108e, 0x108e,
+        0x10d0, 0x10fa,
+        0x1100, 0x1248,
+        0x124a, 0x124d,
+        0x1250, 0x1256,
+        0x1258, 0x1258,
+        0x125a, 0x125d,
+        0x1260, 0x1288,
+        0x128a, 0x128d,
+        0x1290, 0x12b0,
+        0x12b2, 0x12b5,
+        0x12b8, 0x12be,
+        0x12c0, 0x12c0,
+        0x12c2, 0x12c5,
+        0x12c8, 0x12d6,
+        0x12d8, 0x1310,
+        0x1312, 0x1315,
+        0x1318, 0x135a,
+        0x1380, 0x138f,
+        0x13a0, 0x13f4,
+        0x1401, 0x166c,
+        0x166f, 0x167f,
+        0x1681, 0x169a,
+        0x16a0, 0x16ea,
+        0x1700, 0x170c,
+        0x170e, 0x1711,
+        0x1720, 0x1731,
+        0x1740, 0x1751,
+        0x1760, 0x176c,
+        0x176e, 0x1770,
+        0x1780, 0x17b3,
+        0x17dc, 0x17dc,
+        0x1820, 0x1842,
+        0x1844, 0x1877,
+        0x1880, 0x18a8,
+        0x18aa, 0x18aa,
+        0x18b0, 0x18f5,
+        0x1900, 0x191c,
+        0x1950, 0x196d,
+        0x1970, 0x1974,
+        0x1980, 0x19ab,
+        0x19c1, 0x19c7,
+        0x1a00, 0x1a16,
+        0x1a20, 0x1a54,
+        0x1b05, 0x1b33,
+        0x1b45, 0x1b4b,
+        0x1b83, 0x1ba0,
+        0x1bae, 0x1baf,
+        0x1c00, 0x1c23,
+        0x1c4d, 0x1c4f,
+        0x1c5a, 0x1c77,
+        0x1ce9, 0x1cec,
+        0x1cee, 0x1cf1,
+        0x2135, 0x2138,
+        0x2d30, 0x2d65,
+        0x2d80, 0x2d96,
+        0x2da0, 0x2da6,
+        0x2da8, 0x2dae,
+        0x2db0, 0x2db6,
+        0x2db8, 0x2dbe,
+        0x2dc0, 0x2dc6,
+        0x2dc8, 0x2dce,
+        0x2dd0, 0x2dd6,
+        0x2dd8, 0x2dde,
+        0x3006, 0x3006,
+        0x303c, 0x303c,
+        0x3041, 0x3096,
+        0x309f, 0x309f,
+        0x30a1, 0x30fa,
+        0x30ff, 0x30ff,
+        0x3105, 0x312d,
+        0x3131, 0x318e,
+        0x31a0, 0x31b7,
+        0x31f0, 0x31ff,
+        0x3400, 0x4db5,
+        0x4e00, 0x9fcb,
+        0xa000, 0xa014,
+        0xa016, 0xa48c,
+        0xa4d0, 0xa4f7,
+        0xa500, 0xa60b,
+        0xa610, 0xa61f,
+        0xa62a, 0xa62b,
+        0xa66e, 0xa66e,
+        0xa6a0, 0xa6e5,
+        0xa7fb, 0xa801,
+        0xa803, 0xa805,
+        0xa807, 0xa80a,
+        0xa80c, 0xa822,
+        0xa840, 0xa873,
+        0xa882, 0xa8b3,
+        0xa8f2, 0xa8f7,
+        0xa8fb, 0xa8fb,
+        0xa90a, 0xa925,
+        0xa930, 0xa946,
+        0xa960, 0xa97c,
+        0xa984, 0xa9b2,
+        0xaa00, 0xaa28,
+        0xaa40, 0xaa42,
+        0xaa44, 0xaa4b,
+        0xaa60, 0xaa6f,
+        0xaa71, 0xaa76,
+        0xaa7a, 0xaa7a,
+        0xaa80, 0xaaaf,
+        0xaab1, 0xaab1,
+        0xaab5, 0xaab6,
+        0xaab9, 0xaabd,
+        0xaac0, 0xaac0,
+        0xaac2, 0xaac2,
+        0xaadb, 0xaadc,
+        0xabc0, 0xabe2,
+        0xac00, 0xd7a3,
+        0xd7b0, 0xd7c6,
+        0xd7cb, 0xd7fb,
+        0xf900, 0xfa2d,
+        0xfa30, 0xfa6d,
+        0xfa70, 0xfad9,
+        0xfb1d, 0xfb1d,
+        0xfb1f, 0xfb28,
+        0xfb2a, 0xfb36,
+        0xfb38, 0xfb3c,
+        0xfb3e, 0xfb3e,
+        0xfb40, 0xfb41,
+        0xfb43, 0xfb44,
+        0xfb46, 0xfbb1,
+        0xfbd3, 0xfd3d,
+        0xfd50, 0xfd8f,
+        0xfd92, 0xfdc7,
+        0xfdf0, 0xfdfb,
+        0xfe70, 0xfe74,
+        0xfe76, 0xfefc,
+        0xff66, 0xff6f,
+        0xff71, 0xff9d,
+        0xffa0, 0xffbe,
+        0xffc2, 0xffc7,
+        0xffca, 0xffcf,
+        0xffd2, 0xffd7,
+        0xffda, 0xffdc,
+        0x10000, 0x1000b,
+        0x1000d, 0x10026,
+        0x10028, 0x1003a,
+        0x1003c, 0x1003d,
+        0x1003f, 0x1004d,
+        0x10050, 0x1005d,
+        0x10080, 0x100fa,
+        0x10280, 0x1029c,
+        0x102a0, 0x102d0,
+        0x10300, 0x1031e,
+        0x10330, 0x10340,
+        0x10342, 0x10349,
+        0x10380, 0x1039d,
+        0x103a0, 0x103c3,
+        0x103c8, 0x103cf,
+        0x10450, 0x1049d,
+        0x10800, 0x10805,
+        0x10808, 0x10808,
+        0x1080a, 0x10835,
+        0x10837, 0x10838,
+        0x1083c, 0x1083c,
+        0x1083f, 0x10855,
+        0x10900, 0x10915,
+        0x10920, 0x10939,
+        0x10a00, 0x10a00,
+        0x10a10, 0x10a13,
+        0x10a15, 0x10a17,
+        0x10a19, 0x10a33,
+        0x10a60, 0x10a7c,
+        0x10b00, 0x10b35,
+        0x10b40, 0x10b55,
+        0x10b60, 0x10b72,
+        0x10c00, 0x10c48,
+        0x11083, 0x110af,
+        0x12000, 0x1236e,
+        0x13000, 0x1342e,
+        0x20000, 0x2a6d6,
+        0x2a700, 0x2b734,
+        0x2f800, 0x2fa1d,
 }; /* CR_Lo */
 
 /* 'Lt': General Category */
 static const OnigCodePoint CR_Lt[] = {
-	10,
-	0x01c5, 0x01c5,
-	0x01c8, 0x01c8,
-	0x01cb, 0x01cb,
-	0x01f2, 0x01f2,
-	0x1f88, 0x1f8f,
-	0x1f98, 0x1f9f,
-	0x1fa8, 0x1faf,
-	0x1fbc, 0x1fbc,
-	0x1fcc, 0x1fcc,
-	0x1ffc, 0x1ffc,
+        10,
+        0x01c5, 0x01c5,
+        0x01c8, 0x01c8,
+        0x01cb, 0x01cb,
+        0x01f2, 0x01f2,
+        0x1f88, 0x1f8f,
+        0x1f98, 0x1f9f,
+        0x1fa8, 0x1faf,
+        0x1fbc, 0x1fbc,
+        0x1fcc, 0x1fcc,
+        0x1ffc, 0x1ffc,
 }; /* CR_Lt */
 
 /* 'Lu': General Category */
 static const OnigCodePoint CR_Lu[] = {
-	594,
-	0x0041, 0x005a,
-	0x00c0, 0x00d6,
-	0x00d8, 0x00de,
-	0x0100, 0x0100,
-	0x0102, 0x0102,
-	0x0104, 0x0104,
-	0x0106, 0x0106,
-	0x0108, 0x0108,
-	0x010a, 0x010a,
-	0x010c, 0x010c,
-	0x010e, 0x010e,
-	0x0110, 0x0110,
-	0x0112, 0x0112,
-	0x0114, 0x0114,
-	0x0116, 0x0116,
-	0x0118, 0x0118,
-	0x011a, 0x011a,
-	0x011c, 0x011c,
-	0x011e, 0x011e,
-	0x0120, 0x0120,
-	0x0122, 0x0122,
-	0x0124, 0x0124,
-	0x0126, 0x0126,
-	0x0128, 0x0128,
-	0x012a, 0x012a,
-	0x012c, 0x012c,
-	0x012e, 0x012e,
-	0x0130, 0x0130,
-	0x0132, 0x0132,
-	0x0134, 0x0134,
-	0x0136, 0x0136,
-	0x0139, 0x0139,
-	0x013b, 0x013b,
-	0x013d, 0x013d,
-	0x013f, 0x013f,
-	0x0141, 0x0141,
-	0x0143, 0x0143,
-	0x0145, 0x0145,
-	0x0147, 0x0147,
-	0x014a, 0x014a,
-	0x014c, 0x014c,
-	0x014e, 0x014e,
-	0x0150, 0x0150,
-	0x0152, 0x0152,
-	0x0154, 0x0154,
-	0x0156, 0x0156,
-	0x0158, 0x0158,
-	0x015a, 0x015a,
-	0x015c, 0x015c,
-	0x015e, 0x015e,
-	0x0160, 0x0160,
-	0x0162, 0x0162,
-	0x0164, 0x0164,
-	0x0166, 0x0166,
-	0x0168, 0x0168,
-	0x016a, 0x016a,
-	0x016c, 0x016c,
-	0x016e, 0x016e,
-	0x0170, 0x0170,
-	0x0172, 0x0172,
-	0x0174, 0x0174,
-	0x0176, 0x0176,
-	0x0178, 0x0179,
-	0x017b, 0x017b,
-	0x017d, 0x017d,
-	0x0181, 0x0182,
-	0x0184, 0x0184,
-	0x0186, 0x0187,
-	0x0189, 0x018b,
-	0x018e, 0x0191,
-	0x0193, 0x0194,
-	0x0196, 0x0198,
-	0x019c, 0x019d,
-	0x019f, 0x01a0,
-	0x01a2, 0x01a2,
-	0x01a4, 0x01a4,
-	0x01a6, 0x01a7,
-	0x01a9, 0x01a9,
-	0x01ac, 0x01ac,
-	0x01ae, 0x01af,
-	0x01b1, 0x01b3,
-	0x01b5, 0x01b5,
-	0x01b7, 0x01b8,
-	0x01bc, 0x01bc,
-	0x01c4, 0x01c4,
-	0x01c7, 0x01c7,
-	0x01ca, 0x01ca,
-	0x01cd, 0x01cd,
-	0x01cf, 0x01cf,
-	0x01d1, 0x01d1,
-	0x01d3, 0x01d3,
-	0x01d5, 0x01d5,
-	0x01d7, 0x01d7,
-	0x01d9, 0x01d9,
-	0x01db, 0x01db,
-	0x01de, 0x01de,
-	0x01e0, 0x01e0,
-	0x01e2, 0x01e2,
-	0x01e4, 0x01e4,
-	0x01e6, 0x01e6,
-	0x01e8, 0x01e8,
-	0x01ea, 0x01ea,
-	0x01ec, 0x01ec,
-	0x01ee, 0x01ee,
-	0x01f1, 0x01f1,
-	0x01f4, 0x01f4,
-	0x01f6, 0x01f8,
-	0x01fa, 0x01fa,
-	0x01fc, 0x01fc,
-	0x01fe, 0x01fe,
-	0x0200, 0x0200,
-	0x0202, 0x0202,
-	0x0204, 0x0204,
-	0x0206, 0x0206,
-	0x0208, 0x0208,
-	0x020a, 0x020a,
-	0x020c, 0x020c,
-	0x020e, 0x020e,
-	0x0210, 0x0210,
-	0x0212, 0x0212,
-	0x0214, 0x0214,
-	0x0216, 0x0216,
-	0x0218, 0x0218,
-	0x021a, 0x021a,
-	0x021c, 0x021c,
-	0x021e, 0x021e,
-	0x0220, 0x0220,
-	0x0222, 0x0222,
-	0x0224, 0x0224,
-	0x0226, 0x0226,
-	0x0228, 0x0228,
-	0x022a, 0x022a,
-	0x022c, 0x022c,
-	0x022e, 0x022e,
-	0x0230, 0x0230,
-	0x0232, 0x0232,
-	0x023a, 0x023b,
-	0x023d, 0x023e,
-	0x0241, 0x0241,
-	0x0243, 0x0246,
-	0x0248, 0x0248,
-	0x024a, 0x024a,
-	0x024c, 0x024c,
-	0x024e, 0x024e,
-	0x0370, 0x0370,
-	0x0372, 0x0372,
-	0x0376, 0x0376,
-	0x0386, 0x0386,
-	0x0388, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x038f,
-	0x0391, 0x03a1,
-	0x03a3, 0x03ab,
-	0x03cf, 0x03cf,
-	0x03d2, 0x03d4,
-	0x03d8, 0x03d8,
-	0x03da, 0x03da,
-	0x03dc, 0x03dc,
-	0x03de, 0x03de,
-	0x03e0, 0x03e0,
-	0x03e2, 0x03e2,
-	0x03e4, 0x03e4,
-	0x03e6, 0x03e6,
-	0x03e8, 0x03e8,
-	0x03ea, 0x03ea,
-	0x03ec, 0x03ec,
-	0x03ee, 0x03ee,
-	0x03f4, 0x03f4,
-	0x03f7, 0x03f7,
-	0x03f9, 0x03fa,
-	0x03fd, 0x042f,
-	0x0460, 0x0460,
-	0x0462, 0x0462,
-	0x0464, 0x0464,
-	0x0466, 0x0466,
-	0x0468, 0x0468,
-	0x046a, 0x046a,
-	0x046c, 0x046c,
-	0x046e, 0x046e,
-	0x0470, 0x0470,
-	0x0472, 0x0472,
-	0x0474, 0x0474,
-	0x0476, 0x0476,
-	0x0478, 0x0478,
-	0x047a, 0x047a,
-	0x047c, 0x047c,
-	0x047e, 0x047e,
-	0x0480, 0x0480,
-	0x048a, 0x048a,
-	0x048c, 0x048c,
-	0x048e, 0x048e,
-	0x0490, 0x0490,
-	0x0492, 0x0492,
-	0x0494, 0x0494,
-	0x0496, 0x0496,
-	0x0498, 0x0498,
-	0x049a, 0x049a,
-	0x049c, 0x049c,
-	0x049e, 0x049e,
-	0x04a0, 0x04a0,
-	0x04a2, 0x04a2,
-	0x04a4, 0x04a4,
-	0x04a6, 0x04a6,
-	0x04a8, 0x04a8,
-	0x04aa, 0x04aa,
-	0x04ac, 0x04ac,
-	0x04ae, 0x04ae,
-	0x04b0, 0x04b0,
-	0x04b2, 0x04b2,
-	0x04b4, 0x04b4,
-	0x04b6, 0x04b6,
-	0x04b8, 0x04b8,
-	0x04ba, 0x04ba,
-	0x04bc, 0x04bc,
-	0x04be, 0x04be,
-	0x04c0, 0x04c1,
-	0x04c3, 0x04c3,
-	0x04c5, 0x04c5,
-	0x04c7, 0x04c7,
-	0x04c9, 0x04c9,
-	0x04cb, 0x04cb,
-	0x04cd, 0x04cd,
-	0x04d0, 0x04d0,
-	0x04d2, 0x04d2,
-	0x04d4, 0x04d4,
-	0x04d6, 0x04d6,
-	0x04d8, 0x04d8,
-	0x04da, 0x04da,
-	0x04dc, 0x04dc,
-	0x04de, 0x04de,
-	0x04e0, 0x04e0,
-	0x04e2, 0x04e2,
-	0x04e4, 0x04e4,
-	0x04e6, 0x04e6,
-	0x04e8, 0x04e8,
-	0x04ea, 0x04ea,
-	0x04ec, 0x04ec,
-	0x04ee, 0x04ee,
-	0x04f0, 0x04f0,
-	0x04f2, 0x04f2,
-	0x04f4, 0x04f4,
-	0x04f6, 0x04f6,
-	0x04f8, 0x04f8,
-	0x04fa, 0x04fa,
-	0x04fc, 0x04fc,
-	0x04fe, 0x04fe,
-	0x0500, 0x0500,
-	0x0502, 0x0502,
-	0x0504, 0x0504,
-	0x0506, 0x0506,
-	0x0508, 0x0508,
-	0x050a, 0x050a,
-	0x050c, 0x050c,
-	0x050e, 0x050e,
-	0x0510, 0x0510,
-	0x0512, 0x0512,
-	0x0514, 0x0514,
-	0x0516, 0x0516,
-	0x0518, 0x0518,
-	0x051a, 0x051a,
-	0x051c, 0x051c,
-	0x051e, 0x051e,
-	0x0520, 0x0520,
-	0x0522, 0x0522,
-	0x0524, 0x0524,
-	0x0531, 0x0556,
-	0x10a0, 0x10c5,
-	0x1e00, 0x1e00,
-	0x1e02, 0x1e02,
-	0x1e04, 0x1e04,
-	0x1e06, 0x1e06,
-	0x1e08, 0x1e08,
-	0x1e0a, 0x1e0a,
-	0x1e0c, 0x1e0c,
-	0x1e0e, 0x1e0e,
-	0x1e10, 0x1e10,
-	0x1e12, 0x1e12,
-	0x1e14, 0x1e14,
-	0x1e16, 0x1e16,
-	0x1e18, 0x1e18,
-	0x1e1a, 0x1e1a,
-	0x1e1c, 0x1e1c,
-	0x1e1e, 0x1e1e,
-	0x1e20, 0x1e20,
-	0x1e22, 0x1e22,
-	0x1e24, 0x1e24,
-	0x1e26, 0x1e26,
-	0x1e28, 0x1e28,
-	0x1e2a, 0x1e2a,
-	0x1e2c, 0x1e2c,
-	0x1e2e, 0x1e2e,
-	0x1e30, 0x1e30,
-	0x1e32, 0x1e32,
-	0x1e34, 0x1e34,
-	0x1e36, 0x1e36,
-	0x1e38, 0x1e38,
-	0x1e3a, 0x1e3a,
-	0x1e3c, 0x1e3c,
-	0x1e3e, 0x1e3e,
-	0x1e40, 0x1e40,
-	0x1e42, 0x1e42,
-	0x1e44, 0x1e44,
-	0x1e46, 0x1e46,
-	0x1e48, 0x1e48,
-	0x1e4a, 0x1e4a,
-	0x1e4c, 0x1e4c,
-	0x1e4e, 0x1e4e,
-	0x1e50, 0x1e50,
-	0x1e52, 0x1e52,
-	0x1e54, 0x1e54,
-	0x1e56, 0x1e56,
-	0x1e58, 0x1e58,
-	0x1e5a, 0x1e5a,
-	0x1e5c, 0x1e5c,
-	0x1e5e, 0x1e5e,
-	0x1e60, 0x1e60,
-	0x1e62, 0x1e62,
-	0x1e64, 0x1e64,
-	0x1e66, 0x1e66,
-	0x1e68, 0x1e68,
-	0x1e6a, 0x1e6a,
-	0x1e6c, 0x1e6c,
-	0x1e6e, 0x1e6e,
-	0x1e70, 0x1e70,
-	0x1e72, 0x1e72,
-	0x1e74, 0x1e74,
-	0x1e76, 0x1e76,
-	0x1e78, 0x1e78,
-	0x1e7a, 0x1e7a,
-	0x1e7c, 0x1e7c,
-	0x1e7e, 0x1e7e,
-	0x1e80, 0x1e80,
-	0x1e82, 0x1e82,
-	0x1e84, 0x1e84,
-	0x1e86, 0x1e86,
-	0x1e88, 0x1e88,
-	0x1e8a, 0x1e8a,
-	0x1e8c, 0x1e8c,
-	0x1e8e, 0x1e8e,
-	0x1e90, 0x1e90,
-	0x1e92, 0x1e92,
-	0x1e94, 0x1e94,
-	0x1e9e, 0x1e9e,
-	0x1ea0, 0x1ea0,
-	0x1ea2, 0x1ea2,
-	0x1ea4, 0x1ea4,
-	0x1ea6, 0x1ea6,
-	0x1ea8, 0x1ea8,
-	0x1eaa, 0x1eaa,
-	0x1eac, 0x1eac,
-	0x1eae, 0x1eae,
-	0x1eb0, 0x1eb0,
-	0x1eb2, 0x1eb2,
-	0x1eb4, 0x1eb4,
-	0x1eb6, 0x1eb6,
-	0x1eb8, 0x1eb8,
-	0x1eba, 0x1eba,
-	0x1ebc, 0x1ebc,
-	0x1ebe, 0x1ebe,
-	0x1ec0, 0x1ec0,
-	0x1ec2, 0x1ec2,
-	0x1ec4, 0x1ec4,
-	0x1ec6, 0x1ec6,
-	0x1ec8, 0x1ec8,
-	0x1eca, 0x1eca,
-	0x1ecc, 0x1ecc,
-	0x1ece, 0x1ece,
-	0x1ed0, 0x1ed0,
-	0x1ed2, 0x1ed2,
-	0x1ed4, 0x1ed4,
-	0x1ed6, 0x1ed6,
-	0x1ed8, 0x1ed8,
-	0x1eda, 0x1eda,
-	0x1edc, 0x1edc,
-	0x1ede, 0x1ede,
-	0x1ee0, 0x1ee0,
-	0x1ee2, 0x1ee2,
-	0x1ee4, 0x1ee4,
-	0x1ee6, 0x1ee6,
-	0x1ee8, 0x1ee8,
-	0x1eea, 0x1eea,
-	0x1eec, 0x1eec,
-	0x1eee, 0x1eee,
-	0x1ef0, 0x1ef0,
-	0x1ef2, 0x1ef2,
-	0x1ef4, 0x1ef4,
-	0x1ef6, 0x1ef6,
-	0x1ef8, 0x1ef8,
-	0x1efa, 0x1efa,
-	0x1efc, 0x1efc,
-	0x1efe, 0x1efe,
-	0x1f08, 0x1f0f,
-	0x1f18, 0x1f1d,
-	0x1f28, 0x1f2f,
-	0x1f38, 0x1f3f,
-	0x1f48, 0x1f4d,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f5f,
-	0x1f68, 0x1f6f,
-	0x1fb8, 0x1fbb,
-	0x1fc8, 0x1fcb,
-	0x1fd8, 0x1fdb,
-	0x1fe8, 0x1fec,
-	0x1ff8, 0x1ffb,
-	0x2102, 0x2102,
-	0x2107, 0x2107,
-	0x210b, 0x210d,
-	0x2110, 0x2112,
-	0x2115, 0x2115,
-	0x2119, 0x211d,
-	0x2124, 0x2124,
-	0x2126, 0x2126,
-	0x2128, 0x2128,
-	0x212a, 0x212d,
-	0x2130, 0x2133,
-	0x213e, 0x213f,
-	0x2145, 0x2145,
-	0x2183, 0x2183,
-	0x2c00, 0x2c2e,
-	0x2c60, 0x2c60,
-	0x2c62, 0x2c64,
-	0x2c67, 0x2c67,
-	0x2c69, 0x2c69,
-	0x2c6b, 0x2c6b,
-	0x2c6d, 0x2c70,
-	0x2c72, 0x2c72,
-	0x2c75, 0x2c75,
-	0x2c7e, 0x2c80,
-	0x2c82, 0x2c82,
-	0x2c84, 0x2c84,
-	0x2c86, 0x2c86,
-	0x2c88, 0x2c88,
-	0x2c8a, 0x2c8a,
-	0x2c8c, 0x2c8c,
-	0x2c8e, 0x2c8e,
-	0x2c90, 0x2c90,
-	0x2c92, 0x2c92,
-	0x2c94, 0x2c94,
-	0x2c96, 0x2c96,
-	0x2c98, 0x2c98,
-	0x2c9a, 0x2c9a,
-	0x2c9c, 0x2c9c,
-	0x2c9e, 0x2c9e,
-	0x2ca0, 0x2ca0,
-	0x2ca2, 0x2ca2,
-	0x2ca4, 0x2ca4,
-	0x2ca6, 0x2ca6,
-	0x2ca8, 0x2ca8,
-	0x2caa, 0x2caa,
-	0x2cac, 0x2cac,
-	0x2cae, 0x2cae,
-	0x2cb0, 0x2cb0,
-	0x2cb2, 0x2cb2,
-	0x2cb4, 0x2cb4,
-	0x2cb6, 0x2cb6,
-	0x2cb8, 0x2cb8,
-	0x2cba, 0x2cba,
-	0x2cbc, 0x2cbc,
-	0x2cbe, 0x2cbe,
-	0x2cc0, 0x2cc0,
-	0x2cc2, 0x2cc2,
-	0x2cc4, 0x2cc4,
-	0x2cc6, 0x2cc6,
-	0x2cc8, 0x2cc8,
-	0x2cca, 0x2cca,
-	0x2ccc, 0x2ccc,
-	0x2cce, 0x2cce,
-	0x2cd0, 0x2cd0,
-	0x2cd2, 0x2cd2,
-	0x2cd4, 0x2cd4,
-	0x2cd6, 0x2cd6,
-	0x2cd8, 0x2cd8,
-	0x2cda, 0x2cda,
-	0x2cdc, 0x2cdc,
-	0x2cde, 0x2cde,
-	0x2ce0, 0x2ce0,
-	0x2ce2, 0x2ce2,
-	0x2ceb, 0x2ceb,
-	0x2ced, 0x2ced,
-	0xa640, 0xa640,
-	0xa642, 0xa642,
-	0xa644, 0xa644,
-	0xa646, 0xa646,
-	0xa648, 0xa648,
-	0xa64a, 0xa64a,
-	0xa64c, 0xa64c,
-	0xa64e, 0xa64e,
-	0xa650, 0xa650,
-	0xa652, 0xa652,
-	0xa654, 0xa654,
-	0xa656, 0xa656,
-	0xa658, 0xa658,
-	0xa65a, 0xa65a,
-	0xa65c, 0xa65c,
-	0xa65e, 0xa65e,
-	0xa662, 0xa662,
-	0xa664, 0xa664,
-	0xa666, 0xa666,
-	0xa668, 0xa668,
-	0xa66a, 0xa66a,
-	0xa66c, 0xa66c,
-	0xa680, 0xa680,
-	0xa682, 0xa682,
-	0xa684, 0xa684,
-	0xa686, 0xa686,
-	0xa688, 0xa688,
-	0xa68a, 0xa68a,
-	0xa68c, 0xa68c,
-	0xa68e, 0xa68e,
-	0xa690, 0xa690,
-	0xa692, 0xa692,
-	0xa694, 0xa694,
-	0xa696, 0xa696,
-	0xa722, 0xa722,
-	0xa724, 0xa724,
-	0xa726, 0xa726,
-	0xa728, 0xa728,
-	0xa72a, 0xa72a,
-	0xa72c, 0xa72c,
-	0xa72e, 0xa72e,
-	0xa732, 0xa732,
-	0xa734, 0xa734,
-	0xa736, 0xa736,
-	0xa738, 0xa738,
-	0xa73a, 0xa73a,
-	0xa73c, 0xa73c,
-	0xa73e, 0xa73e,
-	0xa740, 0xa740,
-	0xa742, 0xa742,
-	0xa744, 0xa744,
-	0xa746, 0xa746,
-	0xa748, 0xa748,
-	0xa74a, 0xa74a,
-	0xa74c, 0xa74c,
-	0xa74e, 0xa74e,
-	0xa750, 0xa750,
-	0xa752, 0xa752,
-	0xa754, 0xa754,
-	0xa756, 0xa756,
-	0xa758, 0xa758,
-	0xa75a, 0xa75a,
-	0xa75c, 0xa75c,
-	0xa75e, 0xa75e,
-	0xa760, 0xa760,
-	0xa762, 0xa762,
-	0xa764, 0xa764,
-	0xa766, 0xa766,
-	0xa768, 0xa768,
-	0xa76a, 0xa76a,
-	0xa76c, 0xa76c,
-	0xa76e, 0xa76e,
-	0xa779, 0xa779,
-	0xa77b, 0xa77b,
-	0xa77d, 0xa77e,
-	0xa780, 0xa780,
-	0xa782, 0xa782,
-	0xa784, 0xa784,
-	0xa786, 0xa786,
-	0xa78b, 0xa78b,
-	0xff21, 0xff3a,
-	0x10400, 0x10427,
-	0x1d400, 0x1d419,
-	0x1d434, 0x1d44d,
-	0x1d468, 0x1d481,
-	0x1d49c, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b5,
-	0x1d4d0, 0x1d4e9,
-	0x1d504, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d538, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d56c, 0x1d585,
-	0x1d5a0, 0x1d5b9,
-	0x1d5d4, 0x1d5ed,
-	0x1d608, 0x1d621,
-	0x1d63c, 0x1d655,
-	0x1d670, 0x1d689,
-	0x1d6a8, 0x1d6c0,
-	0x1d6e2, 0x1d6fa,
-	0x1d71c, 0x1d734,
-	0x1d756, 0x1d76e,
-	0x1d790, 0x1d7a8,
-	0x1d7ca, 0x1d7ca,
+        594,
+        0x0041, 0x005a,
+        0x00c0, 0x00d6,
+        0x00d8, 0x00de,
+        0x0100, 0x0100,
+        0x0102, 0x0102,
+        0x0104, 0x0104,
+        0x0106, 0x0106,
+        0x0108, 0x0108,
+        0x010a, 0x010a,
+        0x010c, 0x010c,
+        0x010e, 0x010e,
+        0x0110, 0x0110,
+        0x0112, 0x0112,
+        0x0114, 0x0114,
+        0x0116, 0x0116,
+        0x0118, 0x0118,
+        0x011a, 0x011a,
+        0x011c, 0x011c,
+        0x011e, 0x011e,
+        0x0120, 0x0120,
+        0x0122, 0x0122,
+        0x0124, 0x0124,
+        0x0126, 0x0126,
+        0x0128, 0x0128,
+        0x012a, 0x012a,
+        0x012c, 0x012c,
+        0x012e, 0x012e,
+        0x0130, 0x0130,
+        0x0132, 0x0132,
+        0x0134, 0x0134,
+        0x0136, 0x0136,
+        0x0139, 0x0139,
+        0x013b, 0x013b,
+        0x013d, 0x013d,
+        0x013f, 0x013f,
+        0x0141, 0x0141,
+        0x0143, 0x0143,
+        0x0145, 0x0145,
+        0x0147, 0x0147,
+        0x014a, 0x014a,
+        0x014c, 0x014c,
+        0x014e, 0x014e,
+        0x0150, 0x0150,
+        0x0152, 0x0152,
+        0x0154, 0x0154,
+        0x0156, 0x0156,
+        0x0158, 0x0158,
+        0x015a, 0x015a,
+        0x015c, 0x015c,
+        0x015e, 0x015e,
+        0x0160, 0x0160,
+        0x0162, 0x0162,
+        0x0164, 0x0164,
+        0x0166, 0x0166,
+        0x0168, 0x0168,
+        0x016a, 0x016a,
+        0x016c, 0x016c,
+        0x016e, 0x016e,
+        0x0170, 0x0170,
+        0x0172, 0x0172,
+        0x0174, 0x0174,
+        0x0176, 0x0176,
+        0x0178, 0x0179,
+        0x017b, 0x017b,
+        0x017d, 0x017d,
+        0x0181, 0x0182,
+        0x0184, 0x0184,
+        0x0186, 0x0187,
+        0x0189, 0x018b,
+        0x018e, 0x0191,
+        0x0193, 0x0194,
+        0x0196, 0x0198,
+        0x019c, 0x019d,
+        0x019f, 0x01a0,
+        0x01a2, 0x01a2,
+        0x01a4, 0x01a4,
+        0x01a6, 0x01a7,
+        0x01a9, 0x01a9,
+        0x01ac, 0x01ac,
+        0x01ae, 0x01af,
+        0x01b1, 0x01b3,
+        0x01b5, 0x01b5,
+        0x01b7, 0x01b8,
+        0x01bc, 0x01bc,
+        0x01c4, 0x01c4,
+        0x01c7, 0x01c7,
+        0x01ca, 0x01ca,
+        0x01cd, 0x01cd,
+        0x01cf, 0x01cf,
+        0x01d1, 0x01d1,
+        0x01d3, 0x01d3,
+        0x01d5, 0x01d5,
+        0x01d7, 0x01d7,
+        0x01d9, 0x01d9,
+        0x01db, 0x01db,
+        0x01de, 0x01de,
+        0x01e0, 0x01e0,
+        0x01e2, 0x01e2,
+        0x01e4, 0x01e4,
+        0x01e6, 0x01e6,
+        0x01e8, 0x01e8,
+        0x01ea, 0x01ea,
+        0x01ec, 0x01ec,
+        0x01ee, 0x01ee,
+        0x01f1, 0x01f1,
+        0x01f4, 0x01f4,
+        0x01f6, 0x01f8,
+        0x01fa, 0x01fa,
+        0x01fc, 0x01fc,
+        0x01fe, 0x01fe,
+        0x0200, 0x0200,
+        0x0202, 0x0202,
+        0x0204, 0x0204,
+        0x0206, 0x0206,
+        0x0208, 0x0208,
+        0x020a, 0x020a,
+        0x020c, 0x020c,
+        0x020e, 0x020e,
+        0x0210, 0x0210,
+        0x0212, 0x0212,
+        0x0214, 0x0214,
+        0x0216, 0x0216,
+        0x0218, 0x0218,
+        0x021a, 0x021a,
+        0x021c, 0x021c,
+        0x021e, 0x021e,
+        0x0220, 0x0220,
+        0x0222, 0x0222,
+        0x0224, 0x0224,
+        0x0226, 0x0226,
+        0x0228, 0x0228,
+        0x022a, 0x022a,
+        0x022c, 0x022c,
+        0x022e, 0x022e,
+        0x0230, 0x0230,
+        0x0232, 0x0232,
+        0x023a, 0x023b,
+        0x023d, 0x023e,
+        0x0241, 0x0241,
+        0x0243, 0x0246,
+        0x0248, 0x0248,
+        0x024a, 0x024a,
+        0x024c, 0x024c,
+        0x024e, 0x024e,
+        0x0370, 0x0370,
+        0x0372, 0x0372,
+        0x0376, 0x0376,
+        0x0386, 0x0386,
+        0x0388, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x038f,
+        0x0391, 0x03a1,
+        0x03a3, 0x03ab,
+        0x03cf, 0x03cf,
+        0x03d2, 0x03d4,
+        0x03d8, 0x03d8,
+        0x03da, 0x03da,
+        0x03dc, 0x03dc,
+        0x03de, 0x03de,
+        0x03e0, 0x03e0,
+        0x03e2, 0x03e2,
+        0x03e4, 0x03e4,
+        0x03e6, 0x03e6,
+        0x03e8, 0x03e8,
+        0x03ea, 0x03ea,
+        0x03ec, 0x03ec,
+        0x03ee, 0x03ee,
+        0x03f4, 0x03f4,
+        0x03f7, 0x03f7,
+        0x03f9, 0x03fa,
+        0x03fd, 0x042f,
+        0x0460, 0x0460,
+        0x0462, 0x0462,
+        0x0464, 0x0464,
+        0x0466, 0x0466,
+        0x0468, 0x0468,
+        0x046a, 0x046a,
+        0x046c, 0x046c,
+        0x046e, 0x046e,
+        0x0470, 0x0470,
+        0x0472, 0x0472,
+        0x0474, 0x0474,
+        0x0476, 0x0476,
+        0x0478, 0x0478,
+        0x047a, 0x047a,
+        0x047c, 0x047c,
+        0x047e, 0x047e,
+        0x0480, 0x0480,
+        0x048a, 0x048a,
+        0x048c, 0x048c,
+        0x048e, 0x048e,
+        0x0490, 0x0490,
+        0x0492, 0x0492,
+        0x0494, 0x0494,
+        0x0496, 0x0496,
+        0x0498, 0x0498,
+        0x049a, 0x049a,
+        0x049c, 0x049c,
+        0x049e, 0x049e,
+        0x04a0, 0x04a0,
+        0x04a2, 0x04a2,
+        0x04a4, 0x04a4,
+        0x04a6, 0x04a6,
+        0x04a8, 0x04a8,
+        0x04aa, 0x04aa,
+        0x04ac, 0x04ac,
+        0x04ae, 0x04ae,
+        0x04b0, 0x04b0,
+        0x04b2, 0x04b2,
+        0x04b4, 0x04b4,
+        0x04b6, 0x04b6,
+        0x04b8, 0x04b8,
+        0x04ba, 0x04ba,
+        0x04bc, 0x04bc,
+        0x04be, 0x04be,
+        0x04c0, 0x04c1,
+        0x04c3, 0x04c3,
+        0x04c5, 0x04c5,
+        0x04c7, 0x04c7,
+        0x04c9, 0x04c9,
+        0x04cb, 0x04cb,
+        0x04cd, 0x04cd,
+        0x04d0, 0x04d0,
+        0x04d2, 0x04d2,
+        0x04d4, 0x04d4,
+        0x04d6, 0x04d6,
+        0x04d8, 0x04d8,
+        0x04da, 0x04da,
+        0x04dc, 0x04dc,
+        0x04de, 0x04de,
+        0x04e0, 0x04e0,
+        0x04e2, 0x04e2,
+        0x04e4, 0x04e4,
+        0x04e6, 0x04e6,
+        0x04e8, 0x04e8,
+        0x04ea, 0x04ea,
+        0x04ec, 0x04ec,
+        0x04ee, 0x04ee,
+        0x04f0, 0x04f0,
+        0x04f2, 0x04f2,
+        0x04f4, 0x04f4,
+        0x04f6, 0x04f6,
+        0x04f8, 0x04f8,
+        0x04fa, 0x04fa,
+        0x04fc, 0x04fc,
+        0x04fe, 0x04fe,
+        0x0500, 0x0500,
+        0x0502, 0x0502,
+        0x0504, 0x0504,
+        0x0506, 0x0506,
+        0x0508, 0x0508,
+        0x050a, 0x050a,
+        0x050c, 0x050c,
+        0x050e, 0x050e,
+        0x0510, 0x0510,
+        0x0512, 0x0512,
+        0x0514, 0x0514,
+        0x0516, 0x0516,
+        0x0518, 0x0518,
+        0x051a, 0x051a,
+        0x051c, 0x051c,
+        0x051e, 0x051e,
+        0x0520, 0x0520,
+        0x0522, 0x0522,
+        0x0524, 0x0524,
+        0x0531, 0x0556,
+        0x10a0, 0x10c5,
+        0x1e00, 0x1e00,
+        0x1e02, 0x1e02,
+        0x1e04, 0x1e04,
+        0x1e06, 0x1e06,
+        0x1e08, 0x1e08,
+        0x1e0a, 0x1e0a,
+        0x1e0c, 0x1e0c,
+        0x1e0e, 0x1e0e,
+        0x1e10, 0x1e10,
+        0x1e12, 0x1e12,
+        0x1e14, 0x1e14,
+        0x1e16, 0x1e16,
+        0x1e18, 0x1e18,
+        0x1e1a, 0x1e1a,
+        0x1e1c, 0x1e1c,
+        0x1e1e, 0x1e1e,
+        0x1e20, 0x1e20,
+        0x1e22, 0x1e22,
+        0x1e24, 0x1e24,
+        0x1e26, 0x1e26,
+        0x1e28, 0x1e28,
+        0x1e2a, 0x1e2a,
+        0x1e2c, 0x1e2c,
+        0x1e2e, 0x1e2e,
+        0x1e30, 0x1e30,
+        0x1e32, 0x1e32,
+        0x1e34, 0x1e34,
+        0x1e36, 0x1e36,
+        0x1e38, 0x1e38,
+        0x1e3a, 0x1e3a,
+        0x1e3c, 0x1e3c,
+        0x1e3e, 0x1e3e,
+        0x1e40, 0x1e40,
+        0x1e42, 0x1e42,
+        0x1e44, 0x1e44,
+        0x1e46, 0x1e46,
+        0x1e48, 0x1e48,
+        0x1e4a, 0x1e4a,
+        0x1e4c, 0x1e4c,
+        0x1e4e, 0x1e4e,
+        0x1e50, 0x1e50,
+        0x1e52, 0x1e52,
+        0x1e54, 0x1e54,
+        0x1e56, 0x1e56,
+        0x1e58, 0x1e58,
+        0x1e5a, 0x1e5a,
+        0x1e5c, 0x1e5c,
+        0x1e5e, 0x1e5e,
+        0x1e60, 0x1e60,
+        0x1e62, 0x1e62,
+        0x1e64, 0x1e64,
+        0x1e66, 0x1e66,
+        0x1e68, 0x1e68,
+        0x1e6a, 0x1e6a,
+        0x1e6c, 0x1e6c,
+        0x1e6e, 0x1e6e,
+        0x1e70, 0x1e70,
+        0x1e72, 0x1e72,
+        0x1e74, 0x1e74,
+        0x1e76, 0x1e76,
+        0x1e78, 0x1e78,
+        0x1e7a, 0x1e7a,
+        0x1e7c, 0x1e7c,
+        0x1e7e, 0x1e7e,
+        0x1e80, 0x1e80,
+        0x1e82, 0x1e82,
+        0x1e84, 0x1e84,
+        0x1e86, 0x1e86,
+        0x1e88, 0x1e88,
+        0x1e8a, 0x1e8a,
+        0x1e8c, 0x1e8c,
+        0x1e8e, 0x1e8e,
+        0x1e90, 0x1e90,
+        0x1e92, 0x1e92,
+        0x1e94, 0x1e94,
+        0x1e9e, 0x1e9e,
+        0x1ea0, 0x1ea0,
+        0x1ea2, 0x1ea2,
+        0x1ea4, 0x1ea4,
+        0x1ea6, 0x1ea6,
+        0x1ea8, 0x1ea8,
+        0x1eaa, 0x1eaa,
+        0x1eac, 0x1eac,
+        0x1eae, 0x1eae,
+        0x1eb0, 0x1eb0,
+        0x1eb2, 0x1eb2,
+        0x1eb4, 0x1eb4,
+        0x1eb6, 0x1eb6,
+        0x1eb8, 0x1eb8,
+        0x1eba, 0x1eba,
+        0x1ebc, 0x1ebc,
+        0x1ebe, 0x1ebe,
+        0x1ec0, 0x1ec0,
+        0x1ec2, 0x1ec2,
+        0x1ec4, 0x1ec4,
+        0x1ec6, 0x1ec6,
+        0x1ec8, 0x1ec8,
+        0x1eca, 0x1eca,
+        0x1ecc, 0x1ecc,
+        0x1ece, 0x1ece,
+        0x1ed0, 0x1ed0,
+        0x1ed2, 0x1ed2,
+        0x1ed4, 0x1ed4,
+        0x1ed6, 0x1ed6,
+        0x1ed8, 0x1ed8,
+        0x1eda, 0x1eda,
+        0x1edc, 0x1edc,
+        0x1ede, 0x1ede,
+        0x1ee0, 0x1ee0,
+        0x1ee2, 0x1ee2,
+        0x1ee4, 0x1ee4,
+        0x1ee6, 0x1ee6,
+        0x1ee8, 0x1ee8,
+        0x1eea, 0x1eea,
+        0x1eec, 0x1eec,
+        0x1eee, 0x1eee,
+        0x1ef0, 0x1ef0,
+        0x1ef2, 0x1ef2,
+        0x1ef4, 0x1ef4,
+        0x1ef6, 0x1ef6,
+        0x1ef8, 0x1ef8,
+        0x1efa, 0x1efa,
+        0x1efc, 0x1efc,
+        0x1efe, 0x1efe,
+        0x1f08, 0x1f0f,
+        0x1f18, 0x1f1d,
+        0x1f28, 0x1f2f,
+        0x1f38, 0x1f3f,
+        0x1f48, 0x1f4d,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f5f,
+        0x1f68, 0x1f6f,
+        0x1fb8, 0x1fbb,
+        0x1fc8, 0x1fcb,
+        0x1fd8, 0x1fdb,
+        0x1fe8, 0x1fec,
+        0x1ff8, 0x1ffb,
+        0x2102, 0x2102,
+        0x2107, 0x2107,
+        0x210b, 0x210d,
+        0x2110, 0x2112,
+        0x2115, 0x2115,
+        0x2119, 0x211d,
+        0x2124, 0x2124,
+        0x2126, 0x2126,
+        0x2128, 0x2128,
+        0x212a, 0x212d,
+        0x2130, 0x2133,
+        0x213e, 0x213f,
+        0x2145, 0x2145,
+        0x2183, 0x2183,
+        0x2c00, 0x2c2e,
+        0x2c60, 0x2c60,
+        0x2c62, 0x2c64,
+        0x2c67, 0x2c67,
+        0x2c69, 0x2c69,
+        0x2c6b, 0x2c6b,
+        0x2c6d, 0x2c70,
+        0x2c72, 0x2c72,
+        0x2c75, 0x2c75,
+        0x2c7e, 0x2c80,
+        0x2c82, 0x2c82,
+        0x2c84, 0x2c84,
+        0x2c86, 0x2c86,
+        0x2c88, 0x2c88,
+        0x2c8a, 0x2c8a,
+        0x2c8c, 0x2c8c,
+        0x2c8e, 0x2c8e,
+        0x2c90, 0x2c90,
+        0x2c92, 0x2c92,
+        0x2c94, 0x2c94,
+        0x2c96, 0x2c96,
+        0x2c98, 0x2c98,
+        0x2c9a, 0x2c9a,
+        0x2c9c, 0x2c9c,
+        0x2c9e, 0x2c9e,
+        0x2ca0, 0x2ca0,
+        0x2ca2, 0x2ca2,
+        0x2ca4, 0x2ca4,
+        0x2ca6, 0x2ca6,
+        0x2ca8, 0x2ca8,
+        0x2caa, 0x2caa,
+        0x2cac, 0x2cac,
+        0x2cae, 0x2cae,
+        0x2cb0, 0x2cb0,
+        0x2cb2, 0x2cb2,
+        0x2cb4, 0x2cb4,
+        0x2cb6, 0x2cb6,
+        0x2cb8, 0x2cb8,
+        0x2cba, 0x2cba,
+        0x2cbc, 0x2cbc,
+        0x2cbe, 0x2cbe,
+        0x2cc0, 0x2cc0,
+        0x2cc2, 0x2cc2,
+        0x2cc4, 0x2cc4,
+        0x2cc6, 0x2cc6,
+        0x2cc8, 0x2cc8,
+        0x2cca, 0x2cca,
+        0x2ccc, 0x2ccc,
+        0x2cce, 0x2cce,
+        0x2cd0, 0x2cd0,
+        0x2cd2, 0x2cd2,
+        0x2cd4, 0x2cd4,
+        0x2cd6, 0x2cd6,
+        0x2cd8, 0x2cd8,
+        0x2cda, 0x2cda,
+        0x2cdc, 0x2cdc,
+        0x2cde, 0x2cde,
+        0x2ce0, 0x2ce0,
+        0x2ce2, 0x2ce2,
+        0x2ceb, 0x2ceb,
+        0x2ced, 0x2ced,
+        0xa640, 0xa640,
+        0xa642, 0xa642,
+        0xa644, 0xa644,
+        0xa646, 0xa646,
+        0xa648, 0xa648,
+        0xa64a, 0xa64a,
+        0xa64c, 0xa64c,
+        0xa64e, 0xa64e,
+        0xa650, 0xa650,
+        0xa652, 0xa652,
+        0xa654, 0xa654,
+        0xa656, 0xa656,
+        0xa658, 0xa658,
+        0xa65a, 0xa65a,
+        0xa65c, 0xa65c,
+        0xa65e, 0xa65e,
+        0xa662, 0xa662,
+        0xa664, 0xa664,
+        0xa666, 0xa666,
+        0xa668, 0xa668,
+        0xa66a, 0xa66a,
+        0xa66c, 0xa66c,
+        0xa680, 0xa680,
+        0xa682, 0xa682,
+        0xa684, 0xa684,
+        0xa686, 0xa686,
+        0xa688, 0xa688,
+        0xa68a, 0xa68a,
+        0xa68c, 0xa68c,
+        0xa68e, 0xa68e,
+        0xa690, 0xa690,
+        0xa692, 0xa692,
+        0xa694, 0xa694,
+        0xa696, 0xa696,
+        0xa722, 0xa722,
+        0xa724, 0xa724,
+        0xa726, 0xa726,
+        0xa728, 0xa728,
+        0xa72a, 0xa72a,
+        0xa72c, 0xa72c,
+        0xa72e, 0xa72e,
+        0xa732, 0xa732,
+        0xa734, 0xa734,
+        0xa736, 0xa736,
+        0xa738, 0xa738,
+        0xa73a, 0xa73a,
+        0xa73c, 0xa73c,
+        0xa73e, 0xa73e,
+        0xa740, 0xa740,
+        0xa742, 0xa742,
+        0xa744, 0xa744,
+        0xa746, 0xa746,
+        0xa748, 0xa748,
+        0xa74a, 0xa74a,
+        0xa74c, 0xa74c,
+        0xa74e, 0xa74e,
+        0xa750, 0xa750,
+        0xa752, 0xa752,
+        0xa754, 0xa754,
+        0xa756, 0xa756,
+        0xa758, 0xa758,
+        0xa75a, 0xa75a,
+        0xa75c, 0xa75c,
+        0xa75e, 0xa75e,
+        0xa760, 0xa760,
+        0xa762, 0xa762,
+        0xa764, 0xa764,
+        0xa766, 0xa766,
+        0xa768, 0xa768,
+        0xa76a, 0xa76a,
+        0xa76c, 0xa76c,
+        0xa76e, 0xa76e,
+        0xa779, 0xa779,
+        0xa77b, 0xa77b,
+        0xa77d, 0xa77e,
+        0xa780, 0xa780,
+        0xa782, 0xa782,
+        0xa784, 0xa784,
+        0xa786, 0xa786,
+        0xa78b, 0xa78b,
+        0xff21, 0xff3a,
+        0x10400, 0x10427,
+        0x1d400, 0x1d419,
+        0x1d434, 0x1d44d,
+        0x1d468, 0x1d481,
+        0x1d49c, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b5,
+        0x1d4d0, 0x1d4e9,
+        0x1d504, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d538, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d56c, 0x1d585,
+        0x1d5a0, 0x1d5b9,
+        0x1d5d4, 0x1d5ed,
+        0x1d608, 0x1d621,
+        0x1d63c, 0x1d655,
+        0x1d670, 0x1d689,
+        0x1d6a8, 0x1d6c0,
+        0x1d6e2, 0x1d6fa,
+        0x1d71c, 0x1d734,
+        0x1d756, 0x1d76e,
+        0x1d790, 0x1d7a8,
+        0x1d7ca, 0x1d7ca,
 }; /* CR_Lu */
 
 /* 'M': Major Category */
 static const OnigCodePoint CR_M[] = {
-	188,
-	0x0300, 0x036f,
-	0x0483, 0x0489,
-	0x0591, 0x05bd,
-	0x05bf, 0x05bf,
-	0x05c1, 0x05c2,
-	0x05c4, 0x05c5,
-	0x05c7, 0x05c7,
-	0x0610, 0x061a,
-	0x064b, 0x065e,
-	0x0670, 0x0670,
-	0x06d6, 0x06dc,
-	0x06de, 0x06e4,
-	0x06e7, 0x06e8,
-	0x06ea, 0x06ed,
-	0x0711, 0x0711,
-	0x0730, 0x074a,
-	0x07a6, 0x07b0,
-	0x07eb, 0x07f3,
-	0x0816, 0x0819,
-	0x081b, 0x0823,
-	0x0825, 0x0827,
-	0x0829, 0x082d,
-	0x0900, 0x0903,
-	0x093c, 0x093c,
-	0x093e, 0x094e,
-	0x0951, 0x0955,
-	0x0962, 0x0963,
-	0x0981, 0x0983,
-	0x09bc, 0x09bc,
-	0x09be, 0x09c4,
-	0x09c7, 0x09c8,
-	0x09cb, 0x09cd,
-	0x09d7, 0x09d7,
-	0x09e2, 0x09e3,
-	0x0a01, 0x0a03,
-	0x0a3c, 0x0a3c,
-	0x0a3e, 0x0a42,
-	0x0a47, 0x0a48,
-	0x0a4b, 0x0a4d,
-	0x0a51, 0x0a51,
-	0x0a70, 0x0a71,
-	0x0a75, 0x0a75,
-	0x0a81, 0x0a83,
-	0x0abc, 0x0abc,
-	0x0abe, 0x0ac5,
-	0x0ac7, 0x0ac9,
-	0x0acb, 0x0acd,
-	0x0ae2, 0x0ae3,
-	0x0b01, 0x0b03,
-	0x0b3c, 0x0b3c,
-	0x0b3e, 0x0b44,
-	0x0b47, 0x0b48,
-	0x0b4b, 0x0b4d,
-	0x0b56, 0x0b57,
-	0x0b62, 0x0b63,
-	0x0b82, 0x0b82,
-	0x0bbe, 0x0bc2,
-	0x0bc6, 0x0bc8,
-	0x0bca, 0x0bcd,
-	0x0bd7, 0x0bd7,
-	0x0c01, 0x0c03,
-	0x0c3e, 0x0c44,
-	0x0c46, 0x0c48,
-	0x0c4a, 0x0c4d,
-	0x0c55, 0x0c56,
-	0x0c62, 0x0c63,
-	0x0c82, 0x0c83,
-	0x0cbc, 0x0cbc,
-	0x0cbe, 0x0cc4,
-	0x0cc6, 0x0cc8,
-	0x0cca, 0x0ccd,
-	0x0cd5, 0x0cd6,
-	0x0ce2, 0x0ce3,
-	0x0d02, 0x0d03,
-	0x0d3e, 0x0d44,
-	0x0d46, 0x0d48,
-	0x0d4a, 0x0d4d,
-	0x0d57, 0x0d57,
-	0x0d62, 0x0d63,
-	0x0d82, 0x0d83,
-	0x0dca, 0x0dca,
-	0x0dcf, 0x0dd4,
-	0x0dd6, 0x0dd6,
-	0x0dd8, 0x0ddf,
-	0x0df2, 0x0df3,
-	0x0e31, 0x0e31,
-	0x0e34, 0x0e3a,
-	0x0e47, 0x0e4e,
-	0x0eb1, 0x0eb1,
-	0x0eb4, 0x0eb9,
-	0x0ebb, 0x0ebc,
-	0x0ec8, 0x0ecd,
-	0x0f18, 0x0f19,
-	0x0f35, 0x0f35,
-	0x0f37, 0x0f37,
-	0x0f39, 0x0f39,
-	0x0f3e, 0x0f3f,
-	0x0f71, 0x0f84,
-	0x0f86, 0x0f87,
-	0x0f90, 0x0f97,
-	0x0f99, 0x0fbc,
-	0x0fc6, 0x0fc6,
-	0x102b, 0x103e,
-	0x1056, 0x1059,
-	0x105e, 0x1060,
-	0x1062, 0x1064,
-	0x1067, 0x106d,
-	0x1071, 0x1074,
-	0x1082, 0x108d,
-	0x108f, 0x108f,
-	0x109a, 0x109d,
-	0x135f, 0x135f,
-	0x1712, 0x1714,
-	0x1732, 0x1734,
-	0x1752, 0x1753,
-	0x1772, 0x1773,
-	0x17b6, 0x17d3,
-	0x17dd, 0x17dd,
-	0x180b, 0x180d,
-	0x18a9, 0x18a9,
-	0x1920, 0x192b,
-	0x1930, 0x193b,
-	0x19b0, 0x19c0,
-	0x19c8, 0x19c9,
-	0x1a17, 0x1a1b,
-	0x1a55, 0x1a5e,
-	0x1a60, 0x1a7c,
-	0x1a7f, 0x1a7f,
-	0x1b00, 0x1b04,
-	0x1b34, 0x1b44,
-	0x1b6b, 0x1b73,
-	0x1b80, 0x1b82,
-	0x1ba1, 0x1baa,
-	0x1c24, 0x1c37,
-	0x1cd0, 0x1cd2,
-	0x1cd4, 0x1ce8,
-	0x1ced, 0x1ced,
-	0x1cf2, 0x1cf2,
-	0x1dc0, 0x1de6,
-	0x1dfd, 0x1dff,
-	0x20d0, 0x20f0,
-	0x2cef, 0x2cf1,
-	0x2de0, 0x2dff,
-	0x302a, 0x302f,
-	0x3099, 0x309a,
-	0xa66f, 0xa672,
-	0xa67c, 0xa67d,
-	0xa6f0, 0xa6f1,
-	0xa802, 0xa802,
-	0xa806, 0xa806,
-	0xa80b, 0xa80b,
-	0xa823, 0xa827,
-	0xa880, 0xa881,
-	0xa8b4, 0xa8c4,
-	0xa8e0, 0xa8f1,
-	0xa926, 0xa92d,
-	0xa947, 0xa953,
-	0xa980, 0xa983,
-	0xa9b3, 0xa9c0,
-	0xaa29, 0xaa36,
-	0xaa43, 0xaa43,
-	0xaa4c, 0xaa4d,
-	0xaa7b, 0xaa7b,
-	0xaab0, 0xaab0,
-	0xaab2, 0xaab4,
-	0xaab7, 0xaab8,
-	0xaabe, 0xaabf,
-	0xaac1, 0xaac1,
-	0xabe3, 0xabea,
-	0xabec, 0xabed,
-	0xfb1e, 0xfb1e,
-	0xfe00, 0xfe0f,
-	0xfe20, 0xfe26,
-	0x101fd, 0x101fd,
-	0x10a01, 0x10a03,
-	0x10a05, 0x10a06,
-	0x10a0c, 0x10a0f,
-	0x10a38, 0x10a3a,
-	0x10a3f, 0x10a3f,
-	0x11080, 0x11082,
-	0x110b0, 0x110ba,
-	0x1d165, 0x1d169,
-	0x1d16d, 0x1d172,
-	0x1d17b, 0x1d182,
-	0x1d185, 0x1d18b,
-	0x1d1aa, 0x1d1ad,
-	0x1d242, 0x1d244,
-	0xe0100, 0xe01ef,
+        188,
+        0x0300, 0x036f,
+        0x0483, 0x0489,
+        0x0591, 0x05bd,
+        0x05bf, 0x05bf,
+        0x05c1, 0x05c2,
+        0x05c4, 0x05c5,
+        0x05c7, 0x05c7,
+        0x0610, 0x061a,
+        0x064b, 0x065e,
+        0x0670, 0x0670,
+        0x06d6, 0x06dc,
+        0x06de, 0x06e4,
+        0x06e7, 0x06e8,
+        0x06ea, 0x06ed,
+        0x0711, 0x0711,
+        0x0730, 0x074a,
+        0x07a6, 0x07b0,
+        0x07eb, 0x07f3,
+        0x0816, 0x0819,
+        0x081b, 0x0823,
+        0x0825, 0x0827,
+        0x0829, 0x082d,
+        0x0900, 0x0903,
+        0x093c, 0x093c,
+        0x093e, 0x094e,
+        0x0951, 0x0955,
+        0x0962, 0x0963,
+        0x0981, 0x0983,
+        0x09bc, 0x09bc,
+        0x09be, 0x09c4,
+        0x09c7, 0x09c8,
+        0x09cb, 0x09cd,
+        0x09d7, 0x09d7,
+        0x09e2, 0x09e3,
+        0x0a01, 0x0a03,
+        0x0a3c, 0x0a3c,
+        0x0a3e, 0x0a42,
+        0x0a47, 0x0a48,
+        0x0a4b, 0x0a4d,
+        0x0a51, 0x0a51,
+        0x0a70, 0x0a71,
+        0x0a75, 0x0a75,
+        0x0a81, 0x0a83,
+        0x0abc, 0x0abc,
+        0x0abe, 0x0ac5,
+        0x0ac7, 0x0ac9,
+        0x0acb, 0x0acd,
+        0x0ae2, 0x0ae3,
+        0x0b01, 0x0b03,
+        0x0b3c, 0x0b3c,
+        0x0b3e, 0x0b44,
+        0x0b47, 0x0b48,
+        0x0b4b, 0x0b4d,
+        0x0b56, 0x0b57,
+        0x0b62, 0x0b63,
+        0x0b82, 0x0b82,
+        0x0bbe, 0x0bc2,
+        0x0bc6, 0x0bc8,
+        0x0bca, 0x0bcd,
+        0x0bd7, 0x0bd7,
+        0x0c01, 0x0c03,
+        0x0c3e, 0x0c44,
+        0x0c46, 0x0c48,
+        0x0c4a, 0x0c4d,
+        0x0c55, 0x0c56,
+        0x0c62, 0x0c63,
+        0x0c82, 0x0c83,
+        0x0cbc, 0x0cbc,
+        0x0cbe, 0x0cc4,
+        0x0cc6, 0x0cc8,
+        0x0cca, 0x0ccd,
+        0x0cd5, 0x0cd6,
+        0x0ce2, 0x0ce3,
+        0x0d02, 0x0d03,
+        0x0d3e, 0x0d44,
+        0x0d46, 0x0d48,
+        0x0d4a, 0x0d4d,
+        0x0d57, 0x0d57,
+        0x0d62, 0x0d63,
+        0x0d82, 0x0d83,
+        0x0dca, 0x0dca,
+        0x0dcf, 0x0dd4,
+        0x0dd6, 0x0dd6,
+        0x0dd8, 0x0ddf,
+        0x0df2, 0x0df3,
+        0x0e31, 0x0e31,
+        0x0e34, 0x0e3a,
+        0x0e47, 0x0e4e,
+        0x0eb1, 0x0eb1,
+        0x0eb4, 0x0eb9,
+        0x0ebb, 0x0ebc,
+        0x0ec8, 0x0ecd,
+        0x0f18, 0x0f19,
+        0x0f35, 0x0f35,
+        0x0f37, 0x0f37,
+        0x0f39, 0x0f39,
+        0x0f3e, 0x0f3f,
+        0x0f71, 0x0f84,
+        0x0f86, 0x0f87,
+        0x0f90, 0x0f97,
+        0x0f99, 0x0fbc,
+        0x0fc6, 0x0fc6,
+        0x102b, 0x103e,
+        0x1056, 0x1059,
+        0x105e, 0x1060,
+        0x1062, 0x1064,
+        0x1067, 0x106d,
+        0x1071, 0x1074,
+        0x1082, 0x108d,
+        0x108f, 0x108f,
+        0x109a, 0x109d,
+        0x135f, 0x135f,
+        0x1712, 0x1714,
+        0x1732, 0x1734,
+        0x1752, 0x1753,
+        0x1772, 0x1773,
+        0x17b6, 0x17d3,
+        0x17dd, 0x17dd,
+        0x180b, 0x180d,
+        0x18a9, 0x18a9,
+        0x1920, 0x192b,
+        0x1930, 0x193b,
+        0x19b0, 0x19c0,
+        0x19c8, 0x19c9,
+        0x1a17, 0x1a1b,
+        0x1a55, 0x1a5e,
+        0x1a60, 0x1a7c,
+        0x1a7f, 0x1a7f,
+        0x1b00, 0x1b04,
+        0x1b34, 0x1b44,
+        0x1b6b, 0x1b73,
+        0x1b80, 0x1b82,
+        0x1ba1, 0x1baa,
+        0x1c24, 0x1c37,
+        0x1cd0, 0x1cd2,
+        0x1cd4, 0x1ce8,
+        0x1ced, 0x1ced,
+        0x1cf2, 0x1cf2,
+        0x1dc0, 0x1de6,
+        0x1dfd, 0x1dff,
+        0x20d0, 0x20f0,
+        0x2cef, 0x2cf1,
+        0x2de0, 0x2dff,
+        0x302a, 0x302f,
+        0x3099, 0x309a,
+        0xa66f, 0xa672,
+        0xa67c, 0xa67d,
+        0xa6f0, 0xa6f1,
+        0xa802, 0xa802,
+        0xa806, 0xa806,
+        0xa80b, 0xa80b,
+        0xa823, 0xa827,
+        0xa880, 0xa881,
+        0xa8b4, 0xa8c4,
+        0xa8e0, 0xa8f1,
+        0xa926, 0xa92d,
+        0xa947, 0xa953,
+        0xa980, 0xa983,
+        0xa9b3, 0xa9c0,
+        0xaa29, 0xaa36,
+        0xaa43, 0xaa43,
+        0xaa4c, 0xaa4d,
+        0xaa7b, 0xaa7b,
+        0xaab0, 0xaab0,
+        0xaab2, 0xaab4,
+        0xaab7, 0xaab8,
+        0xaabe, 0xaabf,
+        0xaac1, 0xaac1,
+        0xabe3, 0xabea,
+        0xabec, 0xabed,
+        0xfb1e, 0xfb1e,
+        0xfe00, 0xfe0f,
+        0xfe20, 0xfe26,
+        0x101fd, 0x101fd,
+        0x10a01, 0x10a03,
+        0x10a05, 0x10a06,
+        0x10a0c, 0x10a0f,
+        0x10a38, 0x10a3a,
+        0x10a3f, 0x10a3f,
+        0x11080, 0x11082,
+        0x110b0, 0x110ba,
+        0x1d165, 0x1d169,
+        0x1d16d, 0x1d172,
+        0x1d17b, 0x1d182,
+        0x1d185, 0x1d18b,
+        0x1d1aa, 0x1d1ad,
+        0x1d242, 0x1d244,
+        0xe0100, 0xe01ef,
 }; /* CR_M */
 
 /* 'Mc': General Category */
 static const OnigCodePoint CR_Mc[] = {
-	106,
-	0x0903, 0x0903,
-	0x093e, 0x0940,
-	0x0949, 0x094c,
-	0x094e, 0x094e,
-	0x0982, 0x0983,
-	0x09be, 0x09c0,
-	0x09c7, 0x09c8,
-	0x09cb, 0x09cc,
-	0x09d7, 0x09d7,
-	0x0a03, 0x0a03,
-	0x0a3e, 0x0a40,
-	0x0a83, 0x0a83,
-	0x0abe, 0x0ac0,
-	0x0ac9, 0x0ac9,
-	0x0acb, 0x0acc,
-	0x0b02, 0x0b03,
-	0x0b3e, 0x0b3e,
-	0x0b40, 0x0b40,
-	0x0b47, 0x0b48,
-	0x0b4b, 0x0b4c,
-	0x0b57, 0x0b57,
-	0x0bbe, 0x0bbf,
-	0x0bc1, 0x0bc2,
-	0x0bc6, 0x0bc8,
-	0x0bca, 0x0bcc,
-	0x0bd7, 0x0bd7,
-	0x0c01, 0x0c03,
-	0x0c41, 0x0c44,
-	0x0c82, 0x0c83,
-	0x0cbe, 0x0cbe,
-	0x0cc0, 0x0cc4,
-	0x0cc7, 0x0cc8,
-	0x0cca, 0x0ccb,
-	0x0cd5, 0x0cd6,
-	0x0d02, 0x0d03,
-	0x0d3e, 0x0d40,
-	0x0d46, 0x0d48,
-	0x0d4a, 0x0d4c,
-	0x0d57, 0x0d57,
-	0x0d82, 0x0d83,
-	0x0dcf, 0x0dd1,
-	0x0dd8, 0x0ddf,
-	0x0df2, 0x0df3,
-	0x0f3e, 0x0f3f,
-	0x0f7f, 0x0f7f,
-	0x102b, 0x102c,
-	0x1031, 0x1031,
-	0x1038, 0x1038,
-	0x103b, 0x103c,
-	0x1056, 0x1057,
-	0x1062, 0x1064,
-	0x1067, 0x106d,
-	0x1083, 0x1084,
-	0x1087, 0x108c,
-	0x108f, 0x108f,
-	0x109a, 0x109c,
-	0x17b6, 0x17b6,
-	0x17be, 0x17c5,
-	0x17c7, 0x17c8,
-	0x1923, 0x1926,
-	0x1929, 0x192b,
-	0x1930, 0x1931,
-	0x1933, 0x1938,
-	0x19b0, 0x19c0,
-	0x19c8, 0x19c9,
-	0x1a19, 0x1a1b,
-	0x1a55, 0x1a55,
-	0x1a57, 0x1a57,
-	0x1a61, 0x1a61,
-	0x1a63, 0x1a64,
-	0x1a6d, 0x1a72,
-	0x1b04, 0x1b04,
-	0x1b35, 0x1b35,
-	0x1b3b, 0x1b3b,
-	0x1b3d, 0x1b41,
-	0x1b43, 0x1b44,
-	0x1b82, 0x1b82,
-	0x1ba1, 0x1ba1,
-	0x1ba6, 0x1ba7,
-	0x1baa, 0x1baa,
-	0x1c24, 0x1c2b,
-	0x1c34, 0x1c35,
-	0x1ce1, 0x1ce1,
-	0x1cf2, 0x1cf2,
-	0xa823, 0xa824,
-	0xa827, 0xa827,
-	0xa880, 0xa881,
-	0xa8b4, 0xa8c3,
-	0xa952, 0xa953,
-	0xa983, 0xa983,
-	0xa9b4, 0xa9b5,
-	0xa9ba, 0xa9bb,
-	0xa9bd, 0xa9c0,
-	0xaa2f, 0xaa30,
-	0xaa33, 0xaa34,
-	0xaa4d, 0xaa4d,
-	0xaa7b, 0xaa7b,
-	0xabe3, 0xabe4,
-	0xabe6, 0xabe7,
-	0xabe9, 0xabea,
-	0xabec, 0xabec,
-	0x11082, 0x11082,
-	0x110b0, 0x110b2,
-	0x110b7, 0x110b8,
-	0x1d165, 0x1d166,
-	0x1d16d, 0x1d172,
+        106,
+        0x0903, 0x0903,
+        0x093e, 0x0940,
+        0x0949, 0x094c,
+        0x094e, 0x094e,
+        0x0982, 0x0983,
+        0x09be, 0x09c0,
+        0x09c7, 0x09c8,
+        0x09cb, 0x09cc,
+        0x09d7, 0x09d7,
+        0x0a03, 0x0a03,
+        0x0a3e, 0x0a40,
+        0x0a83, 0x0a83,
+        0x0abe, 0x0ac0,
+        0x0ac9, 0x0ac9,
+        0x0acb, 0x0acc,
+        0x0b02, 0x0b03,
+        0x0b3e, 0x0b3e,
+        0x0b40, 0x0b40,
+        0x0b47, 0x0b48,
+        0x0b4b, 0x0b4c,
+        0x0b57, 0x0b57,
+        0x0bbe, 0x0bbf,
+        0x0bc1, 0x0bc2,
+        0x0bc6, 0x0bc8,
+        0x0bca, 0x0bcc,
+        0x0bd7, 0x0bd7,
+        0x0c01, 0x0c03,
+        0x0c41, 0x0c44,
+        0x0c82, 0x0c83,
+        0x0cbe, 0x0cbe,
+        0x0cc0, 0x0cc4,
+        0x0cc7, 0x0cc8,
+        0x0cca, 0x0ccb,
+        0x0cd5, 0x0cd6,
+        0x0d02, 0x0d03,
+        0x0d3e, 0x0d40,
+        0x0d46, 0x0d48,
+        0x0d4a, 0x0d4c,
+        0x0d57, 0x0d57,
+        0x0d82, 0x0d83,
+        0x0dcf, 0x0dd1,
+        0x0dd8, 0x0ddf,
+        0x0df2, 0x0df3,
+        0x0f3e, 0x0f3f,
+        0x0f7f, 0x0f7f,
+        0x102b, 0x102c,
+        0x1031, 0x1031,
+        0x1038, 0x1038,
+        0x103b, 0x103c,
+        0x1056, 0x1057,
+        0x1062, 0x1064,
+        0x1067, 0x106d,
+        0x1083, 0x1084,
+        0x1087, 0x108c,
+        0x108f, 0x108f,
+        0x109a, 0x109c,
+        0x17b6, 0x17b6,
+        0x17be, 0x17c5,
+        0x17c7, 0x17c8,
+        0x1923, 0x1926,
+        0x1929, 0x192b,
+        0x1930, 0x1931,
+        0x1933, 0x1938,
+        0x19b0, 0x19c0,
+        0x19c8, 0x19c9,
+        0x1a19, 0x1a1b,
+        0x1a55, 0x1a55,
+        0x1a57, 0x1a57,
+        0x1a61, 0x1a61,
+        0x1a63, 0x1a64,
+        0x1a6d, 0x1a72,
+        0x1b04, 0x1b04,
+        0x1b35, 0x1b35,
+        0x1b3b, 0x1b3b,
+        0x1b3d, 0x1b41,
+        0x1b43, 0x1b44,
+        0x1b82, 0x1b82,
+        0x1ba1, 0x1ba1,
+        0x1ba6, 0x1ba7,
+        0x1baa, 0x1baa,
+        0x1c24, 0x1c2b,
+        0x1c34, 0x1c35,
+        0x1ce1, 0x1ce1,
+        0x1cf2, 0x1cf2,
+        0xa823, 0xa824,
+        0xa827, 0xa827,
+        0xa880, 0xa881,
+        0xa8b4, 0xa8c3,
+        0xa952, 0xa953,
+        0xa983, 0xa983,
+        0xa9b4, 0xa9b5,
+        0xa9ba, 0xa9bb,
+        0xa9bd, 0xa9c0,
+        0xaa2f, 0xaa30,
+        0xaa33, 0xaa34,
+        0xaa4d, 0xaa4d,
+        0xaa7b, 0xaa7b,
+        0xabe3, 0xabe4,
+        0xabe6, 0xabe7,
+        0xabe9, 0xabea,
+        0xabec, 0xabec,
+        0x11082, 0x11082,
+        0x110b0, 0x110b2,
+        0x110b7, 0x110b8,
+        0x1d165, 0x1d166,
+        0x1d16d, 0x1d172,
 }; /* CR_Mc */
 
 /* 'Me': General Category */
 static const OnigCodePoint CR_Me[] = {
-	5,
-	0x0488, 0x0489,
-	0x06de, 0x06de,
-	0x20dd, 0x20e0,
-	0x20e2, 0x20e4,
-	0xa670, 0xa672,
+        5,
+        0x0488, 0x0489,
+        0x06de, 0x06de,
+        0x20dd, 0x20e0,
+        0x20e2, 0x20e4,
+        0xa670, 0xa672,
 }; /* CR_Me */
 
 /* 'Mn': General Category */
 static const OnigCodePoint CR_Mn[] = {
-	194,
-	0x0300, 0x036f,
-	0x0483, 0x0487,
-	0x0591, 0x05bd,
-	0x05bf, 0x05bf,
-	0x05c1, 0x05c2,
-	0x05c4, 0x05c5,
-	0x05c7, 0x05c7,
-	0x0610, 0x061a,
-	0x064b, 0x065e,
-	0x0670, 0x0670,
-	0x06d6, 0x06dc,
-	0x06df, 0x06e4,
-	0x06e7, 0x06e8,
-	0x06ea, 0x06ed,
-	0x0711, 0x0711,
-	0x0730, 0x074a,
-	0x07a6, 0x07b0,
-	0x07eb, 0x07f3,
-	0x0816, 0x0819,
-	0x081b, 0x0823,
-	0x0825, 0x0827,
-	0x0829, 0x082d,
-	0x0900, 0x0902,
-	0x093c, 0x093c,
-	0x0941, 0x0948,
-	0x094d, 0x094d,
-	0x0951, 0x0955,
-	0x0962, 0x0963,
-	0x0981, 0x0981,
-	0x09bc, 0x09bc,
-	0x09c1, 0x09c4,
-	0x09cd, 0x09cd,
-	0x09e2, 0x09e3,
-	0x0a01, 0x0a02,
-	0x0a3c, 0x0a3c,
-	0x0a41, 0x0a42,
-	0x0a47, 0x0a48,
-	0x0a4b, 0x0a4d,
-	0x0a51, 0x0a51,
-	0x0a70, 0x0a71,
-	0x0a75, 0x0a75,
-	0x0a81, 0x0a82,
-	0x0abc, 0x0abc,
-	0x0ac1, 0x0ac5,
-	0x0ac7, 0x0ac8,
-	0x0acd, 0x0acd,
-	0x0ae2, 0x0ae3,
-	0x0b01, 0x0b01,
-	0x0b3c, 0x0b3c,
-	0x0b3f, 0x0b3f,
-	0x0b41, 0x0b44,
-	0x0b4d, 0x0b4d,
-	0x0b56, 0x0b56,
-	0x0b62, 0x0b63,
-	0x0b82, 0x0b82,
-	0x0bc0, 0x0bc0,
-	0x0bcd, 0x0bcd,
-	0x0c3e, 0x0c40,
-	0x0c46, 0x0c48,
-	0x0c4a, 0x0c4d,
-	0x0c55, 0x0c56,
-	0x0c62, 0x0c63,
-	0x0cbc, 0x0cbc,
-	0x0cbf, 0x0cbf,
-	0x0cc6, 0x0cc6,
-	0x0ccc, 0x0ccd,
-	0x0ce2, 0x0ce3,
-	0x0d41, 0x0d44,
-	0x0d4d, 0x0d4d,
-	0x0d62, 0x0d63,
-	0x0dca, 0x0dca,
-	0x0dd2, 0x0dd4,
-	0x0dd6, 0x0dd6,
-	0x0e31, 0x0e31,
-	0x0e34, 0x0e3a,
-	0x0e47, 0x0e4e,
-	0x0eb1, 0x0eb1,
-	0x0eb4, 0x0eb9,
-	0x0ebb, 0x0ebc,
-	0x0ec8, 0x0ecd,
-	0x0f18, 0x0f19,
-	0x0f35, 0x0f35,
-	0x0f37, 0x0f37,
-	0x0f39, 0x0f39,
-	0x0f71, 0x0f7e,
-	0x0f80, 0x0f84,
-	0x0f86, 0x0f87,
-	0x0f90, 0x0f97,
-	0x0f99, 0x0fbc,
-	0x0fc6, 0x0fc6,
-	0x102d, 0x1030,
-	0x1032, 0x1037,
-	0x1039, 0x103a,
-	0x103d, 0x103e,
-	0x1058, 0x1059,
-	0x105e, 0x1060,
-	0x1071, 0x1074,
-	0x1082, 0x1082,
-	0x1085, 0x1086,
-	0x108d, 0x108d,
-	0x109d, 0x109d,
-	0x135f, 0x135f,
-	0x1712, 0x1714,
-	0x1732, 0x1734,
-	0x1752, 0x1753,
-	0x1772, 0x1773,
-	0x17b7, 0x17bd,
-	0x17c6, 0x17c6,
-	0x17c9, 0x17d3,
-	0x17dd, 0x17dd,
-	0x180b, 0x180d,
-	0x18a9, 0x18a9,
-	0x1920, 0x1922,
-	0x1927, 0x1928,
-	0x1932, 0x1932,
-	0x1939, 0x193b,
-	0x1a17, 0x1a18,
-	0x1a56, 0x1a56,
-	0x1a58, 0x1a5e,
-	0x1a60, 0x1a60,
-	0x1a62, 0x1a62,
-	0x1a65, 0x1a6c,
-	0x1a73, 0x1a7c,
-	0x1a7f, 0x1a7f,
-	0x1b00, 0x1b03,
-	0x1b34, 0x1b34,
-	0x1b36, 0x1b3a,
-	0x1b3c, 0x1b3c,
-	0x1b42, 0x1b42,
-	0x1b6b, 0x1b73,
-	0x1b80, 0x1b81,
-	0x1ba2, 0x1ba5,
-	0x1ba8, 0x1ba9,
-	0x1c2c, 0x1c33,
-	0x1c36, 0x1c37,
-	0x1cd0, 0x1cd2,
-	0x1cd4, 0x1ce0,
-	0x1ce2, 0x1ce8,
-	0x1ced, 0x1ced,
-	0x1dc0, 0x1de6,
-	0x1dfd, 0x1dff,
-	0x20d0, 0x20dc,
-	0x20e1, 0x20e1,
-	0x20e5, 0x20f0,
-	0x2cef, 0x2cf1,
-	0x2de0, 0x2dff,
-	0x302a, 0x302f,
-	0x3099, 0x309a,
-	0xa66f, 0xa66f,
-	0xa67c, 0xa67d,
-	0xa6f0, 0xa6f1,
-	0xa802, 0xa802,
-	0xa806, 0xa806,
-	0xa80b, 0xa80b,
-	0xa825, 0xa826,
-	0xa8c4, 0xa8c4,
-	0xa8e0, 0xa8f1,
-	0xa926, 0xa92d,
-	0xa947, 0xa951,
-	0xa980, 0xa982,
-	0xa9b3, 0xa9b3,
-	0xa9b6, 0xa9b9,
-	0xa9bc, 0xa9bc,
-	0xaa29, 0xaa2e,
-	0xaa31, 0xaa32,
-	0xaa35, 0xaa36,
-	0xaa43, 0xaa43,
-	0xaa4c, 0xaa4c,
-	0xaab0, 0xaab0,
-	0xaab2, 0xaab4,
-	0xaab7, 0xaab8,
-	0xaabe, 0xaabf,
-	0xaac1, 0xaac1,
-	0xabe5, 0xabe5,
-	0xabe8, 0xabe8,
-	0xabed, 0xabed,
-	0xfb1e, 0xfb1e,
-	0xfe00, 0xfe0f,
-	0xfe20, 0xfe26,
-	0x101fd, 0x101fd,
-	0x10a01, 0x10a03,
-	0x10a05, 0x10a06,
-	0x10a0c, 0x10a0f,
-	0x10a38, 0x10a3a,
-	0x10a3f, 0x10a3f,
-	0x11080, 0x11081,
-	0x110b3, 0x110b6,
-	0x110b9, 0x110ba,
-	0x1d167, 0x1d169,
-	0x1d17b, 0x1d182,
-	0x1d185, 0x1d18b,
-	0x1d1aa, 0x1d1ad,
-	0x1d242, 0x1d244,
-	0xe0100, 0xe01ef,
+        194,
+        0x0300, 0x036f,
+        0x0483, 0x0487,
+        0x0591, 0x05bd,
+        0x05bf, 0x05bf,
+        0x05c1, 0x05c2,
+        0x05c4, 0x05c5,
+        0x05c7, 0x05c7,
+        0x0610, 0x061a,
+        0x064b, 0x065e,
+        0x0670, 0x0670,
+        0x06d6, 0x06dc,
+        0x06df, 0x06e4,
+        0x06e7, 0x06e8,
+        0x06ea, 0x06ed,
+        0x0711, 0x0711,
+        0x0730, 0x074a,
+        0x07a6, 0x07b0,
+        0x07eb, 0x07f3,
+        0x0816, 0x0819,
+        0x081b, 0x0823,
+        0x0825, 0x0827,
+        0x0829, 0x082d,
+        0x0900, 0x0902,
+        0x093c, 0x093c,
+        0x0941, 0x0948,
+        0x094d, 0x094d,
+        0x0951, 0x0955,
+        0x0962, 0x0963,
+        0x0981, 0x0981,
+        0x09bc, 0x09bc,
+        0x09c1, 0x09c4,
+        0x09cd, 0x09cd,
+        0x09e2, 0x09e3,
+        0x0a01, 0x0a02,
+        0x0a3c, 0x0a3c,
+        0x0a41, 0x0a42,
+        0x0a47, 0x0a48,
+        0x0a4b, 0x0a4d,
+        0x0a51, 0x0a51,
+        0x0a70, 0x0a71,
+        0x0a75, 0x0a75,
+        0x0a81, 0x0a82,
+        0x0abc, 0x0abc,
+        0x0ac1, 0x0ac5,
+        0x0ac7, 0x0ac8,
+        0x0acd, 0x0acd,
+        0x0ae2, 0x0ae3,
+        0x0b01, 0x0b01,
+        0x0b3c, 0x0b3c,
+        0x0b3f, 0x0b3f,
+        0x0b41, 0x0b44,
+        0x0b4d, 0x0b4d,
+        0x0b56, 0x0b56,
+        0x0b62, 0x0b63,
+        0x0b82, 0x0b82,
+        0x0bc0, 0x0bc0,
+        0x0bcd, 0x0bcd,
+        0x0c3e, 0x0c40,
+        0x0c46, 0x0c48,
+        0x0c4a, 0x0c4d,
+        0x0c55, 0x0c56,
+        0x0c62, 0x0c63,
+        0x0cbc, 0x0cbc,
+        0x0cbf, 0x0cbf,
+        0x0cc6, 0x0cc6,
+        0x0ccc, 0x0ccd,
+        0x0ce2, 0x0ce3,
+        0x0d41, 0x0d44,
+        0x0d4d, 0x0d4d,
+        0x0d62, 0x0d63,
+        0x0dca, 0x0dca,
+        0x0dd2, 0x0dd4,
+        0x0dd6, 0x0dd6,
+        0x0e31, 0x0e31,
+        0x0e34, 0x0e3a,
+        0x0e47, 0x0e4e,
+        0x0eb1, 0x0eb1,
+        0x0eb4, 0x0eb9,
+        0x0ebb, 0x0ebc,
+        0x0ec8, 0x0ecd,
+        0x0f18, 0x0f19,
+        0x0f35, 0x0f35,
+        0x0f37, 0x0f37,
+        0x0f39, 0x0f39,
+        0x0f71, 0x0f7e,
+        0x0f80, 0x0f84,
+        0x0f86, 0x0f87,
+        0x0f90, 0x0f97,
+        0x0f99, 0x0fbc,
+        0x0fc6, 0x0fc6,
+        0x102d, 0x1030,
+        0x1032, 0x1037,
+        0x1039, 0x103a,
+        0x103d, 0x103e,
+        0x1058, 0x1059,
+        0x105e, 0x1060,
+        0x1071, 0x1074,
+        0x1082, 0x1082,
+        0x1085, 0x1086,
+        0x108d, 0x108d,
+        0x109d, 0x109d,
+        0x135f, 0x135f,
+        0x1712, 0x1714,
+        0x1732, 0x1734,
+        0x1752, 0x1753,
+        0x1772, 0x1773,
+        0x17b7, 0x17bd,
+        0x17c6, 0x17c6,
+        0x17c9, 0x17d3,
+        0x17dd, 0x17dd,
+        0x180b, 0x180d,
+        0x18a9, 0x18a9,
+        0x1920, 0x1922,
+        0x1927, 0x1928,
+        0x1932, 0x1932,
+        0x1939, 0x193b,
+        0x1a17, 0x1a18,
+        0x1a56, 0x1a56,
+        0x1a58, 0x1a5e,
+        0x1a60, 0x1a60,
+        0x1a62, 0x1a62,
+        0x1a65, 0x1a6c,
+        0x1a73, 0x1a7c,
+        0x1a7f, 0x1a7f,
+        0x1b00, 0x1b03,
+        0x1b34, 0x1b34,
+        0x1b36, 0x1b3a,
+        0x1b3c, 0x1b3c,
+        0x1b42, 0x1b42,
+        0x1b6b, 0x1b73,
+        0x1b80, 0x1b81,
+        0x1ba2, 0x1ba5,
+        0x1ba8, 0x1ba9,
+        0x1c2c, 0x1c33,
+        0x1c36, 0x1c37,
+        0x1cd0, 0x1cd2,
+        0x1cd4, 0x1ce0,
+        0x1ce2, 0x1ce8,
+        0x1ced, 0x1ced,
+        0x1dc0, 0x1de6,
+        0x1dfd, 0x1dff,
+        0x20d0, 0x20dc,
+        0x20e1, 0x20e1,
+        0x20e5, 0x20f0,
+        0x2cef, 0x2cf1,
+        0x2de0, 0x2dff,
+        0x302a, 0x302f,
+        0x3099, 0x309a,
+        0xa66f, 0xa66f,
+        0xa67c, 0xa67d,
+        0xa6f0, 0xa6f1,
+        0xa802, 0xa802,
+        0xa806, 0xa806,
+        0xa80b, 0xa80b,
+        0xa825, 0xa826,
+        0xa8c4, 0xa8c4,
+        0xa8e0, 0xa8f1,
+        0xa926, 0xa92d,
+        0xa947, 0xa951,
+        0xa980, 0xa982,
+        0xa9b3, 0xa9b3,
+        0xa9b6, 0xa9b9,
+        0xa9bc, 0xa9bc,
+        0xaa29, 0xaa2e,
+        0xaa31, 0xaa32,
+        0xaa35, 0xaa36,
+        0xaa43, 0xaa43,
+        0xaa4c, 0xaa4c,
+        0xaab0, 0xaab0,
+        0xaab2, 0xaab4,
+        0xaab7, 0xaab8,
+        0xaabe, 0xaabf,
+        0xaac1, 0xaac1,
+        0xabe5, 0xabe5,
+        0xabe8, 0xabe8,
+        0xabed, 0xabed,
+        0xfb1e, 0xfb1e,
+        0xfe00, 0xfe0f,
+        0xfe20, 0xfe26,
+        0x101fd, 0x101fd,
+        0x10a01, 0x10a03,
+        0x10a05, 0x10a06,
+        0x10a0c, 0x10a0f,
+        0x10a38, 0x10a3a,
+        0x10a3f, 0x10a3f,
+        0x11080, 0x11081,
+        0x110b3, 0x110b6,
+        0x110b9, 0x110ba,
+        0x1d167, 0x1d169,
+        0x1d17b, 0x1d182,
+        0x1d185, 0x1d18b,
+        0x1d1aa, 0x1d1ad,
+        0x1d242, 0x1d244,
+        0xe0100, 0xe01ef,
 }; /* CR_Mn */
 
 /* 'N': Major Category */
 static const OnigCodePoint CR_N[] = {
-	81,
-	0x0030, 0x0039,
-	0x00b2, 0x00b3,
-	0x00b9, 0x00b9,
-	0x00bc, 0x00be,
-	0x0660, 0x0669,
-	0x06f0, 0x06f9,
-	0x07c0, 0x07c9,
-	0x0966, 0x096f,
-	0x09e6, 0x09ef,
-	0x09f4, 0x09f9,
-	0x0a66, 0x0a6f,
-	0x0ae6, 0x0aef,
-	0x0b66, 0x0b6f,
-	0x0be6, 0x0bf2,
-	0x0c66, 0x0c6f,
-	0x0c78, 0x0c7e,
-	0x0ce6, 0x0cef,
-	0x0d66, 0x0d75,
-	0x0e50, 0x0e59,
-	0x0ed0, 0x0ed9,
-	0x0f20, 0x0f33,
-	0x1040, 0x1049,
-	0x1090, 0x1099,
-	0x1369, 0x137c,
-	0x16ee, 0x16f0,
-	0x17e0, 0x17e9,
-	0x17f0, 0x17f9,
-	0x1810, 0x1819,
-	0x1946, 0x194f,
-	0x19d0, 0x19da,
-	0x1a80, 0x1a89,
-	0x1a90, 0x1a99,
-	0x1b50, 0x1b59,
-	0x1bb0, 0x1bb9,
-	0x1c40, 0x1c49,
-	0x1c50, 0x1c59,
-	0x2070, 0x2070,
-	0x2074, 0x2079,
-	0x2080, 0x2089,
-	0x2150, 0x2182,
-	0x2185, 0x2189,
-	0x2460, 0x249b,
-	0x24ea, 0x24ff,
-	0x2776, 0x2793,
-	0x2cfd, 0x2cfd,
-	0x3007, 0x3007,
-	0x3021, 0x3029,
-	0x3038, 0x303a,
-	0x3192, 0x3195,
-	0x3220, 0x3229,
-	0x3251, 0x325f,
-	0x3280, 0x3289,
-	0x32b1, 0x32bf,
-	0xa620, 0xa629,
-	0xa6e6, 0xa6ef,
-	0xa830, 0xa835,
-	0xa8d0, 0xa8d9,
-	0xa900, 0xa909,
-	0xa9d0, 0xa9d9,
-	0xaa50, 0xaa59,
-	0xabf0, 0xabf9,
-	0xff10, 0xff19,
-	0x10107, 0x10133,
-	0x10140, 0x10178,
-	0x1018a, 0x1018a,
-	0x10320, 0x10323,
-	0x10341, 0x10341,
-	0x1034a, 0x1034a,
-	0x103d1, 0x103d5,
-	0x104a0, 0x104a9,
-	0x10858, 0x1085f,
-	0x10916, 0x1091b,
-	0x10a40, 0x10a47,
-	0x10a7d, 0x10a7e,
-	0x10b58, 0x10b5f,
-	0x10b78, 0x10b7f,
-	0x10e60, 0x10e7e,
-	0x12400, 0x12462,
-	0x1d360, 0x1d371,
-	0x1d7ce, 0x1d7ff,
-	0x1f100, 0x1f10a,
+        81,
+        0x0030, 0x0039,
+        0x00b2, 0x00b3,
+        0x00b9, 0x00b9,
+        0x00bc, 0x00be,
+        0x0660, 0x0669,
+        0x06f0, 0x06f9,
+        0x07c0, 0x07c9,
+        0x0966, 0x096f,
+        0x09e6, 0x09ef,
+        0x09f4, 0x09f9,
+        0x0a66, 0x0a6f,
+        0x0ae6, 0x0aef,
+        0x0b66, 0x0b6f,
+        0x0be6, 0x0bf2,
+        0x0c66, 0x0c6f,
+        0x0c78, 0x0c7e,
+        0x0ce6, 0x0cef,
+        0x0d66, 0x0d75,
+        0x0e50, 0x0e59,
+        0x0ed0, 0x0ed9,
+        0x0f20, 0x0f33,
+        0x1040, 0x1049,
+        0x1090, 0x1099,
+        0x1369, 0x137c,
+        0x16ee, 0x16f0,
+        0x17e0, 0x17e9,
+        0x17f0, 0x17f9,
+        0x1810, 0x1819,
+        0x1946, 0x194f,
+        0x19d0, 0x19da,
+        0x1a80, 0x1a89,
+        0x1a90, 0x1a99,
+        0x1b50, 0x1b59,
+        0x1bb0, 0x1bb9,
+        0x1c40, 0x1c49,
+        0x1c50, 0x1c59,
+        0x2070, 0x2070,
+        0x2074, 0x2079,
+        0x2080, 0x2089,
+        0x2150, 0x2182,
+        0x2185, 0x2189,
+        0x2460, 0x249b,
+        0x24ea, 0x24ff,
+        0x2776, 0x2793,
+        0x2cfd, 0x2cfd,
+        0x3007, 0x3007,
+        0x3021, 0x3029,
+        0x3038, 0x303a,
+        0x3192, 0x3195,
+        0x3220, 0x3229,
+        0x3251, 0x325f,
+        0x3280, 0x3289,
+        0x32b1, 0x32bf,
+        0xa620, 0xa629,
+        0xa6e6, 0xa6ef,
+        0xa830, 0xa835,
+        0xa8d0, 0xa8d9,
+        0xa900, 0xa909,
+        0xa9d0, 0xa9d9,
+        0xaa50, 0xaa59,
+        0xabf0, 0xabf9,
+        0xff10, 0xff19,
+        0x10107, 0x10133,
+        0x10140, 0x10178,
+        0x1018a, 0x1018a,
+        0x10320, 0x10323,
+        0x10341, 0x10341,
+        0x1034a, 0x1034a,
+        0x103d1, 0x103d5,
+        0x104a0, 0x104a9,
+        0x10858, 0x1085f,
+        0x10916, 0x1091b,
+        0x10a40, 0x10a47,
+        0x10a7d, 0x10a7e,
+        0x10b58, 0x10b5f,
+        0x10b78, 0x10b7f,
+        0x10e60, 0x10e7e,
+        0x12400, 0x12462,
+        0x1d360, 0x1d371,
+        0x1d7ce, 0x1d7ff,
+        0x1f100, 0x1f10a,
 }; /* CR_N */
 
 /* 'Nd': General Category */
 static const OnigCodePoint CR_Nd[] = {
-	37,
-	0x0030, 0x0039,
-	0x0660, 0x0669,
-	0x06f0, 0x06f9,
-	0x07c0, 0x07c9,
-	0x0966, 0x096f,
-	0x09e6, 0x09ef,
-	0x0a66, 0x0a6f,
-	0x0ae6, 0x0aef,
-	0x0b66, 0x0b6f,
-	0x0be6, 0x0bef,
-	0x0c66, 0x0c6f,
-	0x0ce6, 0x0cef,
-	0x0d66, 0x0d6f,
-	0x0e50, 0x0e59,
-	0x0ed0, 0x0ed9,
-	0x0f20, 0x0f29,
-	0x1040, 0x1049,
-	0x1090, 0x1099,
-	0x17e0, 0x17e9,
-	0x1810, 0x1819,
-	0x1946, 0x194f,
-	0x19d0, 0x19da,
-	0x1a80, 0x1a89,
-	0x1a90, 0x1a99,
-	0x1b50, 0x1b59,
-	0x1bb0, 0x1bb9,
-	0x1c40, 0x1c49,
-	0x1c50, 0x1c59,
-	0xa620, 0xa629,
-	0xa8d0, 0xa8d9,
-	0xa900, 0xa909,
-	0xa9d0, 0xa9d9,
-	0xaa50, 0xaa59,
-	0xabf0, 0xabf9,
-	0xff10, 0xff19,
-	0x104a0, 0x104a9,
-	0x1d7ce, 0x1d7ff,
+        37,
+        0x0030, 0x0039,
+        0x0660, 0x0669,
+        0x06f0, 0x06f9,
+        0x07c0, 0x07c9,
+        0x0966, 0x096f,
+        0x09e6, 0x09ef,
+        0x0a66, 0x0a6f,
+        0x0ae6, 0x0aef,
+        0x0b66, 0x0b6f,
+        0x0be6, 0x0bef,
+        0x0c66, 0x0c6f,
+        0x0ce6, 0x0cef,
+        0x0d66, 0x0d6f,
+        0x0e50, 0x0e59,
+        0x0ed0, 0x0ed9,
+        0x0f20, 0x0f29,
+        0x1040, 0x1049,
+        0x1090, 0x1099,
+        0x17e0, 0x17e9,
+        0x1810, 0x1819,
+        0x1946, 0x194f,
+        0x19d0, 0x19da,
+        0x1a80, 0x1a89,
+        0x1a90, 0x1a99,
+        0x1b50, 0x1b59,
+        0x1bb0, 0x1bb9,
+        0x1c40, 0x1c49,
+        0x1c50, 0x1c59,
+        0xa620, 0xa629,
+        0xa8d0, 0xa8d9,
+        0xa900, 0xa909,
+        0xa9d0, 0xa9d9,
+        0xaa50, 0xaa59,
+        0xabf0, 0xabf9,
+        0xff10, 0xff19,
+        0x104a0, 0x104a9,
+        0x1d7ce, 0x1d7ff,
 }; /* CR_Nd */
 
 /* 'Nl': General Category */
 static const OnigCodePoint CR_Nl[] = {
-	12,
-	0x16ee, 0x16f0,
-	0x2160, 0x2182,
-	0x2185, 0x2188,
-	0x3007, 0x3007,
-	0x3021, 0x3029,
-	0x3038, 0x303a,
-	0xa6e6, 0xa6ef,
-	0x10140, 0x10174,
-	0x10341, 0x10341,
-	0x1034a, 0x1034a,
-	0x103d1, 0x103d5,
-	0x12400, 0x12462,
+        12,
+        0x16ee, 0x16f0,
+        0x2160, 0x2182,
+        0x2185, 0x2188,
+        0x3007, 0x3007,
+        0x3021, 0x3029,
+        0x3038, 0x303a,
+        0xa6e6, 0xa6ef,
+        0x10140, 0x10174,
+        0x10341, 0x10341,
+        0x1034a, 0x1034a,
+        0x103d1, 0x103d5,
+        0x12400, 0x12462,
 }; /* CR_Nl */
 
 /* 'No': General Category */
 static const OnigCodePoint CR_No[] = {
-	38,
-	0x00b2, 0x00b3,
-	0x00b9, 0x00b9,
-	0x00bc, 0x00be,
-	0x09f4, 0x09f9,
-	0x0bf0, 0x0bf2,
-	0x0c78, 0x0c7e,
-	0x0d70, 0x0d75,
-	0x0f2a, 0x0f33,
-	0x1369, 0x137c,
-	0x17f0, 0x17f9,
-	0x2070, 0x2070,
-	0x2074, 0x2079,
-	0x2080, 0x2089,
-	0x2150, 0x215f,
-	0x2189, 0x2189,
-	0x2460, 0x249b,
-	0x24ea, 0x24ff,
-	0x2776, 0x2793,
-	0x2cfd, 0x2cfd,
-	0x3192, 0x3195,
-	0x3220, 0x3229,
-	0x3251, 0x325f,
-	0x3280, 0x3289,
-	0x32b1, 0x32bf,
-	0xa830, 0xa835,
-	0x10107, 0x10133,
-	0x10175, 0x10178,
-	0x1018a, 0x1018a,
-	0x10320, 0x10323,
-	0x10858, 0x1085f,
-	0x10916, 0x1091b,
-	0x10a40, 0x10a47,
-	0x10a7d, 0x10a7e,
-	0x10b58, 0x10b5f,
-	0x10b78, 0x10b7f,
-	0x10e60, 0x10e7e,
-	0x1d360, 0x1d371,
-	0x1f100, 0x1f10a,
+        38,
+        0x00b2, 0x00b3,
+        0x00b9, 0x00b9,
+        0x00bc, 0x00be,
+        0x09f4, 0x09f9,
+        0x0bf0, 0x0bf2,
+        0x0c78, 0x0c7e,
+        0x0d70, 0x0d75,
+        0x0f2a, 0x0f33,
+        0x1369, 0x137c,
+        0x17f0, 0x17f9,
+        0x2070, 0x2070,
+        0x2074, 0x2079,
+        0x2080, 0x2089,
+        0x2150, 0x215f,
+        0x2189, 0x2189,
+        0x2460, 0x249b,
+        0x24ea, 0x24ff,
+        0x2776, 0x2793,
+        0x2cfd, 0x2cfd,
+        0x3192, 0x3195,
+        0x3220, 0x3229,
+        0x3251, 0x325f,
+        0x3280, 0x3289,
+        0x32b1, 0x32bf,
+        0xa830, 0xa835,
+        0x10107, 0x10133,
+        0x10175, 0x10178,
+        0x1018a, 0x1018a,
+        0x10320, 0x10323,
+        0x10858, 0x1085f,
+        0x10916, 0x1091b,
+        0x10a40, 0x10a47,
+        0x10a7d, 0x10a7e,
+        0x10b58, 0x10b5f,
+        0x10b78, 0x10b7f,
+        0x10e60, 0x10e7e,
+        0x1d360, 0x1d371,
+        0x1f100, 0x1f10a,
 }; /* CR_No */
 
 /* 'P': Major Category */
 static const OnigCodePoint CR_P[] = {
-	129,
-	0x0021, 0x0023,
-	0x0025, 0x002a,
-	0x002c, 0x002f,
-	0x003a, 0x003b,
-	0x003f, 0x0040,
-	0x005b, 0x005d,
-	0x005f, 0x005f,
-	0x007b, 0x007b,
-	0x007d, 0x007d,
-	0x00a1, 0x00a1,
-	0x00ab, 0x00ab,
-	0x00b7, 0x00b7,
-	0x00bb, 0x00bb,
-	0x00bf, 0x00bf,
-	0x037e, 0x037e,
-	0x0387, 0x0387,
-	0x055a, 0x055f,
-	0x0589, 0x058a,
-	0x05be, 0x05be,
-	0x05c0, 0x05c0,
-	0x05c3, 0x05c3,
-	0x05c6, 0x05c6,
-	0x05f3, 0x05f4,
-	0x0609, 0x060a,
-	0x060c, 0x060d,
-	0x061b, 0x061b,
-	0x061e, 0x061f,
-	0x066a, 0x066d,
-	0x06d4, 0x06d4,
-	0x0700, 0x070d,
-	0x07f7, 0x07f9,
-	0x0830, 0x083e,
-	0x0964, 0x0965,
-	0x0970, 0x0970,
-	0x0df4, 0x0df4,
-	0x0e4f, 0x0e4f,
-	0x0e5a, 0x0e5b,
-	0x0f04, 0x0f12,
-	0x0f3a, 0x0f3d,
-	0x0f85, 0x0f85,
-	0x0fd0, 0x0fd4,
-	0x104a, 0x104f,
-	0x10fb, 0x10fb,
-	0x1361, 0x1368,
-	0x1400, 0x1400,
-	0x166d, 0x166e,
-	0x169b, 0x169c,
-	0x16eb, 0x16ed,
-	0x1735, 0x1736,
-	0x17d4, 0x17d6,
-	0x17d8, 0x17da,
-	0x1800, 0x180a,
-	0x1944, 0x1945,
-	0x19de, 0x19df,
-	0x1a1e, 0x1a1f,
-	0x1aa0, 0x1aa6,
-	0x1aa8, 0x1aad,
-	0x1b5a, 0x1b60,
-	0x1c3b, 0x1c3f,
-	0x1c7e, 0x1c7f,
-	0x1cd3, 0x1cd3,
-	0x2010, 0x2027,
-	0x2030, 0x2043,
-	0x2045, 0x2051,
-	0x2053, 0x205e,
-	0x207d, 0x207e,
-	0x208d, 0x208e,
-	0x2329, 0x232a,
-	0x2768, 0x2775,
-	0x27c5, 0x27c6,
-	0x27e6, 0x27ef,
-	0x2983, 0x2998,
-	0x29d8, 0x29db,
-	0x29fc, 0x29fd,
-	0x2cf9, 0x2cfc,
-	0x2cfe, 0x2cff,
-	0x2e00, 0x2e2e,
-	0x2e30, 0x2e31,
-	0x3001, 0x3003,
-	0x3008, 0x3011,
-	0x3014, 0x301f,
-	0x3030, 0x3030,
-	0x303d, 0x303d,
-	0x30a0, 0x30a0,
-	0x30fb, 0x30fb,
-	0xa4fe, 0xa4ff,
-	0xa60d, 0xa60f,
-	0xa673, 0xa673,
-	0xa67e, 0xa67e,
-	0xa6f2, 0xa6f7,
-	0xa874, 0xa877,
-	0xa8ce, 0xa8cf,
-	0xa8f8, 0xa8fa,
-	0xa92e, 0xa92f,
-	0xa95f, 0xa95f,
-	0xa9c1, 0xa9cd,
-	0xa9de, 0xa9df,
-	0xaa5c, 0xaa5f,
-	0xaade, 0xaadf,
-	0xabeb, 0xabeb,
-	0xfd3e, 0xfd3f,
-	0xfe10, 0xfe19,
-	0xfe30, 0xfe52,
-	0xfe54, 0xfe61,
-	0xfe63, 0xfe63,
-	0xfe68, 0xfe68,
-	0xfe6a, 0xfe6b,
-	0xff01, 0xff03,
-	0xff05, 0xff0a,
-	0xff0c, 0xff0f,
-	0xff1a, 0xff1b,
-	0xff1f, 0xff20,
-	0xff3b, 0xff3d,
-	0xff3f, 0xff3f,
-	0xff5b, 0xff5b,
-	0xff5d, 0xff5d,
-	0xff5f, 0xff65,
-	0x10100, 0x10101,
-	0x1039f, 0x1039f,
-	0x103d0, 0x103d0,
-	0x10857, 0x10857,
-	0x1091f, 0x1091f,
-	0x1093f, 0x1093f,
-	0x10a50, 0x10a58,
-	0x10a7f, 0x10a7f,
-	0x10b39, 0x10b3f,
-	0x110bb, 0x110bc,
-	0x110be, 0x110c1,
-	0x12470, 0x12473,
+        129,
+        0x0021, 0x0023,
+        0x0025, 0x002a,
+        0x002c, 0x002f,
+        0x003a, 0x003b,
+        0x003f, 0x0040,
+        0x005b, 0x005d,
+        0x005f, 0x005f,
+        0x007b, 0x007b,
+        0x007d, 0x007d,
+        0x00a1, 0x00a1,
+        0x00ab, 0x00ab,
+        0x00b7, 0x00b7,
+        0x00bb, 0x00bb,
+        0x00bf, 0x00bf,
+        0x037e, 0x037e,
+        0x0387, 0x0387,
+        0x055a, 0x055f,
+        0x0589, 0x058a,
+        0x05be, 0x05be,
+        0x05c0, 0x05c0,
+        0x05c3, 0x05c3,
+        0x05c6, 0x05c6,
+        0x05f3, 0x05f4,
+        0x0609, 0x060a,
+        0x060c, 0x060d,
+        0x061b, 0x061b,
+        0x061e, 0x061f,
+        0x066a, 0x066d,
+        0x06d4, 0x06d4,
+        0x0700, 0x070d,
+        0x07f7, 0x07f9,
+        0x0830, 0x083e,
+        0x0964, 0x0965,
+        0x0970, 0x0970,
+        0x0df4, 0x0df4,
+        0x0e4f, 0x0e4f,
+        0x0e5a, 0x0e5b,
+        0x0f04, 0x0f12,
+        0x0f3a, 0x0f3d,
+        0x0f85, 0x0f85,
+        0x0fd0, 0x0fd4,
+        0x104a, 0x104f,
+        0x10fb, 0x10fb,
+        0x1361, 0x1368,
+        0x1400, 0x1400,
+        0x166d, 0x166e,
+        0x169b, 0x169c,
+        0x16eb, 0x16ed,
+        0x1735, 0x1736,
+        0x17d4, 0x17d6,
+        0x17d8, 0x17da,
+        0x1800, 0x180a,
+        0x1944, 0x1945,
+        0x19de, 0x19df,
+        0x1a1e, 0x1a1f,
+        0x1aa0, 0x1aa6,
+        0x1aa8, 0x1aad,
+        0x1b5a, 0x1b60,
+        0x1c3b, 0x1c3f,
+        0x1c7e, 0x1c7f,
+        0x1cd3, 0x1cd3,
+        0x2010, 0x2027,
+        0x2030, 0x2043,
+        0x2045, 0x2051,
+        0x2053, 0x205e,
+        0x207d, 0x207e,
+        0x208d, 0x208e,
+        0x2329, 0x232a,
+        0x2768, 0x2775,
+        0x27c5, 0x27c6,
+        0x27e6, 0x27ef,
+        0x2983, 0x2998,
+        0x29d8, 0x29db,
+        0x29fc, 0x29fd,
+        0x2cf9, 0x2cfc,
+        0x2cfe, 0x2cff,
+        0x2e00, 0x2e2e,
+        0x2e30, 0x2e31,
+        0x3001, 0x3003,
+        0x3008, 0x3011,
+        0x3014, 0x301f,
+        0x3030, 0x3030,
+        0x303d, 0x303d,
+        0x30a0, 0x30a0,
+        0x30fb, 0x30fb,
+        0xa4fe, 0xa4ff,
+        0xa60d, 0xa60f,
+        0xa673, 0xa673,
+        0xa67e, 0xa67e,
+        0xa6f2, 0xa6f7,
+        0xa874, 0xa877,
+        0xa8ce, 0xa8cf,
+        0xa8f8, 0xa8fa,
+        0xa92e, 0xa92f,
+        0xa95f, 0xa95f,
+        0xa9c1, 0xa9cd,
+        0xa9de, 0xa9df,
+        0xaa5c, 0xaa5f,
+        0xaade, 0xaadf,
+        0xabeb, 0xabeb,
+        0xfd3e, 0xfd3f,
+        0xfe10, 0xfe19,
+        0xfe30, 0xfe52,
+        0xfe54, 0xfe61,
+        0xfe63, 0xfe63,
+        0xfe68, 0xfe68,
+        0xfe6a, 0xfe6b,
+        0xff01, 0xff03,
+        0xff05, 0xff0a,
+        0xff0c, 0xff0f,
+        0xff1a, 0xff1b,
+        0xff1f, 0xff20,
+        0xff3b, 0xff3d,
+        0xff3f, 0xff3f,
+        0xff5b, 0xff5b,
+        0xff5d, 0xff5d,
+        0xff5f, 0xff65,
+        0x10100, 0x10101,
+        0x1039f, 0x1039f,
+        0x103d0, 0x103d0,
+        0x10857, 0x10857,
+        0x1091f, 0x1091f,
+        0x1093f, 0x1093f,
+        0x10a50, 0x10a58,
+        0x10a7f, 0x10a7f,
+        0x10b39, 0x10b3f,
+        0x110bb, 0x110bc,
+        0x110be, 0x110c1,
+        0x12470, 0x12473,
 }; /* CR_P */
 
 /* 'Pc': General Category */
 static const OnigCodePoint CR_Pc[] = {
-	6,
-	0x005f, 0x005f,
-	0x203f, 0x2040,
-	0x2054, 0x2054,
-	0xfe33, 0xfe34,
-	0xfe4d, 0xfe4f,
-	0xff3f, 0xff3f,
+        6,
+        0x005f, 0x005f,
+        0x203f, 0x2040,
+        0x2054, 0x2054,
+        0xfe33, 0xfe34,
+        0xfe4d, 0xfe4f,
+        0xff3f, 0xff3f,
 }; /* CR_Pc */
 
 /* 'Pd': General Category */
 static const OnigCodePoint CR_Pd[] = {
-	15,
-	0x002d, 0x002d,
-	0x058a, 0x058a,
-	0x05be, 0x05be,
-	0x1400, 0x1400,
-	0x1806, 0x1806,
-	0x2010, 0x2015,
-	0x2e17, 0x2e17,
-	0x2e1a, 0x2e1a,
-	0x301c, 0x301c,
-	0x3030, 0x3030,
-	0x30a0, 0x30a0,
-	0xfe31, 0xfe32,
-	0xfe58, 0xfe58,
-	0xfe63, 0xfe63,
-	0xff0d, 0xff0d,
+        15,
+        0x002d, 0x002d,
+        0x058a, 0x058a,
+        0x05be, 0x05be,
+        0x1400, 0x1400,
+        0x1806, 0x1806,
+        0x2010, 0x2015,
+        0x2e17, 0x2e17,
+        0x2e1a, 0x2e1a,
+        0x301c, 0x301c,
+        0x3030, 0x3030,
+        0x30a0, 0x30a0,
+        0xfe31, 0xfe32,
+        0xfe58, 0xfe58,
+        0xfe63, 0xfe63,
+        0xff0d, 0xff0d,
 }; /* CR_Pd */
 
 /* 'Pe': General Category */
 static const OnigCodePoint CR_Pe[] = {
-	70,
-	0x0029, 0x0029,
-	0x005d, 0x005d,
-	0x007d, 0x007d,
-	0x0f3b, 0x0f3b,
-	0x0f3d, 0x0f3d,
-	0x169c, 0x169c,
-	0x2046, 0x2046,
-	0x207e, 0x207e,
-	0x208e, 0x208e,
-	0x232a, 0x232a,
-	0x2769, 0x2769,
-	0x276b, 0x276b,
-	0x276d, 0x276d,
-	0x276f, 0x276f,
-	0x2771, 0x2771,
-	0x2773, 0x2773,
-	0x2775, 0x2775,
-	0x27c6, 0x27c6,
-	0x27e7, 0x27e7,
-	0x27e9, 0x27e9,
-	0x27eb, 0x27eb,
-	0x27ed, 0x27ed,
-	0x27ef, 0x27ef,
-	0x2984, 0x2984,
-	0x2986, 0x2986,
-	0x2988, 0x2988,
-	0x298a, 0x298a,
-	0x298c, 0x298c,
-	0x298e, 0x298e,
-	0x2990, 0x2990,
-	0x2992, 0x2992,
-	0x2994, 0x2994,
-	0x2996, 0x2996,
-	0x2998, 0x2998,
-	0x29d9, 0x29d9,
-	0x29db, 0x29db,
-	0x29fd, 0x29fd,
-	0x2e23, 0x2e23,
-	0x2e25, 0x2e25,
-	0x2e27, 0x2e27,
-	0x2e29, 0x2e29,
-	0x3009, 0x3009,
-	0x300b, 0x300b,
-	0x300d, 0x300d,
-	0x300f, 0x300f,
-	0x3011, 0x3011,
-	0x3015, 0x3015,
-	0x3017, 0x3017,
-	0x3019, 0x3019,
-	0x301b, 0x301b,
-	0x301e, 0x301f,
-	0xfd3f, 0xfd3f,
-	0xfe18, 0xfe18,
-	0xfe36, 0xfe36,
-	0xfe38, 0xfe38,
-	0xfe3a, 0xfe3a,
-	0xfe3c, 0xfe3c,
-	0xfe3e, 0xfe3e,
-	0xfe40, 0xfe40,
-	0xfe42, 0xfe42,
-	0xfe44, 0xfe44,
-	0xfe48, 0xfe48,
-	0xfe5a, 0xfe5a,
-	0xfe5c, 0xfe5c,
-	0xfe5e, 0xfe5e,
-	0xff09, 0xff09,
-	0xff3d, 0xff3d,
-	0xff5d, 0xff5d,
-	0xff60, 0xff60,
-	0xff63, 0xff63,
+        70,
+        0x0029, 0x0029,
+        0x005d, 0x005d,
+        0x007d, 0x007d,
+        0x0f3b, 0x0f3b,
+        0x0f3d, 0x0f3d,
+        0x169c, 0x169c,
+        0x2046, 0x2046,
+        0x207e, 0x207e,
+        0x208e, 0x208e,
+        0x232a, 0x232a,
+        0x2769, 0x2769,
+        0x276b, 0x276b,
+        0x276d, 0x276d,
+        0x276f, 0x276f,
+        0x2771, 0x2771,
+        0x2773, 0x2773,
+        0x2775, 0x2775,
+        0x27c6, 0x27c6,
+        0x27e7, 0x27e7,
+        0x27e9, 0x27e9,
+        0x27eb, 0x27eb,
+        0x27ed, 0x27ed,
+        0x27ef, 0x27ef,
+        0x2984, 0x2984,
+        0x2986, 0x2986,
+        0x2988, 0x2988,
+        0x298a, 0x298a,
+        0x298c, 0x298c,
+        0x298e, 0x298e,
+        0x2990, 0x2990,
+        0x2992, 0x2992,
+        0x2994, 0x2994,
+        0x2996, 0x2996,
+        0x2998, 0x2998,
+        0x29d9, 0x29d9,
+        0x29db, 0x29db,
+        0x29fd, 0x29fd,
+        0x2e23, 0x2e23,
+        0x2e25, 0x2e25,
+        0x2e27, 0x2e27,
+        0x2e29, 0x2e29,
+        0x3009, 0x3009,
+        0x300b, 0x300b,
+        0x300d, 0x300d,
+        0x300f, 0x300f,
+        0x3011, 0x3011,
+        0x3015, 0x3015,
+        0x3017, 0x3017,
+        0x3019, 0x3019,
+        0x301b, 0x301b,
+        0x301e, 0x301f,
+        0xfd3f, 0xfd3f,
+        0xfe18, 0xfe18,
+        0xfe36, 0xfe36,
+        0xfe38, 0xfe38,
+        0xfe3a, 0xfe3a,
+        0xfe3c, 0xfe3c,
+        0xfe3e, 0xfe3e,
+        0xfe40, 0xfe40,
+        0xfe42, 0xfe42,
+        0xfe44, 0xfe44,
+        0xfe48, 0xfe48,
+        0xfe5a, 0xfe5a,
+        0xfe5c, 0xfe5c,
+        0xfe5e, 0xfe5e,
+        0xff09, 0xff09,
+        0xff3d, 0xff3d,
+        0xff5d, 0xff5d,
+        0xff60, 0xff60,
+        0xff63, 0xff63,
 }; /* CR_Pe */
 
 /* 'Pf': General Category */
 static const OnigCodePoint CR_Pf[] = {
-	10,
-	0x00bb, 0x00bb,
-	0x2019, 0x2019,
-	0x201d, 0x201d,
-	0x203a, 0x203a,
-	0x2e03, 0x2e03,
-	0x2e05, 0x2e05,
-	0x2e0a, 0x2e0a,
-	0x2e0d, 0x2e0d,
-	0x2e1d, 0x2e1d,
-	0x2e21, 0x2e21,
+        10,
+        0x00bb, 0x00bb,
+        0x2019, 0x2019,
+        0x201d, 0x201d,
+        0x203a, 0x203a,
+        0x2e03, 0x2e03,
+        0x2e05, 0x2e05,
+        0x2e0a, 0x2e0a,
+        0x2e0d, 0x2e0d,
+        0x2e1d, 0x2e1d,
+        0x2e21, 0x2e21,
 }; /* CR_Pf */
 
 /* 'Pi': General Category */
 static const OnigCodePoint CR_Pi[] = {
-	11,
-	0x00ab, 0x00ab,
-	0x2018, 0x2018,
-	0x201b, 0x201c,
-	0x201f, 0x201f,
-	0x2039, 0x2039,
-	0x2e02, 0x2e02,
-	0x2e04, 0x2e04,
-	0x2e09, 0x2e09,
-	0x2e0c, 0x2e0c,
-	0x2e1c, 0x2e1c,
-	0x2e20, 0x2e20,
+        11,
+        0x00ab, 0x00ab,
+        0x2018, 0x2018,
+        0x201b, 0x201c,
+        0x201f, 0x201f,
+        0x2039, 0x2039,
+        0x2e02, 0x2e02,
+        0x2e04, 0x2e04,
+        0x2e09, 0x2e09,
+        0x2e0c, 0x2e0c,
+        0x2e1c, 0x2e1c,
+        0x2e20, 0x2e20,
 }; /* CR_Pi */
 
 /* 'Po': General Category */
 static const OnigCodePoint CR_Po[] = {
-	124,
-	0x0021, 0x0023,
-	0x0025, 0x0027,
-	0x002a, 0x002a,
-	0x002c, 0x002c,
-	0x002e, 0x002f,
-	0x003a, 0x003b,
-	0x003f, 0x0040,
-	0x005c, 0x005c,
-	0x00a1, 0x00a1,
-	0x00b7, 0x00b7,
-	0x00bf, 0x00bf,
-	0x037e, 0x037e,
-	0x0387, 0x0387,
-	0x055a, 0x055f,
-	0x0589, 0x0589,
-	0x05c0, 0x05c0,
-	0x05c3, 0x05c3,
-	0x05c6, 0x05c6,
-	0x05f3, 0x05f4,
-	0x0609, 0x060a,
-	0x060c, 0x060d,
-	0x061b, 0x061b,
-	0x061e, 0x061f,
-	0x066a, 0x066d,
-	0x06d4, 0x06d4,
-	0x0700, 0x070d,
-	0x07f7, 0x07f9,
-	0x0830, 0x083e,
-	0x0964, 0x0965,
-	0x0970, 0x0970,
-	0x0df4, 0x0df4,
-	0x0e4f, 0x0e4f,
-	0x0e5a, 0x0e5b,
-	0x0f04, 0x0f12,
-	0x0f85, 0x0f85,
-	0x0fd0, 0x0fd4,
-	0x104a, 0x104f,
-	0x10fb, 0x10fb,
-	0x1361, 0x1368,
-	0x166d, 0x166e,
-	0x16eb, 0x16ed,
-	0x1735, 0x1736,
-	0x17d4, 0x17d6,
-	0x17d8, 0x17da,
-	0x1800, 0x1805,
-	0x1807, 0x180a,
-	0x1944, 0x1945,
-	0x19de, 0x19df,
-	0x1a1e, 0x1a1f,
-	0x1aa0, 0x1aa6,
-	0x1aa8, 0x1aad,
-	0x1b5a, 0x1b60,
-	0x1c3b, 0x1c3f,
-	0x1c7e, 0x1c7f,
-	0x1cd3, 0x1cd3,
-	0x2016, 0x2017,
-	0x2020, 0x2027,
-	0x2030, 0x2038,
-	0x203b, 0x203e,
-	0x2041, 0x2043,
-	0x2047, 0x2051,
-	0x2053, 0x2053,
-	0x2055, 0x205e,
-	0x2cf9, 0x2cfc,
-	0x2cfe, 0x2cff,
-	0x2e00, 0x2e01,
-	0x2e06, 0x2e08,
-	0x2e0b, 0x2e0b,
-	0x2e0e, 0x2e16,
-	0x2e18, 0x2e19,
-	0x2e1b, 0x2e1b,
-	0x2e1e, 0x2e1f,
-	0x2e2a, 0x2e2e,
-	0x2e30, 0x2e31,
-	0x3001, 0x3003,
-	0x303d, 0x303d,
-	0x30fb, 0x30fb,
-	0xa4fe, 0xa4ff,
-	0xa60d, 0xa60f,
-	0xa673, 0xa673,
-	0xa67e, 0xa67e,
-	0xa6f2, 0xa6f7,
-	0xa874, 0xa877,
-	0xa8ce, 0xa8cf,
-	0xa8f8, 0xa8fa,
-	0xa92e, 0xa92f,
-	0xa95f, 0xa95f,
-	0xa9c1, 0xa9cd,
-	0xa9de, 0xa9df,
-	0xaa5c, 0xaa5f,
-	0xaade, 0xaadf,
-	0xabeb, 0xabeb,
-	0xfe10, 0xfe16,
-	0xfe19, 0xfe19,
-	0xfe30, 0xfe30,
-	0xfe45, 0xfe46,
-	0xfe49, 0xfe4c,
-	0xfe50, 0xfe52,
-	0xfe54, 0xfe57,
-	0xfe5f, 0xfe61,
-	0xfe68, 0xfe68,
-	0xfe6a, 0xfe6b,
-	0xff01, 0xff03,
-	0xff05, 0xff07,
-	0xff0a, 0xff0a,
-	0xff0c, 0xff0c,
-	0xff0e, 0xff0f,
-	0xff1a, 0xff1b,
-	0xff1f, 0xff20,
-	0xff3c, 0xff3c,
-	0xff61, 0xff61,
-	0xff64, 0xff65,
-	0x10100, 0x10101,
-	0x1039f, 0x1039f,
-	0x103d0, 0x103d0,
-	0x10857, 0x10857,
-	0x1091f, 0x1091f,
-	0x1093f, 0x1093f,
-	0x10a50, 0x10a58,
-	0x10a7f, 0x10a7f,
-	0x10b39, 0x10b3f,
-	0x110bb, 0x110bc,
-	0x110be, 0x110c1,
-	0x12470, 0x12473,
+        124,
+        0x0021, 0x0023,
+        0x0025, 0x0027,
+        0x002a, 0x002a,
+        0x002c, 0x002c,
+        0x002e, 0x002f,
+        0x003a, 0x003b,
+        0x003f, 0x0040,
+        0x005c, 0x005c,
+        0x00a1, 0x00a1,
+        0x00b7, 0x00b7,
+        0x00bf, 0x00bf,
+        0x037e, 0x037e,
+        0x0387, 0x0387,
+        0x055a, 0x055f,
+        0x0589, 0x0589,
+        0x05c0, 0x05c0,
+        0x05c3, 0x05c3,
+        0x05c6, 0x05c6,
+        0x05f3, 0x05f4,
+        0x0609, 0x060a,
+        0x060c, 0x060d,
+        0x061b, 0x061b,
+        0x061e, 0x061f,
+        0x066a, 0x066d,
+        0x06d4, 0x06d4,
+        0x0700, 0x070d,
+        0x07f7, 0x07f9,
+        0x0830, 0x083e,
+        0x0964, 0x0965,
+        0x0970, 0x0970,
+        0x0df4, 0x0df4,
+        0x0e4f, 0x0e4f,
+        0x0e5a, 0x0e5b,
+        0x0f04, 0x0f12,
+        0x0f85, 0x0f85,
+        0x0fd0, 0x0fd4,
+        0x104a, 0x104f,
+        0x10fb, 0x10fb,
+        0x1361, 0x1368,
+        0x166d, 0x166e,
+        0x16eb, 0x16ed,
+        0x1735, 0x1736,
+        0x17d4, 0x17d6,
+        0x17d8, 0x17da,
+        0x1800, 0x1805,
+        0x1807, 0x180a,
+        0x1944, 0x1945,
+        0x19de, 0x19df,
+        0x1a1e, 0x1a1f,
+        0x1aa0, 0x1aa6,
+        0x1aa8, 0x1aad,
+        0x1b5a, 0x1b60,
+        0x1c3b, 0x1c3f,
+        0x1c7e, 0x1c7f,
+        0x1cd3, 0x1cd3,
+        0x2016, 0x2017,
+        0x2020, 0x2027,
+        0x2030, 0x2038,
+        0x203b, 0x203e,
+        0x2041, 0x2043,
+        0x2047, 0x2051,
+        0x2053, 0x2053,
+        0x2055, 0x205e,
+        0x2cf9, 0x2cfc,
+        0x2cfe, 0x2cff,
+        0x2e00, 0x2e01,
+        0x2e06, 0x2e08,
+        0x2e0b, 0x2e0b,
+        0x2e0e, 0x2e16,
+        0x2e18, 0x2e19,
+        0x2e1b, 0x2e1b,
+        0x2e1e, 0x2e1f,
+        0x2e2a, 0x2e2e,
+        0x2e30, 0x2e31,
+        0x3001, 0x3003,
+        0x303d, 0x303d,
+        0x30fb, 0x30fb,
+        0xa4fe, 0xa4ff,
+        0xa60d, 0xa60f,
+        0xa673, 0xa673,
+        0xa67e, 0xa67e,
+        0xa6f2, 0xa6f7,
+        0xa874, 0xa877,
+        0xa8ce, 0xa8cf,
+        0xa8f8, 0xa8fa,
+        0xa92e, 0xa92f,
+        0xa95f, 0xa95f,
+        0xa9c1, 0xa9cd,
+        0xa9de, 0xa9df,
+        0xaa5c, 0xaa5f,
+        0xaade, 0xaadf,
+        0xabeb, 0xabeb,
+        0xfe10, 0xfe16,
+        0xfe19, 0xfe19,
+        0xfe30, 0xfe30,
+        0xfe45, 0xfe46,
+        0xfe49, 0xfe4c,
+        0xfe50, 0xfe52,
+        0xfe54, 0xfe57,
+        0xfe5f, 0xfe61,
+        0xfe68, 0xfe68,
+        0xfe6a, 0xfe6b,
+        0xff01, 0xff03,
+        0xff05, 0xff07,
+        0xff0a, 0xff0a,
+        0xff0c, 0xff0c,
+        0xff0e, 0xff0f,
+        0xff1a, 0xff1b,
+        0xff1f, 0xff20,
+        0xff3c, 0xff3c,
+        0xff61, 0xff61,
+        0xff64, 0xff65,
+        0x10100, 0x10101,
+        0x1039f, 0x1039f,
+        0x103d0, 0x103d0,
+        0x10857, 0x10857,
+        0x1091f, 0x1091f,
+        0x1093f, 0x1093f,
+        0x10a50, 0x10a58,
+        0x10a7f, 0x10a7f,
+        0x10b39, 0x10b3f,
+        0x110bb, 0x110bc,
+        0x110be, 0x110c1,
+        0x12470, 0x12473,
 }; /* CR_Po */
 
 /* 'Ps': General Category */
 static const OnigCodePoint CR_Ps[] = {
-	72,
-	0x0028, 0x0028,
-	0x005b, 0x005b,
-	0x007b, 0x007b,
-	0x0f3a, 0x0f3a,
-	0x0f3c, 0x0f3c,
-	0x169b, 0x169b,
-	0x201a, 0x201a,
-	0x201e, 0x201e,
-	0x2045, 0x2045,
-	0x207d, 0x207d,
-	0x208d, 0x208d,
-	0x2329, 0x2329,
-	0x2768, 0x2768,
-	0x276a, 0x276a,
-	0x276c, 0x276c,
-	0x276e, 0x276e,
-	0x2770, 0x2770,
-	0x2772, 0x2772,
-	0x2774, 0x2774,
-	0x27c5, 0x27c5,
-	0x27e6, 0x27e6,
-	0x27e8, 0x27e8,
-	0x27ea, 0x27ea,
-	0x27ec, 0x27ec,
-	0x27ee, 0x27ee,
-	0x2983, 0x2983,
-	0x2985, 0x2985,
-	0x2987, 0x2987,
-	0x2989, 0x2989,
-	0x298b, 0x298b,
-	0x298d, 0x298d,
-	0x298f, 0x298f,
-	0x2991, 0x2991,
-	0x2993, 0x2993,
-	0x2995, 0x2995,
-	0x2997, 0x2997,
-	0x29d8, 0x29d8,
-	0x29da, 0x29da,
-	0x29fc, 0x29fc,
-	0x2e22, 0x2e22,
-	0x2e24, 0x2e24,
-	0x2e26, 0x2e26,
-	0x2e28, 0x2e28,
-	0x3008, 0x3008,
-	0x300a, 0x300a,
-	0x300c, 0x300c,
-	0x300e, 0x300e,
-	0x3010, 0x3010,
-	0x3014, 0x3014,
-	0x3016, 0x3016,
-	0x3018, 0x3018,
-	0x301a, 0x301a,
-	0x301d, 0x301d,
-	0xfd3e, 0xfd3e,
-	0xfe17, 0xfe17,
-	0xfe35, 0xfe35,
-	0xfe37, 0xfe37,
-	0xfe39, 0xfe39,
-	0xfe3b, 0xfe3b,
-	0xfe3d, 0xfe3d,
-	0xfe3f, 0xfe3f,
-	0xfe41, 0xfe41,
-	0xfe43, 0xfe43,
-	0xfe47, 0xfe47,
-	0xfe59, 0xfe59,
-	0xfe5b, 0xfe5b,
-	0xfe5d, 0xfe5d,
-	0xff08, 0xff08,
-	0xff3b, 0xff3b,
-	0xff5b, 0xff5b,
-	0xff5f, 0xff5f,
-	0xff62, 0xff62,
+        72,
+        0x0028, 0x0028,
+        0x005b, 0x005b,
+        0x007b, 0x007b,
+        0x0f3a, 0x0f3a,
+        0x0f3c, 0x0f3c,
+        0x169b, 0x169b,
+        0x201a, 0x201a,
+        0x201e, 0x201e,
+        0x2045, 0x2045,
+        0x207d, 0x207d,
+        0x208d, 0x208d,
+        0x2329, 0x2329,
+        0x2768, 0x2768,
+        0x276a, 0x276a,
+        0x276c, 0x276c,
+        0x276e, 0x276e,
+        0x2770, 0x2770,
+        0x2772, 0x2772,
+        0x2774, 0x2774,
+        0x27c5, 0x27c5,
+        0x27e6, 0x27e6,
+        0x27e8, 0x27e8,
+        0x27ea, 0x27ea,
+        0x27ec, 0x27ec,
+        0x27ee, 0x27ee,
+        0x2983, 0x2983,
+        0x2985, 0x2985,
+        0x2987, 0x2987,
+        0x2989, 0x2989,
+        0x298b, 0x298b,
+        0x298d, 0x298d,
+        0x298f, 0x298f,
+        0x2991, 0x2991,
+        0x2993, 0x2993,
+        0x2995, 0x2995,
+        0x2997, 0x2997,
+        0x29d8, 0x29d8,
+        0x29da, 0x29da,
+        0x29fc, 0x29fc,
+        0x2e22, 0x2e22,
+        0x2e24, 0x2e24,
+        0x2e26, 0x2e26,
+        0x2e28, 0x2e28,
+        0x3008, 0x3008,
+        0x300a, 0x300a,
+        0x300c, 0x300c,
+        0x300e, 0x300e,
+        0x3010, 0x3010,
+        0x3014, 0x3014,
+        0x3016, 0x3016,
+        0x3018, 0x3018,
+        0x301a, 0x301a,
+        0x301d, 0x301d,
+        0xfd3e, 0xfd3e,
+        0xfe17, 0xfe17,
+        0xfe35, 0xfe35,
+        0xfe37, 0xfe37,
+        0xfe39, 0xfe39,
+        0xfe3b, 0xfe3b,
+        0xfe3d, 0xfe3d,
+        0xfe3f, 0xfe3f,
+        0xfe41, 0xfe41,
+        0xfe43, 0xfe43,
+        0xfe47, 0xfe47,
+        0xfe59, 0xfe59,
+        0xfe5b, 0xfe5b,
+        0xfe5d, 0xfe5d,
+        0xff08, 0xff08,
+        0xff3b, 0xff3b,
+        0xff5b, 0xff5b,
+        0xff5f, 0xff5f,
+        0xff62, 0xff62,
 }; /* CR_Ps */
 
 /* 'S': Major Category */
 static const OnigCodePoint CR_S[] = {
-	198,
-	0x0024, 0x0024,
-	0x002b, 0x002b,
-	0x003c, 0x003e,
-	0x005e, 0x005e,
-	0x0060, 0x0060,
-	0x007c, 0x007c,
-	0x007e, 0x007e,
-	0x00a2, 0x00a9,
-	0x00ac, 0x00ac,
-	0x00ae, 0x00b1,
-	0x00b4, 0x00b4,
-	0x00b6, 0x00b6,
-	0x00b8, 0x00b8,
-	0x00d7, 0x00d7,
-	0x00f7, 0x00f7,
-	0x02c2, 0x02c5,
-	0x02d2, 0x02df,
-	0x02e5, 0x02eb,
-	0x02ed, 0x02ed,
-	0x02ef, 0x02ff,
-	0x0375, 0x0375,
-	0x0384, 0x0385,
-	0x03f6, 0x03f6,
-	0x0482, 0x0482,
-	0x0606, 0x0608,
-	0x060b, 0x060b,
-	0x060e, 0x060f,
-	0x06e9, 0x06e9,
-	0x06fd, 0x06fe,
-	0x07f6, 0x07f6,
-	0x09f2, 0x09f3,
-	0x09fa, 0x09fb,
-	0x0af1, 0x0af1,
-	0x0b70, 0x0b70,
-	0x0bf3, 0x0bfa,
-	0x0c7f, 0x0c7f,
-	0x0cf1, 0x0cf2,
-	0x0d79, 0x0d79,
-	0x0e3f, 0x0e3f,
-	0x0f01, 0x0f03,
-	0x0f13, 0x0f17,
-	0x0f1a, 0x0f1f,
-	0x0f34, 0x0f34,
-	0x0f36, 0x0f36,
-	0x0f38, 0x0f38,
-	0x0fbe, 0x0fc5,
-	0x0fc7, 0x0fcc,
-	0x0fce, 0x0fcf,
-	0x0fd5, 0x0fd8,
-	0x109e, 0x109f,
-	0x1360, 0x1360,
-	0x1390, 0x1399,
-	0x17db, 0x17db,
-	0x1940, 0x1940,
-	0x19e0, 0x19ff,
-	0x1b61, 0x1b6a,
-	0x1b74, 0x1b7c,
-	0x1fbd, 0x1fbd,
-	0x1fbf, 0x1fc1,
-	0x1fcd, 0x1fcf,
-	0x1fdd, 0x1fdf,
-	0x1fed, 0x1fef,
-	0x1ffd, 0x1ffe,
-	0x2044, 0x2044,
-	0x2052, 0x2052,
-	0x207a, 0x207c,
-	0x208a, 0x208c,
-	0x20a0, 0x20b8,
-	0x2100, 0x2101,
-	0x2103, 0x2106,
-	0x2108, 0x2109,
-	0x2114, 0x2114,
-	0x2116, 0x2118,
-	0x211e, 0x2123,
-	0x2125, 0x2125,
-	0x2127, 0x2127,
-	0x2129, 0x2129,
-	0x212e, 0x212e,
-	0x213a, 0x213b,
-	0x2140, 0x2144,
-	0x214a, 0x214d,
-	0x214f, 0x214f,
-	0x2190, 0x2328,
-	0x232b, 0x23e8,
-	0x2400, 0x2426,
-	0x2440, 0x244a,
-	0x249c, 0x24e9,
-	0x2500, 0x26cd,
-	0x26cf, 0x26e1,
-	0x26e3, 0x26e3,
-	0x26e8, 0x26ff,
-	0x2701, 0x2704,
-	0x2706, 0x2709,
-	0x270c, 0x2727,
-	0x2729, 0x274b,
-	0x274d, 0x274d,
-	0x274f, 0x2752,
-	0x2756, 0x275e,
-	0x2761, 0x2767,
-	0x2794, 0x2794,
-	0x2798, 0x27af,
-	0x27b1, 0x27be,
-	0x27c0, 0x27c4,
-	0x27c7, 0x27ca,
-	0x27cc, 0x27cc,
-	0x27d0, 0x27e5,
-	0x27f0, 0x2982,
-	0x2999, 0x29d7,
-	0x29dc, 0x29fb,
-	0x29fe, 0x2b4c,
-	0x2b50, 0x2b59,
-	0x2ce5, 0x2cea,
-	0x2e80, 0x2e99,
-	0x2e9b, 0x2ef3,
-	0x2f00, 0x2fd5,
-	0x2ff0, 0x2ffb,
-	0x3004, 0x3004,
-	0x3012, 0x3013,
-	0x3020, 0x3020,
-	0x3036, 0x3037,
-	0x303e, 0x303f,
-	0x309b, 0x309c,
-	0x3190, 0x3191,
-	0x3196, 0x319f,
-	0x31c0, 0x31e3,
-	0x3200, 0x321e,
-	0x322a, 0x3250,
-	0x3260, 0x327f,
-	0x328a, 0x32b0,
-	0x32c0, 0x32fe,
-	0x3300, 0x33ff,
-	0x4dc0, 0x4dff,
-	0xa490, 0xa4c6,
-	0xa700, 0xa716,
-	0xa720, 0xa721,
-	0xa789, 0xa78a,
-	0xa828, 0xa82b,
-	0xa836, 0xa839,
-	0xaa77, 0xaa79,
-	0xfb29, 0xfb29,
-	0xfdfc, 0xfdfd,
-	0xfe62, 0xfe62,
-	0xfe64, 0xfe66,
-	0xfe69, 0xfe69,
-	0xff04, 0xff04,
-	0xff0b, 0xff0b,
-	0xff1c, 0xff1e,
-	0xff3e, 0xff3e,
-	0xff40, 0xff40,
-	0xff5c, 0xff5c,
-	0xff5e, 0xff5e,
-	0xffe0, 0xffe6,
-	0xffe8, 0xffee,
-	0xfffc, 0xfffd,
-	0x10102, 0x10102,
-	0x10137, 0x1013f,
-	0x10179, 0x10189,
-	0x10190, 0x1019b,
-	0x101d0, 0x101fc,
-	0x1d000, 0x1d0f5,
-	0x1d100, 0x1d126,
-	0x1d129, 0x1d164,
-	0x1d16a, 0x1d16c,
-	0x1d183, 0x1d184,
-	0x1d18c, 0x1d1a9,
-	0x1d1ae, 0x1d1dd,
-	0x1d200, 0x1d241,
-	0x1d245, 0x1d245,
-	0x1d300, 0x1d356,
-	0x1d6c1, 0x1d6c1,
-	0x1d6db, 0x1d6db,
-	0x1d6fb, 0x1d6fb,
-	0x1d715, 0x1d715,
-	0x1d735, 0x1d735,
-	0x1d74f, 0x1d74f,
-	0x1d76f, 0x1d76f,
-	0x1d789, 0x1d789,
-	0x1d7a9, 0x1d7a9,
-	0x1d7c3, 0x1d7c3,
-	0x1f000, 0x1f02b,
-	0x1f030, 0x1f093,
-	0x1f110, 0x1f12e,
-	0x1f131, 0x1f131,
-	0x1f13d, 0x1f13d,
-	0x1f13f, 0x1f13f,
-	0x1f142, 0x1f142,
-	0x1f146, 0x1f146,
-	0x1f14a, 0x1f14e,
-	0x1f157, 0x1f157,
-	0x1f15f, 0x1f15f,
-	0x1f179, 0x1f179,
-	0x1f17b, 0x1f17c,
-	0x1f17f, 0x1f17f,
-	0x1f18a, 0x1f18d,
-	0x1f190, 0x1f190,
-	0x1f200, 0x1f200,
-	0x1f210, 0x1f231,
-	0x1f240, 0x1f248,
+        198,
+        0x0024, 0x0024,
+        0x002b, 0x002b,
+        0x003c, 0x003e,
+        0x005e, 0x005e,
+        0x0060, 0x0060,
+        0x007c, 0x007c,
+        0x007e, 0x007e,
+        0x00a2, 0x00a9,
+        0x00ac, 0x00ac,
+        0x00ae, 0x00b1,
+        0x00b4, 0x00b4,
+        0x00b6, 0x00b6,
+        0x00b8, 0x00b8,
+        0x00d7, 0x00d7,
+        0x00f7, 0x00f7,
+        0x02c2, 0x02c5,
+        0x02d2, 0x02df,
+        0x02e5, 0x02eb,
+        0x02ed, 0x02ed,
+        0x02ef, 0x02ff,
+        0x0375, 0x0375,
+        0x0384, 0x0385,
+        0x03f6, 0x03f6,
+        0x0482, 0x0482,
+        0x0606, 0x0608,
+        0x060b, 0x060b,
+        0x060e, 0x060f,
+        0x06e9, 0x06e9,
+        0x06fd, 0x06fe,
+        0x07f6, 0x07f6,
+        0x09f2, 0x09f3,
+        0x09fa, 0x09fb,
+        0x0af1, 0x0af1,
+        0x0b70, 0x0b70,
+        0x0bf3, 0x0bfa,
+        0x0c7f, 0x0c7f,
+        0x0cf1, 0x0cf2,
+        0x0d79, 0x0d79,
+        0x0e3f, 0x0e3f,
+        0x0f01, 0x0f03,
+        0x0f13, 0x0f17,
+        0x0f1a, 0x0f1f,
+        0x0f34, 0x0f34,
+        0x0f36, 0x0f36,
+        0x0f38, 0x0f38,
+        0x0fbe, 0x0fc5,
+        0x0fc7, 0x0fcc,
+        0x0fce, 0x0fcf,
+        0x0fd5, 0x0fd8,
+        0x109e, 0x109f,
+        0x1360, 0x1360,
+        0x1390, 0x1399,
+        0x17db, 0x17db,
+        0x1940, 0x1940,
+        0x19e0, 0x19ff,
+        0x1b61, 0x1b6a,
+        0x1b74, 0x1b7c,
+        0x1fbd, 0x1fbd,
+        0x1fbf, 0x1fc1,
+        0x1fcd, 0x1fcf,
+        0x1fdd, 0x1fdf,
+        0x1fed, 0x1fef,
+        0x1ffd, 0x1ffe,
+        0x2044, 0x2044,
+        0x2052, 0x2052,
+        0x207a, 0x207c,
+        0x208a, 0x208c,
+        0x20a0, 0x20b8,
+        0x2100, 0x2101,
+        0x2103, 0x2106,
+        0x2108, 0x2109,
+        0x2114, 0x2114,
+        0x2116, 0x2118,
+        0x211e, 0x2123,
+        0x2125, 0x2125,
+        0x2127, 0x2127,
+        0x2129, 0x2129,
+        0x212e, 0x212e,
+        0x213a, 0x213b,
+        0x2140, 0x2144,
+        0x214a, 0x214d,
+        0x214f, 0x214f,
+        0x2190, 0x2328,
+        0x232b, 0x23e8,
+        0x2400, 0x2426,
+        0x2440, 0x244a,
+        0x249c, 0x24e9,
+        0x2500, 0x26cd,
+        0x26cf, 0x26e1,
+        0x26e3, 0x26e3,
+        0x26e8, 0x26ff,
+        0x2701, 0x2704,
+        0x2706, 0x2709,
+        0x270c, 0x2727,
+        0x2729, 0x274b,
+        0x274d, 0x274d,
+        0x274f, 0x2752,
+        0x2756, 0x275e,
+        0x2761, 0x2767,
+        0x2794, 0x2794,
+        0x2798, 0x27af,
+        0x27b1, 0x27be,
+        0x27c0, 0x27c4,
+        0x27c7, 0x27ca,
+        0x27cc, 0x27cc,
+        0x27d0, 0x27e5,
+        0x27f0, 0x2982,
+        0x2999, 0x29d7,
+        0x29dc, 0x29fb,
+        0x29fe, 0x2b4c,
+        0x2b50, 0x2b59,
+        0x2ce5, 0x2cea,
+        0x2e80, 0x2e99,
+        0x2e9b, 0x2ef3,
+        0x2f00, 0x2fd5,
+        0x2ff0, 0x2ffb,
+        0x3004, 0x3004,
+        0x3012, 0x3013,
+        0x3020, 0x3020,
+        0x3036, 0x3037,
+        0x303e, 0x303f,
+        0x309b, 0x309c,
+        0x3190, 0x3191,
+        0x3196, 0x319f,
+        0x31c0, 0x31e3,
+        0x3200, 0x321e,
+        0x322a, 0x3250,
+        0x3260, 0x327f,
+        0x328a, 0x32b0,
+        0x32c0, 0x32fe,
+        0x3300, 0x33ff,
+        0x4dc0, 0x4dff,
+        0xa490, 0xa4c6,
+        0xa700, 0xa716,
+        0xa720, 0xa721,
+        0xa789, 0xa78a,
+        0xa828, 0xa82b,
+        0xa836, 0xa839,
+        0xaa77, 0xaa79,
+        0xfb29, 0xfb29,
+        0xfdfc, 0xfdfd,
+        0xfe62, 0xfe62,
+        0xfe64, 0xfe66,
+        0xfe69, 0xfe69,
+        0xff04, 0xff04,
+        0xff0b, 0xff0b,
+        0xff1c, 0xff1e,
+        0xff3e, 0xff3e,
+        0xff40, 0xff40,
+        0xff5c, 0xff5c,
+        0xff5e, 0xff5e,
+        0xffe0, 0xffe6,
+        0xffe8, 0xffee,
+        0xfffc, 0xfffd,
+        0x10102, 0x10102,
+        0x10137, 0x1013f,
+        0x10179, 0x10189,
+        0x10190, 0x1019b,
+        0x101d0, 0x101fc,
+        0x1d000, 0x1d0f5,
+        0x1d100, 0x1d126,
+        0x1d129, 0x1d164,
+        0x1d16a, 0x1d16c,
+        0x1d183, 0x1d184,
+        0x1d18c, 0x1d1a9,
+        0x1d1ae, 0x1d1dd,
+        0x1d200, 0x1d241,
+        0x1d245, 0x1d245,
+        0x1d300, 0x1d356,
+        0x1d6c1, 0x1d6c1,
+        0x1d6db, 0x1d6db,
+        0x1d6fb, 0x1d6fb,
+        0x1d715, 0x1d715,
+        0x1d735, 0x1d735,
+        0x1d74f, 0x1d74f,
+        0x1d76f, 0x1d76f,
+        0x1d789, 0x1d789,
+        0x1d7a9, 0x1d7a9,
+        0x1d7c3, 0x1d7c3,
+        0x1f000, 0x1f02b,
+        0x1f030, 0x1f093,
+        0x1f110, 0x1f12e,
+        0x1f131, 0x1f131,
+        0x1f13d, 0x1f13d,
+        0x1f13f, 0x1f13f,
+        0x1f142, 0x1f142,
+        0x1f146, 0x1f146,
+        0x1f14a, 0x1f14e,
+        0x1f157, 0x1f157,
+        0x1f15f, 0x1f15f,
+        0x1f179, 0x1f179,
+        0x1f17b, 0x1f17c,
+        0x1f17f, 0x1f17f,
+        0x1f18a, 0x1f18d,
+        0x1f190, 0x1f190,
+        0x1f200, 0x1f200,
+        0x1f210, 0x1f231,
+        0x1f240, 0x1f248,
 }; /* CR_S */
 
 /* 'Sc': General Category */
 static const OnigCodePoint CR_Sc[] = {
-	16,
-	0x0024, 0x0024,
-	0x00a2, 0x00a5,
-	0x060b, 0x060b,
-	0x09f2, 0x09f3,
-	0x09fb, 0x09fb,
-	0x0af1, 0x0af1,
-	0x0bf9, 0x0bf9,
-	0x0e3f, 0x0e3f,
-	0x17db, 0x17db,
-	0x20a0, 0x20b8,
-	0xa838, 0xa838,
-	0xfdfc, 0xfdfc,
-	0xfe69, 0xfe69,
-	0xff04, 0xff04,
-	0xffe0, 0xffe1,
-	0xffe5, 0xffe6,
+        16,
+        0x0024, 0x0024,
+        0x00a2, 0x00a5,
+        0x060b, 0x060b,
+        0x09f2, 0x09f3,
+        0x09fb, 0x09fb,
+        0x0af1, 0x0af1,
+        0x0bf9, 0x0bf9,
+        0x0e3f, 0x0e3f,
+        0x17db, 0x17db,
+        0x20a0, 0x20b8,
+        0xa838, 0xa838,
+        0xfdfc, 0xfdfc,
+        0xfe69, 0xfe69,
+        0xff04, 0xff04,
+        0xffe0, 0xffe1,
+        0xffe5, 0xffe6,
 }; /* CR_Sc */
 
 /* 'Sk': General Category */
 static const OnigCodePoint CR_Sk[] = {
-	26,
-	0x005e, 0x005e,
-	0x0060, 0x0060,
-	0x00a8, 0x00a8,
-	0x00af, 0x00af,
-	0x00b4, 0x00b4,
-	0x00b8, 0x00b8,
-	0x02c2, 0x02c5,
-	0x02d2, 0x02df,
-	0x02e5, 0x02eb,
-	0x02ed, 0x02ed,
-	0x02ef, 0x02ff,
-	0x0375, 0x0375,
-	0x0384, 0x0385,
-	0x1fbd, 0x1fbd,
-	0x1fbf, 0x1fc1,
-	0x1fcd, 0x1fcf,
-	0x1fdd, 0x1fdf,
-	0x1fed, 0x1fef,
-	0x1ffd, 0x1ffe,
-	0x309b, 0x309c,
-	0xa700, 0xa716,
-	0xa720, 0xa721,
-	0xa789, 0xa78a,
-	0xff3e, 0xff3e,
-	0xff40, 0xff40,
-	0xffe3, 0xffe3,
+        26,
+        0x005e, 0x005e,
+        0x0060, 0x0060,
+        0x00a8, 0x00a8,
+        0x00af, 0x00af,
+        0x00b4, 0x00b4,
+        0x00b8, 0x00b8,
+        0x02c2, 0x02c5,
+        0x02d2, 0x02df,
+        0x02e5, 0x02eb,
+        0x02ed, 0x02ed,
+        0x02ef, 0x02ff,
+        0x0375, 0x0375,
+        0x0384, 0x0385,
+        0x1fbd, 0x1fbd,
+        0x1fbf, 0x1fc1,
+        0x1fcd, 0x1fcf,
+        0x1fdd, 0x1fdf,
+        0x1fed, 0x1fef,
+        0x1ffd, 0x1ffe,
+        0x309b, 0x309c,
+        0xa700, 0xa716,
+        0xa720, 0xa721,
+        0xa789, 0xa78a,
+        0xff3e, 0xff3e,
+        0xff40, 0xff40,
+        0xffe3, 0xffe3,
 }; /* CR_Sk */
 
 /* 'Sm': General Category */
 static const OnigCodePoint CR_Sm[] = {
-	65,
-	0x002b, 0x002b,
-	0x003c, 0x003e,
-	0x007c, 0x007c,
-	0x007e, 0x007e,
-	0x00ac, 0x00ac,
-	0x00b1, 0x00b1,
-	0x00d7, 0x00d7,
-	0x00f7, 0x00f7,
-	0x03f6, 0x03f6,
-	0x0606, 0x0608,
-	0x2044, 0x2044,
-	0x2052, 0x2052,
-	0x207a, 0x207c,
-	0x208a, 0x208c,
-	0x2140, 0x2144,
-	0x214b, 0x214b,
-	0x2190, 0x2194,
-	0x219a, 0x219b,
-	0x21a0, 0x21a0,
-	0x21a3, 0x21a3,
-	0x21a6, 0x21a6,
-	0x21ae, 0x21ae,
-	0x21ce, 0x21cf,
-	0x21d2, 0x21d2,
-	0x21d4, 0x21d4,
-	0x21f4, 0x22ff,
-	0x2308, 0x230b,
-	0x2320, 0x2321,
-	0x237c, 0x237c,
-	0x239b, 0x23b3,
-	0x23dc, 0x23e1,
-	0x25b7, 0x25b7,
-	0x25c1, 0x25c1,
-	0x25f8, 0x25ff,
-	0x266f, 0x266f,
-	0x27c0, 0x27c4,
-	0x27c7, 0x27ca,
-	0x27cc, 0x27cc,
-	0x27d0, 0x27e5,
-	0x27f0, 0x27ff,
-	0x2900, 0x2982,
-	0x2999, 0x29d7,
-	0x29dc, 0x29fb,
-	0x29fe, 0x2aff,
-	0x2b30, 0x2b44,
-	0x2b47, 0x2b4c,
-	0xfb29, 0xfb29,
-	0xfe62, 0xfe62,
-	0xfe64, 0xfe66,
-	0xff0b, 0xff0b,
-	0xff1c, 0xff1e,
-	0xff5c, 0xff5c,
-	0xff5e, 0xff5e,
-	0xffe2, 0xffe2,
-	0xffe9, 0xffec,
-	0x1d6c1, 0x1d6c1,
-	0x1d6db, 0x1d6db,
-	0x1d6fb, 0x1d6fb,
-	0x1d715, 0x1d715,
-	0x1d735, 0x1d735,
-	0x1d74f, 0x1d74f,
-	0x1d76f, 0x1d76f,
-	0x1d789, 0x1d789,
-	0x1d7a9, 0x1d7a9,
-	0x1d7c3, 0x1d7c3,
+        65,
+        0x002b, 0x002b,
+        0x003c, 0x003e,
+        0x007c, 0x007c,
+        0x007e, 0x007e,
+        0x00ac, 0x00ac,
+        0x00b1, 0x00b1,
+        0x00d7, 0x00d7,
+        0x00f7, 0x00f7,
+        0x03f6, 0x03f6,
+        0x0606, 0x0608,
+        0x2044, 0x2044,
+        0x2052, 0x2052,
+        0x207a, 0x207c,
+        0x208a, 0x208c,
+        0x2140, 0x2144,
+        0x214b, 0x214b,
+        0x2190, 0x2194,
+        0x219a, 0x219b,
+        0x21a0, 0x21a0,
+        0x21a3, 0x21a3,
+        0x21a6, 0x21a6,
+        0x21ae, 0x21ae,
+        0x21ce, 0x21cf,
+        0x21d2, 0x21d2,
+        0x21d4, 0x21d4,
+        0x21f4, 0x22ff,
+        0x2308, 0x230b,
+        0x2320, 0x2321,
+        0x237c, 0x237c,
+        0x239b, 0x23b3,
+        0x23dc, 0x23e1,
+        0x25b7, 0x25b7,
+        0x25c1, 0x25c1,
+        0x25f8, 0x25ff,
+        0x266f, 0x266f,
+        0x27c0, 0x27c4,
+        0x27c7, 0x27ca,
+        0x27cc, 0x27cc,
+        0x27d0, 0x27e5,
+        0x27f0, 0x27ff,
+        0x2900, 0x2982,
+        0x2999, 0x29d7,
+        0x29dc, 0x29fb,
+        0x29fe, 0x2aff,
+        0x2b30, 0x2b44,
+        0x2b47, 0x2b4c,
+        0xfb29, 0xfb29,
+        0xfe62, 0xfe62,
+        0xfe64, 0xfe66,
+        0xff0b, 0xff0b,
+        0xff1c, 0xff1e,
+        0xff5c, 0xff5c,
+        0xff5e, 0xff5e,
+        0xffe2, 0xffe2,
+        0xffe9, 0xffec,
+        0x1d6c1, 0x1d6c1,
+        0x1d6db, 0x1d6db,
+        0x1d6fb, 0x1d6fb,
+        0x1d715, 0x1d715,
+        0x1d735, 0x1d735,
+        0x1d74f, 0x1d74f,
+        0x1d76f, 0x1d76f,
+        0x1d789, 0x1d789,
+        0x1d7a9, 0x1d7a9,
+        0x1d7c3, 0x1d7c3,
 }; /* CR_Sm */
 
 /* 'So': General Category */
 static const OnigCodePoint CR_So[] = {
-	154,
-	0x00a6, 0x00a7,
-	0x00a9, 0x00a9,
-	0x00ae, 0x00ae,
-	0x00b0, 0x00b0,
-	0x00b6, 0x00b6,
-	0x0482, 0x0482,
-	0x060e, 0x060f,
-	0x06e9, 0x06e9,
-	0x06fd, 0x06fe,
-	0x07f6, 0x07f6,
-	0x09fa, 0x09fa,
-	0x0b70, 0x0b70,
-	0x0bf3, 0x0bf8,
-	0x0bfa, 0x0bfa,
-	0x0c7f, 0x0c7f,
-	0x0cf1, 0x0cf2,
-	0x0d79, 0x0d79,
-	0x0f01, 0x0f03,
-	0x0f13, 0x0f17,
-	0x0f1a, 0x0f1f,
-	0x0f34, 0x0f34,
-	0x0f36, 0x0f36,
-	0x0f38, 0x0f38,
-	0x0fbe, 0x0fc5,
-	0x0fc7, 0x0fcc,
-	0x0fce, 0x0fcf,
-	0x0fd5, 0x0fd8,
-	0x109e, 0x109f,
-	0x1360, 0x1360,
-	0x1390, 0x1399,
-	0x1940, 0x1940,
-	0x19e0, 0x19ff,
-	0x1b61, 0x1b6a,
-	0x1b74, 0x1b7c,
-	0x2100, 0x2101,
-	0x2103, 0x2106,
-	0x2108, 0x2109,
-	0x2114, 0x2114,
-	0x2116, 0x2118,
-	0x211e, 0x2123,
-	0x2125, 0x2125,
-	0x2127, 0x2127,
-	0x2129, 0x2129,
-	0x212e, 0x212e,
-	0x213a, 0x213b,
-	0x214a, 0x214a,
-	0x214c, 0x214d,
-	0x214f, 0x214f,
-	0x2195, 0x2199,
-	0x219c, 0x219f,
-	0x21a1, 0x21a2,
-	0x21a4, 0x21a5,
-	0x21a7, 0x21ad,
-	0x21af, 0x21cd,
-	0x21d0, 0x21d1,
-	0x21d3, 0x21d3,
-	0x21d5, 0x21f3,
-	0x2300, 0x2307,
-	0x230c, 0x231f,
-	0x2322, 0x2328,
-	0x232b, 0x237b,
-	0x237d, 0x239a,
-	0x23b4, 0x23db,
-	0x23e2, 0x23e8,
-	0x2400, 0x2426,
-	0x2440, 0x244a,
-	0x249c, 0x24e9,
-	0x2500, 0x25b6,
-	0x25b8, 0x25c0,
-	0x25c2, 0x25f7,
-	0x2600, 0x266e,
-	0x2670, 0x26cd,
-	0x26cf, 0x26e1,
-	0x26e3, 0x26e3,
-	0x26e8, 0x26ff,
-	0x2701, 0x2704,
-	0x2706, 0x2709,
-	0x270c, 0x2727,
-	0x2729, 0x274b,
-	0x274d, 0x274d,
-	0x274f, 0x2752,
-	0x2756, 0x275e,
-	0x2761, 0x2767,
-	0x2794, 0x2794,
-	0x2798, 0x27af,
-	0x27b1, 0x27be,
-	0x2800, 0x28ff,
-	0x2b00, 0x2b2f,
-	0x2b45, 0x2b46,
-	0x2b50, 0x2b59,
-	0x2ce5, 0x2cea,
-	0x2e80, 0x2e99,
-	0x2e9b, 0x2ef3,
-	0x2f00, 0x2fd5,
-	0x2ff0, 0x2ffb,
-	0x3004, 0x3004,
-	0x3012, 0x3013,
-	0x3020, 0x3020,
-	0x3036, 0x3037,
-	0x303e, 0x303f,
-	0x3190, 0x3191,
-	0x3196, 0x319f,
-	0x31c0, 0x31e3,
-	0x3200, 0x321e,
-	0x322a, 0x3250,
-	0x3260, 0x327f,
-	0x328a, 0x32b0,
-	0x32c0, 0x32fe,
-	0x3300, 0x33ff,
-	0x4dc0, 0x4dff,
-	0xa490, 0xa4c6,
-	0xa828, 0xa82b,
-	0xa836, 0xa837,
-	0xa839, 0xa839,
-	0xaa77, 0xaa79,
-	0xfdfd, 0xfdfd,
-	0xffe4, 0xffe4,
-	0xffe8, 0xffe8,
-	0xffed, 0xffee,
-	0xfffc, 0xfffd,
-	0x10102, 0x10102,
-	0x10137, 0x1013f,
-	0x10179, 0x10189,
-	0x10190, 0x1019b,
-	0x101d0, 0x101fc,
-	0x1d000, 0x1d0f5,
-	0x1d100, 0x1d126,
-	0x1d129, 0x1d164,
-	0x1d16a, 0x1d16c,
-	0x1d183, 0x1d184,
-	0x1d18c, 0x1d1a9,
-	0x1d1ae, 0x1d1dd,
-	0x1d200, 0x1d241,
-	0x1d245, 0x1d245,
-	0x1d300, 0x1d356,
-	0x1f000, 0x1f02b,
-	0x1f030, 0x1f093,
-	0x1f110, 0x1f12e,
-	0x1f131, 0x1f131,
-	0x1f13d, 0x1f13d,
-	0x1f13f, 0x1f13f,
-	0x1f142, 0x1f142,
-	0x1f146, 0x1f146,
-	0x1f14a, 0x1f14e,
-	0x1f157, 0x1f157,
-	0x1f15f, 0x1f15f,
-	0x1f179, 0x1f179,
-	0x1f17b, 0x1f17c,
-	0x1f17f, 0x1f17f,
-	0x1f18a, 0x1f18d,
-	0x1f190, 0x1f190,
-	0x1f200, 0x1f200,
-	0x1f210, 0x1f231,
-	0x1f240, 0x1f248,
+        154,
+        0x00a6, 0x00a7,
+        0x00a9, 0x00a9,
+        0x00ae, 0x00ae,
+        0x00b0, 0x00b0,
+        0x00b6, 0x00b6,
+        0x0482, 0x0482,
+        0x060e, 0x060f,
+        0x06e9, 0x06e9,
+        0x06fd, 0x06fe,
+        0x07f6, 0x07f6,
+        0x09fa, 0x09fa,
+        0x0b70, 0x0b70,
+        0x0bf3, 0x0bf8,
+        0x0bfa, 0x0bfa,
+        0x0c7f, 0x0c7f,
+        0x0cf1, 0x0cf2,
+        0x0d79, 0x0d79,
+        0x0f01, 0x0f03,
+        0x0f13, 0x0f17,
+        0x0f1a, 0x0f1f,
+        0x0f34, 0x0f34,
+        0x0f36, 0x0f36,
+        0x0f38, 0x0f38,
+        0x0fbe, 0x0fc5,
+        0x0fc7, 0x0fcc,
+        0x0fce, 0x0fcf,
+        0x0fd5, 0x0fd8,
+        0x109e, 0x109f,
+        0x1360, 0x1360,
+        0x1390, 0x1399,
+        0x1940, 0x1940,
+        0x19e0, 0x19ff,
+        0x1b61, 0x1b6a,
+        0x1b74, 0x1b7c,
+        0x2100, 0x2101,
+        0x2103, 0x2106,
+        0x2108, 0x2109,
+        0x2114, 0x2114,
+        0x2116, 0x2118,
+        0x211e, 0x2123,
+        0x2125, 0x2125,
+        0x2127, 0x2127,
+        0x2129, 0x2129,
+        0x212e, 0x212e,
+        0x213a, 0x213b,
+        0x214a, 0x214a,
+        0x214c, 0x214d,
+        0x214f, 0x214f,
+        0x2195, 0x2199,
+        0x219c, 0x219f,
+        0x21a1, 0x21a2,
+        0x21a4, 0x21a5,
+        0x21a7, 0x21ad,
+        0x21af, 0x21cd,
+        0x21d0, 0x21d1,
+        0x21d3, 0x21d3,
+        0x21d5, 0x21f3,
+        0x2300, 0x2307,
+        0x230c, 0x231f,
+        0x2322, 0x2328,
+        0x232b, 0x237b,
+        0x237d, 0x239a,
+        0x23b4, 0x23db,
+        0x23e2, 0x23e8,
+        0x2400, 0x2426,
+        0x2440, 0x244a,
+        0x249c, 0x24e9,
+        0x2500, 0x25b6,
+        0x25b8, 0x25c0,
+        0x25c2, 0x25f7,
+        0x2600, 0x266e,
+        0x2670, 0x26cd,
+        0x26cf, 0x26e1,
+        0x26e3, 0x26e3,
+        0x26e8, 0x26ff,
+        0x2701, 0x2704,
+        0x2706, 0x2709,
+        0x270c, 0x2727,
+        0x2729, 0x274b,
+        0x274d, 0x274d,
+        0x274f, 0x2752,
+        0x2756, 0x275e,
+        0x2761, 0x2767,
+        0x2794, 0x2794,
+        0x2798, 0x27af,
+        0x27b1, 0x27be,
+        0x2800, 0x28ff,
+        0x2b00, 0x2b2f,
+        0x2b45, 0x2b46,
+        0x2b50, 0x2b59,
+        0x2ce5, 0x2cea,
+        0x2e80, 0x2e99,
+        0x2e9b, 0x2ef3,
+        0x2f00, 0x2fd5,
+        0x2ff0, 0x2ffb,
+        0x3004, 0x3004,
+        0x3012, 0x3013,
+        0x3020, 0x3020,
+        0x3036, 0x3037,
+        0x303e, 0x303f,
+        0x3190, 0x3191,
+        0x3196, 0x319f,
+        0x31c0, 0x31e3,
+        0x3200, 0x321e,
+        0x322a, 0x3250,
+        0x3260, 0x327f,
+        0x328a, 0x32b0,
+        0x32c0, 0x32fe,
+        0x3300, 0x33ff,
+        0x4dc0, 0x4dff,
+        0xa490, 0xa4c6,
+        0xa828, 0xa82b,
+        0xa836, 0xa837,
+        0xa839, 0xa839,
+        0xaa77, 0xaa79,
+        0xfdfd, 0xfdfd,
+        0xffe4, 0xffe4,
+        0xffe8, 0xffe8,
+        0xffed, 0xffee,
+        0xfffc, 0xfffd,
+        0x10102, 0x10102,
+        0x10137, 0x1013f,
+        0x10179, 0x10189,
+        0x10190, 0x1019b,
+        0x101d0, 0x101fc,
+        0x1d000, 0x1d0f5,
+        0x1d100, 0x1d126,
+        0x1d129, 0x1d164,
+        0x1d16a, 0x1d16c,
+        0x1d183, 0x1d184,
+        0x1d18c, 0x1d1a9,
+        0x1d1ae, 0x1d1dd,
+        0x1d200, 0x1d241,
+        0x1d245, 0x1d245,
+        0x1d300, 0x1d356,
+        0x1f000, 0x1f02b,
+        0x1f030, 0x1f093,
+        0x1f110, 0x1f12e,
+        0x1f131, 0x1f131,
+        0x1f13d, 0x1f13d,
+        0x1f13f, 0x1f13f,
+        0x1f142, 0x1f142,
+        0x1f146, 0x1f146,
+        0x1f14a, 0x1f14e,
+        0x1f157, 0x1f157,
+        0x1f15f, 0x1f15f,
+        0x1f179, 0x1f179,
+        0x1f17b, 0x1f17c,
+        0x1f17f, 0x1f17f,
+        0x1f18a, 0x1f18d,
+        0x1f190, 0x1f190,
+        0x1f200, 0x1f200,
+        0x1f210, 0x1f231,
+        0x1f240, 0x1f248,
 }; /* CR_So */
 
 /* 'Z': Major Category */
 static const OnigCodePoint CR_Z[] = {
-	9,
-	0x0020, 0x0020,
-	0x00a0, 0x00a0,
-	0x1680, 0x1680,
-	0x180e, 0x180e,
-	0x2000, 0x200a,
-	0x2028, 0x2029,
-	0x202f, 0x202f,
-	0x205f, 0x205f,
-	0x3000, 0x3000,
+        9,
+        0x0020, 0x0020,
+        0x00a0, 0x00a0,
+        0x1680, 0x1680,
+        0x180e, 0x180e,
+        0x2000, 0x200a,
+        0x2028, 0x2029,
+        0x202f, 0x202f,
+        0x205f, 0x205f,
+        0x3000, 0x3000,
 }; /* CR_Z */
 
 /* 'Zl': General Category */
 static const OnigCodePoint CR_Zl[] = {
-	1,
-	0x2028, 0x2028,
+        1,
+        0x2028, 0x2028,
 }; /* CR_Zl */
 
 /* 'Zp': General Category */
 static const OnigCodePoint CR_Zp[] = {
-	1,
-	0x2029, 0x2029,
+        1,
+        0x2029, 0x2029,
 }; /* CR_Zp */
 
 /* 'Zs': General Category */
 static const OnigCodePoint CR_Zs[] = {
-	8,
-	0x0020, 0x0020,
-	0x00a0, 0x00a0,
-	0x1680, 0x1680,
-	0x180e, 0x180e,
-	0x2000, 0x200a,
-	0x202f, 0x202f,
-	0x205f, 0x205f,
-	0x3000, 0x3000,
+        8,
+        0x0020, 0x0020,
+        0x00a0, 0x00a0,
+        0x1680, 0x1680,
+        0x180e, 0x180e,
+        0x2000, 0x200a,
+        0x202f, 0x202f,
+        0x205f, 0x205f,
+        0x3000, 0x3000,
 }; /* CR_Zs */
 
 /* 'Math': Derived Property */
 static const OnigCodePoint CR_Math[] = {
-	105,
-	0x002b, 0x002b,
-	0x003c, 0x003e,
-	0x005e, 0x005e,
-	0x007c, 0x007c,
-	0x007e, 0x007e,
-	0x00ac, 0x00ac,
-	0x00b1, 0x00b1,
-	0x00d7, 0x00d7,
-	0x00f7, 0x00f7,
-	0x03d0, 0x03d2,
-	0x03d5, 0x03d5,
-	0x03f0, 0x03f1,
-	0x03f4, 0x03f6,
-	0x0606, 0x0608,
-	0x2016, 0x2016,
-	0x2032, 0x2034,
-	0x2040, 0x2040,
-	0x2044, 0x2044,
-	0x2052, 0x2052,
-	0x2061, 0x2064,
-	0x207a, 0x207e,
-	0x208a, 0x208e,
-	0x20d0, 0x20dc,
-	0x20e1, 0x20e1,
-	0x20e5, 0x20e6,
-	0x20eb, 0x20ef,
-	0x2102, 0x2102,
-	0x210a, 0x2113,
-	0x2115, 0x2115,
-	0x2119, 0x211d,
-	0x2124, 0x2124,
-	0x2128, 0x2129,
-	0x212c, 0x212d,
-	0x212f, 0x2131,
-	0x2133, 0x2138,
-	0x213c, 0x2149,
-	0x214b, 0x214b,
-	0x2190, 0x21a7,
-	0x21a9, 0x21ae,
-	0x21b0, 0x21b1,
-	0x21b6, 0x21b7,
-	0x21bc, 0x21db,
-	0x21dd, 0x21dd,
-	0x21e4, 0x21e5,
-	0x21f4, 0x22ff,
-	0x2308, 0x230b,
-	0x2320, 0x2321,
-	0x237c, 0x237c,
-	0x239b, 0x23b5,
-	0x23b7, 0x23b7,
-	0x23d0, 0x23d0,
-	0x23dc, 0x23e2,
-	0x25a0, 0x25a1,
-	0x25ae, 0x25b7,
-	0x25bc, 0x25c1,
-	0x25c6, 0x25c7,
-	0x25ca, 0x25cb,
-	0x25cf, 0x25d3,
-	0x25e2, 0x25e2,
-	0x25e4, 0x25e4,
-	0x25e7, 0x25ec,
-	0x25f8, 0x25ff,
-	0x2605, 0x2606,
-	0x2640, 0x2640,
-	0x2642, 0x2642,
-	0x2660, 0x2663,
-	0x266d, 0x266f,
-	0x27c0, 0x27ca,
-	0x27cc, 0x27cc,
-	0x27d0, 0x27ff,
-	0x2900, 0x2aff,
-	0x2b30, 0x2b44,
-	0x2b47, 0x2b4c,
-	0xfb29, 0xfb29,
-	0xfe61, 0xfe66,
-	0xfe68, 0xfe68,
-	0xff0b, 0xff0b,
-	0xff1c, 0xff1e,
-	0xff3c, 0xff3c,
-	0xff3e, 0xff3e,
-	0xff5c, 0xff5c,
-	0xff5e, 0xff5e,
-	0xffe2, 0xffe2,
-	0xffe9, 0xffec,
-	0x1d400, 0x1d454,
-	0x1d456, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d51e, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d552, 0x1d6a5,
-	0x1d6a8, 0x1d7cb,
-	0x1d7ce, 0x1d7ff,
+        105,
+        0x002b, 0x002b,
+        0x003c, 0x003e,
+        0x005e, 0x005e,
+        0x007c, 0x007c,
+        0x007e, 0x007e,
+        0x00ac, 0x00ac,
+        0x00b1, 0x00b1,
+        0x00d7, 0x00d7,
+        0x00f7, 0x00f7,
+        0x03d0, 0x03d2,
+        0x03d5, 0x03d5,
+        0x03f0, 0x03f1,
+        0x03f4, 0x03f6,
+        0x0606, 0x0608,
+        0x2016, 0x2016,
+        0x2032, 0x2034,
+        0x2040, 0x2040,
+        0x2044, 0x2044,
+        0x2052, 0x2052,
+        0x2061, 0x2064,
+        0x207a, 0x207e,
+        0x208a, 0x208e,
+        0x20d0, 0x20dc,
+        0x20e1, 0x20e1,
+        0x20e5, 0x20e6,
+        0x20eb, 0x20ef,
+        0x2102, 0x2102,
+        0x210a, 0x2113,
+        0x2115, 0x2115,
+        0x2119, 0x211d,
+        0x2124, 0x2124,
+        0x2128, 0x2129,
+        0x212c, 0x212d,
+        0x212f, 0x2131,
+        0x2133, 0x2138,
+        0x213c, 0x2149,
+        0x214b, 0x214b,
+        0x2190, 0x21a7,
+        0x21a9, 0x21ae,
+        0x21b0, 0x21b1,
+        0x21b6, 0x21b7,
+        0x21bc, 0x21db,
+        0x21dd, 0x21dd,
+        0x21e4, 0x21e5,
+        0x21f4, 0x22ff,
+        0x2308, 0x230b,
+        0x2320, 0x2321,
+        0x237c, 0x237c,
+        0x239b, 0x23b5,
+        0x23b7, 0x23b7,
+        0x23d0, 0x23d0,
+        0x23dc, 0x23e2,
+        0x25a0, 0x25a1,
+        0x25ae, 0x25b7,
+        0x25bc, 0x25c1,
+        0x25c6, 0x25c7,
+        0x25ca, 0x25cb,
+        0x25cf, 0x25d3,
+        0x25e2, 0x25e2,
+        0x25e4, 0x25e4,
+        0x25e7, 0x25ec,
+        0x25f8, 0x25ff,
+        0x2605, 0x2606,
+        0x2640, 0x2640,
+        0x2642, 0x2642,
+        0x2660, 0x2663,
+        0x266d, 0x266f,
+        0x27c0, 0x27ca,
+        0x27cc, 0x27cc,
+        0x27d0, 0x27ff,
+        0x2900, 0x2aff,
+        0x2b30, 0x2b44,
+        0x2b47, 0x2b4c,
+        0xfb29, 0xfb29,
+        0xfe61, 0xfe66,
+        0xfe68, 0xfe68,
+        0xff0b, 0xff0b,
+        0xff1c, 0xff1e,
+        0xff3c, 0xff3c,
+        0xff3e, 0xff3e,
+        0xff5c, 0xff5c,
+        0xff5e, 0xff5e,
+        0xffe2, 0xffe2,
+        0xffe9, 0xffec,
+        0x1d400, 0x1d454,
+        0x1d456, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d51e, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d552, 0x1d6a5,
+        0x1d6a8, 0x1d7cb,
+        0x1d7ce, 0x1d7ff,
 }; /* CR_Math */
 
 /* 'Alphabetic': Derived Property */
 static const OnigCodePoint CR_Alphabetic[] = {
-	474,
-	0x0041, 0x005a,
-	0x0061, 0x007a,
-	0x00aa, 0x00aa,
-	0x00b5, 0x00b5,
-	0x00ba, 0x00ba,
-	0x00c0, 0x00d6,
-	0x00d8, 0x00f6,
-	0x00f8, 0x02c1,
-	0x02c6, 0x02d1,
-	0x02e0, 0x02e4,
-	0x02ec, 0x02ec,
-	0x02ee, 0x02ee,
-	0x0345, 0x0345,
-	0x0370, 0x0374,
-	0x0376, 0x0377,
-	0x037a, 0x037d,
-	0x0386, 0x0386,
-	0x0388, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x03a1,
-	0x03a3, 0x03f5,
-	0x03f7, 0x0481,
-	0x048a, 0x0525,
-	0x0531, 0x0556,
-	0x0559, 0x0559,
-	0x0561, 0x0587,
-	0x05b0, 0x05bd,
-	0x05bf, 0x05bf,
-	0x05c1, 0x05c2,
-	0x05c4, 0x05c5,
-	0x05c7, 0x05c7,
-	0x05d0, 0x05ea,
-	0x05f0, 0x05f2,
-	0x0610, 0x061a,
-	0x0621, 0x0657,
-	0x0659, 0x065e,
-	0x066e, 0x06d3,
-	0x06d5, 0x06dc,
-	0x06e1, 0x06e8,
-	0x06ed, 0x06ef,
-	0x06fa, 0x06fc,
-	0x06ff, 0x06ff,
-	0x0710, 0x073f,
-	0x074d, 0x07b1,
-	0x07ca, 0x07ea,
-	0x07f4, 0x07f5,
-	0x07fa, 0x07fa,
-	0x0800, 0x0817,
-	0x081a, 0x082c,
-	0x0900, 0x0939,
-	0x093d, 0x094c,
-	0x094e, 0x094e,
-	0x0950, 0x0950,
-	0x0955, 0x0955,
-	0x0958, 0x0963,
-	0x0971, 0x0972,
-	0x0979, 0x097f,
-	0x0981, 0x0983,
-	0x0985, 0x098c,
-	0x098f, 0x0990,
-	0x0993, 0x09a8,
-	0x09aa, 0x09b0,
-	0x09b2, 0x09b2,
-	0x09b6, 0x09b9,
-	0x09bd, 0x09c4,
-	0x09c7, 0x09c8,
-	0x09cb, 0x09cc,
-	0x09ce, 0x09ce,
-	0x09d7, 0x09d7,
-	0x09dc, 0x09dd,
-	0x09df, 0x09e3,
-	0x09f0, 0x09f1,
-	0x0a01, 0x0a03,
-	0x0a05, 0x0a0a,
-	0x0a0f, 0x0a10,
-	0x0a13, 0x0a28,
-	0x0a2a, 0x0a30,
-	0x0a32, 0x0a33,
-	0x0a35, 0x0a36,
-	0x0a38, 0x0a39,
-	0x0a3e, 0x0a42,
-	0x0a47, 0x0a48,
-	0x0a4b, 0x0a4c,
-	0x0a51, 0x0a51,
-	0x0a59, 0x0a5c,
-	0x0a5e, 0x0a5e,
-	0x0a70, 0x0a75,
-	0x0a81, 0x0a83,
-	0x0a85, 0x0a8d,
-	0x0a8f, 0x0a91,
-	0x0a93, 0x0aa8,
-	0x0aaa, 0x0ab0,
-	0x0ab2, 0x0ab3,
-	0x0ab5, 0x0ab9,
-	0x0abd, 0x0ac5,
-	0x0ac7, 0x0ac9,
-	0x0acb, 0x0acc,
-	0x0ad0, 0x0ad0,
-	0x0ae0, 0x0ae3,
-	0x0b01, 0x0b03,
-	0x0b05, 0x0b0c,
-	0x0b0f, 0x0b10,
-	0x0b13, 0x0b28,
-	0x0b2a, 0x0b30,
-	0x0b32, 0x0b33,
-	0x0b35, 0x0b39,
-	0x0b3d, 0x0b44,
-	0x0b47, 0x0b48,
-	0x0b4b, 0x0b4c,
-	0x0b56, 0x0b57,
-	0x0b5c, 0x0b5d,
-	0x0b5f, 0x0b63,
-	0x0b71, 0x0b71,
-	0x0b82, 0x0b83,
-	0x0b85, 0x0b8a,
-	0x0b8e, 0x0b90,
-	0x0b92, 0x0b95,
-	0x0b99, 0x0b9a,
-	0x0b9c, 0x0b9c,
-	0x0b9e, 0x0b9f,
-	0x0ba3, 0x0ba4,
-	0x0ba8, 0x0baa,
-	0x0bae, 0x0bb9,
-	0x0bbe, 0x0bc2,
-	0x0bc6, 0x0bc8,
-	0x0bca, 0x0bcc,
-	0x0bd0, 0x0bd0,
-	0x0bd7, 0x0bd7,
-	0x0c01, 0x0c03,
-	0x0c05, 0x0c0c,
-	0x0c0e, 0x0c10,
-	0x0c12, 0x0c28,
-	0x0c2a, 0x0c33,
-	0x0c35, 0x0c39,
-	0x0c3d, 0x0c44,
-	0x0c46, 0x0c48,
-	0x0c4a, 0x0c4c,
-	0x0c55, 0x0c56,
-	0x0c58, 0x0c59,
-	0x0c60, 0x0c63,
-	0x0c82, 0x0c83,
-	0x0c85, 0x0c8c,
-	0x0c8e, 0x0c90,
-	0x0c92, 0x0ca8,
-	0x0caa, 0x0cb3,
-	0x0cb5, 0x0cb9,
-	0x0cbd, 0x0cc4,
-	0x0cc6, 0x0cc8,
-	0x0cca, 0x0ccc,
-	0x0cd5, 0x0cd6,
-	0x0cde, 0x0cde,
-	0x0ce0, 0x0ce3,
-	0x0d02, 0x0d03,
-	0x0d05, 0x0d0c,
-	0x0d0e, 0x0d10,
-	0x0d12, 0x0d28,
-	0x0d2a, 0x0d39,
-	0x0d3d, 0x0d44,
-	0x0d46, 0x0d48,
-	0x0d4a, 0x0d4c,
-	0x0d57, 0x0d57,
-	0x0d60, 0x0d63,
-	0x0d7a, 0x0d7f,
-	0x0d82, 0x0d83,
-	0x0d85, 0x0d96,
-	0x0d9a, 0x0db1,
-	0x0db3, 0x0dbb,
-	0x0dbd, 0x0dbd,
-	0x0dc0, 0x0dc6,
-	0x0dcf, 0x0dd4,
-	0x0dd6, 0x0dd6,
-	0x0dd8, 0x0ddf,
-	0x0df2, 0x0df3,
-	0x0e01, 0x0e3a,
-	0x0e40, 0x0e46,
-	0x0e4d, 0x0e4d,
-	0x0e81, 0x0e82,
-	0x0e84, 0x0e84,
-	0x0e87, 0x0e88,
-	0x0e8a, 0x0e8a,
-	0x0e8d, 0x0e8d,
-	0x0e94, 0x0e97,
-	0x0e99, 0x0e9f,
-	0x0ea1, 0x0ea3,
-	0x0ea5, 0x0ea5,
-	0x0ea7, 0x0ea7,
-	0x0eaa, 0x0eab,
-	0x0ead, 0x0eb9,
-	0x0ebb, 0x0ebd,
-	0x0ec0, 0x0ec4,
-	0x0ec6, 0x0ec6,
-	0x0ecd, 0x0ecd,
-	0x0edc, 0x0edd,
-	0x0f00, 0x0f00,
-	0x0f40, 0x0f47,
-	0x0f49, 0x0f6c,
-	0x0f71, 0x0f81,
-	0x0f88, 0x0f8b,
-	0x0f90, 0x0f97,
-	0x0f99, 0x0fbc,
-	0x1000, 0x1036,
-	0x1038, 0x1038,
-	0x103b, 0x103f,
-	0x1050, 0x1062,
-	0x1065, 0x1068,
-	0x106e, 0x1086,
-	0x108e, 0x108e,
-	0x109c, 0x109d,
-	0x10a0, 0x10c5,
-	0x10d0, 0x10fa,
-	0x10fc, 0x10fc,
-	0x1100, 0x1248,
-	0x124a, 0x124d,
-	0x1250, 0x1256,
-	0x1258, 0x1258,
-	0x125a, 0x125d,
-	0x1260, 0x1288,
-	0x128a, 0x128d,
-	0x1290, 0x12b0,
-	0x12b2, 0x12b5,
-	0x12b8, 0x12be,
-	0x12c0, 0x12c0,
-	0x12c2, 0x12c5,
-	0x12c8, 0x12d6,
-	0x12d8, 0x1310,
-	0x1312, 0x1315,
-	0x1318, 0x135a,
-	0x135f, 0x135f,
-	0x1380, 0x138f,
-	0x13a0, 0x13f4,
-	0x1401, 0x166c,
-	0x166f, 0x167f,
-	0x1681, 0x169a,
-	0x16a0, 0x16ea,
-	0x16ee, 0x16f0,
-	0x1700, 0x170c,
-	0x170e, 0x1713,
-	0x1720, 0x1733,
-	0x1740, 0x1753,
-	0x1760, 0x176c,
-	0x176e, 0x1770,
-	0x1772, 0x1773,
-	0x1780, 0x17b3,
-	0x17b6, 0x17c8,
-	0x17d7, 0x17d7,
-	0x17dc, 0x17dc,
-	0x1820, 0x1877,
-	0x1880, 0x18aa,
-	0x18b0, 0x18f5,
-	0x1900, 0x191c,
-	0x1920, 0x192b,
-	0x1930, 0x1938,
-	0x1950, 0x196d,
-	0x1970, 0x1974,
-	0x1980, 0x19ab,
-	0x19b0, 0x19c9,
-	0x1a00, 0x1a1b,
-	0x1a20, 0x1a5e,
-	0x1a61, 0x1a74,
-	0x1aa7, 0x1aa7,
-	0x1b00, 0x1b33,
-	0x1b35, 0x1b43,
-	0x1b45, 0x1b4b,
-	0x1b80, 0x1ba9,
-	0x1bae, 0x1baf,
-	0x1c00, 0x1c35,
-	0x1c4d, 0x1c4f,
-	0x1c5a, 0x1c7d,
-	0x1ce9, 0x1cec,
-	0x1cee, 0x1cf2,
-	0x1d00, 0x1dbf,
-	0x1e00, 0x1f15,
-	0x1f18, 0x1f1d,
-	0x1f20, 0x1f45,
-	0x1f48, 0x1f4d,
-	0x1f50, 0x1f57,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f7d,
-	0x1f80, 0x1fb4,
-	0x1fb6, 0x1fbc,
-	0x1fbe, 0x1fbe,
-	0x1fc2, 0x1fc4,
-	0x1fc6, 0x1fcc,
-	0x1fd0, 0x1fd3,
-	0x1fd6, 0x1fdb,
-	0x1fe0, 0x1fec,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ffc,
-	0x2071, 0x2071,
-	0x207f, 0x207f,
-	0x2090, 0x2094,
-	0x2102, 0x2102,
-	0x2107, 0x2107,
-	0x210a, 0x2113,
-	0x2115, 0x2115,
-	0x2119, 0x211d,
-	0x2124, 0x2124,
-	0x2126, 0x2126,
-	0x2128, 0x2128,
-	0x212a, 0x212d,
-	0x212f, 0x2139,
-	0x213c, 0x213f,
-	0x2145, 0x2149,
-	0x214e, 0x214e,
-	0x2160, 0x2188,
-	0x24b6, 0x24e9,
-	0x2c00, 0x2c2e,
-	0x2c30, 0x2c5e,
-	0x2c60, 0x2ce4,
-	0x2ceb, 0x2cee,
-	0x2d00, 0x2d25,
-	0x2d30, 0x2d65,
-	0x2d6f, 0x2d6f,
-	0x2d80, 0x2d96,
-	0x2da0, 0x2da6,
-	0x2da8, 0x2dae,
-	0x2db0, 0x2db6,
-	0x2db8, 0x2dbe,
-	0x2dc0, 0x2dc6,
-	0x2dc8, 0x2dce,
-	0x2dd0, 0x2dd6,
-	0x2dd8, 0x2dde,
-	0x2de0, 0x2dff,
-	0x2e2f, 0x2e2f,
-	0x3005, 0x3007,
-	0x3021, 0x3029,
-	0x3031, 0x3035,
-	0x3038, 0x303c,
-	0x3041, 0x3096,
-	0x309d, 0x309f,
-	0x30a1, 0x30fa,
-	0x30fc, 0x30ff,
-	0x3105, 0x312d,
-	0x3131, 0x318e,
-	0x31a0, 0x31b7,
-	0x31f0, 0x31ff,
-	0x3400, 0x4db5,
-	0x4e00, 0x9fcb,
-	0xa000, 0xa48c,
-	0xa4d0, 0xa4fd,
-	0xa500, 0xa60c,
-	0xa610, 0xa61f,
-	0xa62a, 0xa62b,
-	0xa640, 0xa65f,
-	0xa662, 0xa66e,
-	0xa67f, 0xa697,
-	0xa6a0, 0xa6ef,
-	0xa717, 0xa71f,
-	0xa722, 0xa788,
-	0xa78b, 0xa78c,
-	0xa7fb, 0xa801,
-	0xa803, 0xa805,
-	0xa807, 0xa80a,
-	0xa80c, 0xa827,
-	0xa840, 0xa873,
-	0xa880, 0xa8c3,
-	0xa8f2, 0xa8f7,
-	0xa8fb, 0xa8fb,
-	0xa90a, 0xa92a,
-	0xa930, 0xa952,
-	0xa960, 0xa97c,
-	0xa980, 0xa9bf,
-	0xa9cf, 0xa9cf,
-	0xaa00, 0xaa36,
-	0xaa40, 0xaa4d,
-	0xaa60, 0xaa76,
-	0xaa7a, 0xaa7a,
-	0xaa80, 0xaabe,
-	0xaac0, 0xaac0,
-	0xaac2, 0xaac2,
-	0xaadb, 0xaadd,
-	0xabc0, 0xabea,
-	0xac00, 0xd7a3,
-	0xd7b0, 0xd7c6,
-	0xd7cb, 0xd7fb,
-	0xf900, 0xfa2d,
-	0xfa30, 0xfa6d,
-	0xfa70, 0xfad9,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xfb1d, 0xfb28,
-	0xfb2a, 0xfb36,
-	0xfb38, 0xfb3c,
-	0xfb3e, 0xfb3e,
-	0xfb40, 0xfb41,
-	0xfb43, 0xfb44,
-	0xfb46, 0xfbb1,
-	0xfbd3, 0xfd3d,
-	0xfd50, 0xfd8f,
-	0xfd92, 0xfdc7,
-	0xfdf0, 0xfdfb,
-	0xfe70, 0xfe74,
-	0xfe76, 0xfefc,
-	0xff21, 0xff3a,
-	0xff41, 0xff5a,
-	0xff66, 0xffbe,
-	0xffc2, 0xffc7,
-	0xffca, 0xffcf,
-	0xffd2, 0xffd7,
-	0xffda, 0xffdc,
-	0x10000, 0x1000b,
-	0x1000d, 0x10026,
-	0x10028, 0x1003a,
-	0x1003c, 0x1003d,
-	0x1003f, 0x1004d,
-	0x10050, 0x1005d,
-	0x10080, 0x100fa,
-	0x10140, 0x10174,
-	0x10280, 0x1029c,
-	0x102a0, 0x102d0,
-	0x10300, 0x1031e,
-	0x10330, 0x1034a,
-	0x10380, 0x1039d,
-	0x103a0, 0x103c3,
-	0x103c8, 0x103cf,
-	0x103d1, 0x103d5,
-	0x10400, 0x1049d,
-	0x10800, 0x10805,
-	0x10808, 0x10808,
-	0x1080a, 0x10835,
-	0x10837, 0x10838,
-	0x1083c, 0x1083c,
-	0x1083f, 0x10855,
-	0x10900, 0x10915,
-	0x10920, 0x10939,
-	0x10a00, 0x10a03,
-	0x10a05, 0x10a06,
-	0x10a0c, 0x10a13,
-	0x10a15, 0x10a17,
-	0x10a19, 0x10a33,
-	0x10a60, 0x10a7c,
-	0x10b00, 0x10b35,
-	0x10b40, 0x10b55,
-	0x10b60, 0x10b72,
-	0x10c00, 0x10c48,
-	0x11082, 0x110b8,
-	0x12000, 0x1236e,
-	0x12400, 0x12462,
-	0x13000, 0x1342e,
-	0x1d400, 0x1d454,
-	0x1d456, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d51e, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d552, 0x1d6a5,
-	0x1d6a8, 0x1d6c0,
-	0x1d6c2, 0x1d6da,
-	0x1d6dc, 0x1d6fa,
-	0x1d6fc, 0x1d714,
-	0x1d716, 0x1d734,
-	0x1d736, 0x1d74e,
-	0x1d750, 0x1d76e,
-	0x1d770, 0x1d788,
-	0x1d78a, 0x1d7a8,
-	0x1d7aa, 0x1d7c2,
-	0x1d7c4, 0x1d7cb,
-	0x20000, 0x2a6d6,
-	0x2a700, 0x2b734,
-	0x2f800, 0x2fa1d,
+        474,
+        0x0041, 0x005a,
+        0x0061, 0x007a,
+        0x00aa, 0x00aa,
+        0x00b5, 0x00b5,
+        0x00ba, 0x00ba,
+        0x00c0, 0x00d6,
+        0x00d8, 0x00f6,
+        0x00f8, 0x02c1,
+        0x02c6, 0x02d1,
+        0x02e0, 0x02e4,
+        0x02ec, 0x02ec,
+        0x02ee, 0x02ee,
+        0x0345, 0x0345,
+        0x0370, 0x0374,
+        0x0376, 0x0377,
+        0x037a, 0x037d,
+        0x0386, 0x0386,
+        0x0388, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x03a1,
+        0x03a3, 0x03f5,
+        0x03f7, 0x0481,
+        0x048a, 0x0525,
+        0x0531, 0x0556,
+        0x0559, 0x0559,
+        0x0561, 0x0587,
+        0x05b0, 0x05bd,
+        0x05bf, 0x05bf,
+        0x05c1, 0x05c2,
+        0x05c4, 0x05c5,
+        0x05c7, 0x05c7,
+        0x05d0, 0x05ea,
+        0x05f0, 0x05f2,
+        0x0610, 0x061a,
+        0x0621, 0x0657,
+        0x0659, 0x065e,
+        0x066e, 0x06d3,
+        0x06d5, 0x06dc,
+        0x06e1, 0x06e8,
+        0x06ed, 0x06ef,
+        0x06fa, 0x06fc,
+        0x06ff, 0x06ff,
+        0x0710, 0x073f,
+        0x074d, 0x07b1,
+        0x07ca, 0x07ea,
+        0x07f4, 0x07f5,
+        0x07fa, 0x07fa,
+        0x0800, 0x0817,
+        0x081a, 0x082c,
+        0x0900, 0x0939,
+        0x093d, 0x094c,
+        0x094e, 0x094e,
+        0x0950, 0x0950,
+        0x0955, 0x0955,
+        0x0958, 0x0963,
+        0x0971, 0x0972,
+        0x0979, 0x097f,
+        0x0981, 0x0983,
+        0x0985, 0x098c,
+        0x098f, 0x0990,
+        0x0993, 0x09a8,
+        0x09aa, 0x09b0,
+        0x09b2, 0x09b2,
+        0x09b6, 0x09b9,
+        0x09bd, 0x09c4,
+        0x09c7, 0x09c8,
+        0x09cb, 0x09cc,
+        0x09ce, 0x09ce,
+        0x09d7, 0x09d7,
+        0x09dc, 0x09dd,
+        0x09df, 0x09e3,
+        0x09f0, 0x09f1,
+        0x0a01, 0x0a03,
+        0x0a05, 0x0a0a,
+        0x0a0f, 0x0a10,
+        0x0a13, 0x0a28,
+        0x0a2a, 0x0a30,
+        0x0a32, 0x0a33,
+        0x0a35, 0x0a36,
+        0x0a38, 0x0a39,
+        0x0a3e, 0x0a42,
+        0x0a47, 0x0a48,
+        0x0a4b, 0x0a4c,
+        0x0a51, 0x0a51,
+        0x0a59, 0x0a5c,
+        0x0a5e, 0x0a5e,
+        0x0a70, 0x0a75,
+        0x0a81, 0x0a83,
+        0x0a85, 0x0a8d,
+        0x0a8f, 0x0a91,
+        0x0a93, 0x0aa8,
+        0x0aaa, 0x0ab0,
+        0x0ab2, 0x0ab3,
+        0x0ab5, 0x0ab9,
+        0x0abd, 0x0ac5,
+        0x0ac7, 0x0ac9,
+        0x0acb, 0x0acc,
+        0x0ad0, 0x0ad0,
+        0x0ae0, 0x0ae3,
+        0x0b01, 0x0b03,
+        0x0b05, 0x0b0c,
+        0x0b0f, 0x0b10,
+        0x0b13, 0x0b28,
+        0x0b2a, 0x0b30,
+        0x0b32, 0x0b33,
+        0x0b35, 0x0b39,
+        0x0b3d, 0x0b44,
+        0x0b47, 0x0b48,
+        0x0b4b, 0x0b4c,
+        0x0b56, 0x0b57,
+        0x0b5c, 0x0b5d,
+        0x0b5f, 0x0b63,
+        0x0b71, 0x0b71,
+        0x0b82, 0x0b83,
+        0x0b85, 0x0b8a,
+        0x0b8e, 0x0b90,
+        0x0b92, 0x0b95,
+        0x0b99, 0x0b9a,
+        0x0b9c, 0x0b9c,
+        0x0b9e, 0x0b9f,
+        0x0ba3, 0x0ba4,
+        0x0ba8, 0x0baa,
+        0x0bae, 0x0bb9,
+        0x0bbe, 0x0bc2,
+        0x0bc6, 0x0bc8,
+        0x0bca, 0x0bcc,
+        0x0bd0, 0x0bd0,
+        0x0bd7, 0x0bd7,
+        0x0c01, 0x0c03,
+        0x0c05, 0x0c0c,
+        0x0c0e, 0x0c10,
+        0x0c12, 0x0c28,
+        0x0c2a, 0x0c33,
+        0x0c35, 0x0c39,
+        0x0c3d, 0x0c44,
+        0x0c46, 0x0c48,
+        0x0c4a, 0x0c4c,
+        0x0c55, 0x0c56,
+        0x0c58, 0x0c59,
+        0x0c60, 0x0c63,
+        0x0c82, 0x0c83,
+        0x0c85, 0x0c8c,
+        0x0c8e, 0x0c90,
+        0x0c92, 0x0ca8,
+        0x0caa, 0x0cb3,
+        0x0cb5, 0x0cb9,
+        0x0cbd, 0x0cc4,
+        0x0cc6, 0x0cc8,
+        0x0cca, 0x0ccc,
+        0x0cd5, 0x0cd6,
+        0x0cde, 0x0cde,
+        0x0ce0, 0x0ce3,
+        0x0d02, 0x0d03,
+        0x0d05, 0x0d0c,
+        0x0d0e, 0x0d10,
+        0x0d12, 0x0d28,
+        0x0d2a, 0x0d39,
+        0x0d3d, 0x0d44,
+        0x0d46, 0x0d48,
+        0x0d4a, 0x0d4c,
+        0x0d57, 0x0d57,
+        0x0d60, 0x0d63,
+        0x0d7a, 0x0d7f,
+        0x0d82, 0x0d83,
+        0x0d85, 0x0d96,
+        0x0d9a, 0x0db1,
+        0x0db3, 0x0dbb,
+        0x0dbd, 0x0dbd,
+        0x0dc0, 0x0dc6,
+        0x0dcf, 0x0dd4,
+        0x0dd6, 0x0dd6,
+        0x0dd8, 0x0ddf,
+        0x0df2, 0x0df3,
+        0x0e01, 0x0e3a,
+        0x0e40, 0x0e46,
+        0x0e4d, 0x0e4d,
+        0x0e81, 0x0e82,
+        0x0e84, 0x0e84,
+        0x0e87, 0x0e88,
+        0x0e8a, 0x0e8a,
+        0x0e8d, 0x0e8d,
+        0x0e94, 0x0e97,
+        0x0e99, 0x0e9f,
+        0x0ea1, 0x0ea3,
+        0x0ea5, 0x0ea5,
+        0x0ea7, 0x0ea7,
+        0x0eaa, 0x0eab,
+        0x0ead, 0x0eb9,
+        0x0ebb, 0x0ebd,
+        0x0ec0, 0x0ec4,
+        0x0ec6, 0x0ec6,
+        0x0ecd, 0x0ecd,
+        0x0edc, 0x0edd,
+        0x0f00, 0x0f00,
+        0x0f40, 0x0f47,
+        0x0f49, 0x0f6c,
+        0x0f71, 0x0f81,
+        0x0f88, 0x0f8b,
+        0x0f90, 0x0f97,
+        0x0f99, 0x0fbc,
+        0x1000, 0x1036,
+        0x1038, 0x1038,
+        0x103b, 0x103f,
+        0x1050, 0x1062,
+        0x1065, 0x1068,
+        0x106e, 0x1086,
+        0x108e, 0x108e,
+        0x109c, 0x109d,
+        0x10a0, 0x10c5,
+        0x10d0, 0x10fa,
+        0x10fc, 0x10fc,
+        0x1100, 0x1248,
+        0x124a, 0x124d,
+        0x1250, 0x1256,
+        0x1258, 0x1258,
+        0x125a, 0x125d,
+        0x1260, 0x1288,
+        0x128a, 0x128d,
+        0x1290, 0x12b0,
+        0x12b2, 0x12b5,
+        0x12b8, 0x12be,
+        0x12c0, 0x12c0,
+        0x12c2, 0x12c5,
+        0x12c8, 0x12d6,
+        0x12d8, 0x1310,
+        0x1312, 0x1315,
+        0x1318, 0x135a,
+        0x135f, 0x135f,
+        0x1380, 0x138f,
+        0x13a0, 0x13f4,
+        0x1401, 0x166c,
+        0x166f, 0x167f,
+        0x1681, 0x169a,
+        0x16a0, 0x16ea,
+        0x16ee, 0x16f0,
+        0x1700, 0x170c,
+        0x170e, 0x1713,
+        0x1720, 0x1733,
+        0x1740, 0x1753,
+        0x1760, 0x176c,
+        0x176e, 0x1770,
+        0x1772, 0x1773,
+        0x1780, 0x17b3,
+        0x17b6, 0x17c8,
+        0x17d7, 0x17d7,
+        0x17dc, 0x17dc,
+        0x1820, 0x1877,
+        0x1880, 0x18aa,
+        0x18b0, 0x18f5,
+        0x1900, 0x191c,
+        0x1920, 0x192b,
+        0x1930, 0x1938,
+        0x1950, 0x196d,
+        0x1970, 0x1974,
+        0x1980, 0x19ab,
+        0x19b0, 0x19c9,
+        0x1a00, 0x1a1b,
+        0x1a20, 0x1a5e,
+        0x1a61, 0x1a74,
+        0x1aa7, 0x1aa7,
+        0x1b00, 0x1b33,
+        0x1b35, 0x1b43,
+        0x1b45, 0x1b4b,
+        0x1b80, 0x1ba9,
+        0x1bae, 0x1baf,
+        0x1c00, 0x1c35,
+        0x1c4d, 0x1c4f,
+        0x1c5a, 0x1c7d,
+        0x1ce9, 0x1cec,
+        0x1cee, 0x1cf2,
+        0x1d00, 0x1dbf,
+        0x1e00, 0x1f15,
+        0x1f18, 0x1f1d,
+        0x1f20, 0x1f45,
+        0x1f48, 0x1f4d,
+        0x1f50, 0x1f57,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f7d,
+        0x1f80, 0x1fb4,
+        0x1fb6, 0x1fbc,
+        0x1fbe, 0x1fbe,
+        0x1fc2, 0x1fc4,
+        0x1fc6, 0x1fcc,
+        0x1fd0, 0x1fd3,
+        0x1fd6, 0x1fdb,
+        0x1fe0, 0x1fec,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ffc,
+        0x2071, 0x2071,
+        0x207f, 0x207f,
+        0x2090, 0x2094,
+        0x2102, 0x2102,
+        0x2107, 0x2107,
+        0x210a, 0x2113,
+        0x2115, 0x2115,
+        0x2119, 0x211d,
+        0x2124, 0x2124,
+        0x2126, 0x2126,
+        0x2128, 0x2128,
+        0x212a, 0x212d,
+        0x212f, 0x2139,
+        0x213c, 0x213f,
+        0x2145, 0x2149,
+        0x214e, 0x214e,
+        0x2160, 0x2188,
+        0x24b6, 0x24e9,
+        0x2c00, 0x2c2e,
+        0x2c30, 0x2c5e,
+        0x2c60, 0x2ce4,
+        0x2ceb, 0x2cee,
+        0x2d00, 0x2d25,
+        0x2d30, 0x2d65,
+        0x2d6f, 0x2d6f,
+        0x2d80, 0x2d96,
+        0x2da0, 0x2da6,
+        0x2da8, 0x2dae,
+        0x2db0, 0x2db6,
+        0x2db8, 0x2dbe,
+        0x2dc0, 0x2dc6,
+        0x2dc8, 0x2dce,
+        0x2dd0, 0x2dd6,
+        0x2dd8, 0x2dde,
+        0x2de0, 0x2dff,
+        0x2e2f, 0x2e2f,
+        0x3005, 0x3007,
+        0x3021, 0x3029,
+        0x3031, 0x3035,
+        0x3038, 0x303c,
+        0x3041, 0x3096,
+        0x309d, 0x309f,
+        0x30a1, 0x30fa,
+        0x30fc, 0x30ff,
+        0x3105, 0x312d,
+        0x3131, 0x318e,
+        0x31a0, 0x31b7,
+        0x31f0, 0x31ff,
+        0x3400, 0x4db5,
+        0x4e00, 0x9fcb,
+        0xa000, 0xa48c,
+        0xa4d0, 0xa4fd,
+        0xa500, 0xa60c,
+        0xa610, 0xa61f,
+        0xa62a, 0xa62b,
+        0xa640, 0xa65f,
+        0xa662, 0xa66e,
+        0xa67f, 0xa697,
+        0xa6a0, 0xa6ef,
+        0xa717, 0xa71f,
+        0xa722, 0xa788,
+        0xa78b, 0xa78c,
+        0xa7fb, 0xa801,
+        0xa803, 0xa805,
+        0xa807, 0xa80a,
+        0xa80c, 0xa827,
+        0xa840, 0xa873,
+        0xa880, 0xa8c3,
+        0xa8f2, 0xa8f7,
+        0xa8fb, 0xa8fb,
+        0xa90a, 0xa92a,
+        0xa930, 0xa952,
+        0xa960, 0xa97c,
+        0xa980, 0xa9bf,
+        0xa9cf, 0xa9cf,
+        0xaa00, 0xaa36,
+        0xaa40, 0xaa4d,
+        0xaa60, 0xaa76,
+        0xaa7a, 0xaa7a,
+        0xaa80, 0xaabe,
+        0xaac0, 0xaac0,
+        0xaac2, 0xaac2,
+        0xaadb, 0xaadd,
+        0xabc0, 0xabea,
+        0xac00, 0xd7a3,
+        0xd7b0, 0xd7c6,
+        0xd7cb, 0xd7fb,
+        0xf900, 0xfa2d,
+        0xfa30, 0xfa6d,
+        0xfa70, 0xfad9,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xfb1d, 0xfb28,
+        0xfb2a, 0xfb36,
+        0xfb38, 0xfb3c,
+        0xfb3e, 0xfb3e,
+        0xfb40, 0xfb41,
+        0xfb43, 0xfb44,
+        0xfb46, 0xfbb1,
+        0xfbd3, 0xfd3d,
+        0xfd50, 0xfd8f,
+        0xfd92, 0xfdc7,
+        0xfdf0, 0xfdfb,
+        0xfe70, 0xfe74,
+        0xfe76, 0xfefc,
+        0xff21, 0xff3a,
+        0xff41, 0xff5a,
+        0xff66, 0xffbe,
+        0xffc2, 0xffc7,
+        0xffca, 0xffcf,
+        0xffd2, 0xffd7,
+        0xffda, 0xffdc,
+        0x10000, 0x1000b,
+        0x1000d, 0x10026,
+        0x10028, 0x1003a,
+        0x1003c, 0x1003d,
+        0x1003f, 0x1004d,
+        0x10050, 0x1005d,
+        0x10080, 0x100fa,
+        0x10140, 0x10174,
+        0x10280, 0x1029c,
+        0x102a0, 0x102d0,
+        0x10300, 0x1031e,
+        0x10330, 0x1034a,
+        0x10380, 0x1039d,
+        0x103a0, 0x103c3,
+        0x103c8, 0x103cf,
+        0x103d1, 0x103d5,
+        0x10400, 0x1049d,
+        0x10800, 0x10805,
+        0x10808, 0x10808,
+        0x1080a, 0x10835,
+        0x10837, 0x10838,
+        0x1083c, 0x1083c,
+        0x1083f, 0x10855,
+        0x10900, 0x10915,
+        0x10920, 0x10939,
+        0x10a00, 0x10a03,
+        0x10a05, 0x10a06,
+        0x10a0c, 0x10a13,
+        0x10a15, 0x10a17,
+        0x10a19, 0x10a33,
+        0x10a60, 0x10a7c,
+        0x10b00, 0x10b35,
+        0x10b40, 0x10b55,
+        0x10b60, 0x10b72,
+        0x10c00, 0x10c48,
+        0x11082, 0x110b8,
+        0x12000, 0x1236e,
+        0x12400, 0x12462,
+        0x13000, 0x1342e,
+        0x1d400, 0x1d454,
+        0x1d456, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d51e, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d552, 0x1d6a5,
+        0x1d6a8, 0x1d6c0,
+        0x1d6c2, 0x1d6da,
+        0x1d6dc, 0x1d6fa,
+        0x1d6fc, 0x1d714,
+        0x1d716, 0x1d734,
+        0x1d736, 0x1d74e,
+        0x1d750, 0x1d76e,
+        0x1d770, 0x1d788,
+        0x1d78a, 0x1d7a8,
+        0x1d7aa, 0x1d7c2,
+        0x1d7c4, 0x1d7cb,
+        0x20000, 0x2a6d6,
+        0x2a700, 0x2b734,
+        0x2f800, 0x2fa1d,
 }; /* CR_Alphabetic */
 
 /* 'Lowercase': Derived Property */
 static const OnigCodePoint CR_Lowercase[] = {
-	602,
-	0x0061, 0x007a,
-	0x00aa, 0x00aa,
-	0x00b5, 0x00b5,
-	0x00ba, 0x00ba,
-	0x00df, 0x00f6,
-	0x00f8, 0x00ff,
-	0x0101, 0x0101,
-	0x0103, 0x0103,
-	0x0105, 0x0105,
-	0x0107, 0x0107,
-	0x0109, 0x0109,
-	0x010b, 0x010b,
-	0x010d, 0x010d,
-	0x010f, 0x010f,
-	0x0111, 0x0111,
-	0x0113, 0x0113,
-	0x0115, 0x0115,
-	0x0117, 0x0117,
-	0x0119, 0x0119,
-	0x011b, 0x011b,
-	0x011d, 0x011d,
-	0x011f, 0x011f,
-	0x0121, 0x0121,
-	0x0123, 0x0123,
-	0x0125, 0x0125,
-	0x0127, 0x0127,
-	0x0129, 0x0129,
-	0x012b, 0x012b,
-	0x012d, 0x012d,
-	0x012f, 0x012f,
-	0x0131, 0x0131,
-	0x0133, 0x0133,
-	0x0135, 0x0135,
-	0x0137, 0x0138,
-	0x013a, 0x013a,
-	0x013c, 0x013c,
-	0x013e, 0x013e,
-	0x0140, 0x0140,
-	0x0142, 0x0142,
-	0x0144, 0x0144,
-	0x0146, 0x0146,
-	0x0148, 0x0149,
-	0x014b, 0x014b,
-	0x014d, 0x014d,
-	0x014f, 0x014f,
-	0x0151, 0x0151,
-	0x0153, 0x0153,
-	0x0155, 0x0155,
-	0x0157, 0x0157,
-	0x0159, 0x0159,
-	0x015b, 0x015b,
-	0x015d, 0x015d,
-	0x015f, 0x015f,
-	0x0161, 0x0161,
-	0x0163, 0x0163,
-	0x0165, 0x0165,
-	0x0167, 0x0167,
-	0x0169, 0x0169,
-	0x016b, 0x016b,
-	0x016d, 0x016d,
-	0x016f, 0x016f,
-	0x0171, 0x0171,
-	0x0173, 0x0173,
-	0x0175, 0x0175,
-	0x0177, 0x0177,
-	0x017a, 0x017a,
-	0x017c, 0x017c,
-	0x017e, 0x0180,
-	0x0183, 0x0183,
-	0x0185, 0x0185,
-	0x0188, 0x0188,
-	0x018c, 0x018d,
-	0x0192, 0x0192,
-	0x0195, 0x0195,
-	0x0199, 0x019b,
-	0x019e, 0x019e,
-	0x01a1, 0x01a1,
-	0x01a3, 0x01a3,
-	0x01a5, 0x01a5,
-	0x01a8, 0x01a8,
-	0x01aa, 0x01ab,
-	0x01ad, 0x01ad,
-	0x01b0, 0x01b0,
-	0x01b4, 0x01b4,
-	0x01b6, 0x01b6,
-	0x01b9, 0x01ba,
-	0x01bd, 0x01bf,
-	0x01c6, 0x01c6,
-	0x01c9, 0x01c9,
-	0x01cc, 0x01cc,
-	0x01ce, 0x01ce,
-	0x01d0, 0x01d0,
-	0x01d2, 0x01d2,
-	0x01d4, 0x01d4,
-	0x01d6, 0x01d6,
-	0x01d8, 0x01d8,
-	0x01da, 0x01da,
-	0x01dc, 0x01dd,
-	0x01df, 0x01df,
-	0x01e1, 0x01e1,
-	0x01e3, 0x01e3,
-	0x01e5, 0x01e5,
-	0x01e7, 0x01e7,
-	0x01e9, 0x01e9,
-	0x01eb, 0x01eb,
-	0x01ed, 0x01ed,
-	0x01ef, 0x01f0,
-	0x01f3, 0x01f3,
-	0x01f5, 0x01f5,
-	0x01f9, 0x01f9,
-	0x01fb, 0x01fb,
-	0x01fd, 0x01fd,
-	0x01ff, 0x01ff,
-	0x0201, 0x0201,
-	0x0203, 0x0203,
-	0x0205, 0x0205,
-	0x0207, 0x0207,
-	0x0209, 0x0209,
-	0x020b, 0x020b,
-	0x020d, 0x020d,
-	0x020f, 0x020f,
-	0x0211, 0x0211,
-	0x0213, 0x0213,
-	0x0215, 0x0215,
-	0x0217, 0x0217,
-	0x0219, 0x0219,
-	0x021b, 0x021b,
-	0x021d, 0x021d,
-	0x021f, 0x021f,
-	0x0221, 0x0221,
-	0x0223, 0x0223,
-	0x0225, 0x0225,
-	0x0227, 0x0227,
-	0x0229, 0x0229,
-	0x022b, 0x022b,
-	0x022d, 0x022d,
-	0x022f, 0x022f,
-	0x0231, 0x0231,
-	0x0233, 0x0239,
-	0x023c, 0x023c,
-	0x023f, 0x0240,
-	0x0242, 0x0242,
-	0x0247, 0x0247,
-	0x0249, 0x0249,
-	0x024b, 0x024b,
-	0x024d, 0x024d,
-	0x024f, 0x0293,
-	0x0295, 0x02b8,
-	0x02c0, 0x02c1,
-	0x02e0, 0x02e4,
-	0x0345, 0x0345,
-	0x0371, 0x0371,
-	0x0373, 0x0373,
-	0x0377, 0x0377,
-	0x037a, 0x037d,
-	0x0390, 0x0390,
-	0x03ac, 0x03ce,
-	0x03d0, 0x03d1,
-	0x03d5, 0x03d7,
-	0x03d9, 0x03d9,
-	0x03db, 0x03db,
-	0x03dd, 0x03dd,
-	0x03df, 0x03df,
-	0x03e1, 0x03e1,
-	0x03e3, 0x03e3,
-	0x03e5, 0x03e5,
-	0x03e7, 0x03e7,
-	0x03e9, 0x03e9,
-	0x03eb, 0x03eb,
-	0x03ed, 0x03ed,
-	0x03ef, 0x03f3,
-	0x03f5, 0x03f5,
-	0x03f8, 0x03f8,
-	0x03fb, 0x03fc,
-	0x0430, 0x045f,
-	0x0461, 0x0461,
-	0x0463, 0x0463,
-	0x0465, 0x0465,
-	0x0467, 0x0467,
-	0x0469, 0x0469,
-	0x046b, 0x046b,
-	0x046d, 0x046d,
-	0x046f, 0x046f,
-	0x0471, 0x0471,
-	0x0473, 0x0473,
-	0x0475, 0x0475,
-	0x0477, 0x0477,
-	0x0479, 0x0479,
-	0x047b, 0x047b,
-	0x047d, 0x047d,
-	0x047f, 0x047f,
-	0x0481, 0x0481,
-	0x048b, 0x048b,
-	0x048d, 0x048d,
-	0x048f, 0x048f,
-	0x0491, 0x0491,
-	0x0493, 0x0493,
-	0x0495, 0x0495,
-	0x0497, 0x0497,
-	0x0499, 0x0499,
-	0x049b, 0x049b,
-	0x049d, 0x049d,
-	0x049f, 0x049f,
-	0x04a1, 0x04a1,
-	0x04a3, 0x04a3,
-	0x04a5, 0x04a5,
-	0x04a7, 0x04a7,
-	0x04a9, 0x04a9,
-	0x04ab, 0x04ab,
-	0x04ad, 0x04ad,
-	0x04af, 0x04af,
-	0x04b1, 0x04b1,
-	0x04b3, 0x04b3,
-	0x04b5, 0x04b5,
-	0x04b7, 0x04b7,
-	0x04b9, 0x04b9,
-	0x04bb, 0x04bb,
-	0x04bd, 0x04bd,
-	0x04bf, 0x04bf,
-	0x04c2, 0x04c2,
-	0x04c4, 0x04c4,
-	0x04c6, 0x04c6,
-	0x04c8, 0x04c8,
-	0x04ca, 0x04ca,
-	0x04cc, 0x04cc,
-	0x04ce, 0x04cf,
-	0x04d1, 0x04d1,
-	0x04d3, 0x04d3,
-	0x04d5, 0x04d5,
-	0x04d7, 0x04d7,
-	0x04d9, 0x04d9,
-	0x04db, 0x04db,
-	0x04dd, 0x04dd,
-	0x04df, 0x04df,
-	0x04e1, 0x04e1,
-	0x04e3, 0x04e3,
-	0x04e5, 0x04e5,
-	0x04e7, 0x04e7,
-	0x04e9, 0x04e9,
-	0x04eb, 0x04eb,
-	0x04ed, 0x04ed,
-	0x04ef, 0x04ef,
-	0x04f1, 0x04f1,
-	0x04f3, 0x04f3,
-	0x04f5, 0x04f5,
-	0x04f7, 0x04f7,
-	0x04f9, 0x04f9,
-	0x04fb, 0x04fb,
-	0x04fd, 0x04fd,
-	0x04ff, 0x04ff,
-	0x0501, 0x0501,
-	0x0503, 0x0503,
-	0x0505, 0x0505,
-	0x0507, 0x0507,
-	0x0509, 0x0509,
-	0x050b, 0x050b,
-	0x050d, 0x050d,
-	0x050f, 0x050f,
-	0x0511, 0x0511,
-	0x0513, 0x0513,
-	0x0515, 0x0515,
-	0x0517, 0x0517,
-	0x0519, 0x0519,
-	0x051b, 0x051b,
-	0x051d, 0x051d,
-	0x051f, 0x051f,
-	0x0521, 0x0521,
-	0x0523, 0x0523,
-	0x0525, 0x0525,
-	0x0561, 0x0587,
-	0x1d00, 0x1dbf,
-	0x1e01, 0x1e01,
-	0x1e03, 0x1e03,
-	0x1e05, 0x1e05,
-	0x1e07, 0x1e07,
-	0x1e09, 0x1e09,
-	0x1e0b, 0x1e0b,
-	0x1e0d, 0x1e0d,
-	0x1e0f, 0x1e0f,
-	0x1e11, 0x1e11,
-	0x1e13, 0x1e13,
-	0x1e15, 0x1e15,
-	0x1e17, 0x1e17,
-	0x1e19, 0x1e19,
-	0x1e1b, 0x1e1b,
-	0x1e1d, 0x1e1d,
-	0x1e1f, 0x1e1f,
-	0x1e21, 0x1e21,
-	0x1e23, 0x1e23,
-	0x1e25, 0x1e25,
-	0x1e27, 0x1e27,
-	0x1e29, 0x1e29,
-	0x1e2b, 0x1e2b,
-	0x1e2d, 0x1e2d,
-	0x1e2f, 0x1e2f,
-	0x1e31, 0x1e31,
-	0x1e33, 0x1e33,
-	0x1e35, 0x1e35,
-	0x1e37, 0x1e37,
-	0x1e39, 0x1e39,
-	0x1e3b, 0x1e3b,
-	0x1e3d, 0x1e3d,
-	0x1e3f, 0x1e3f,
-	0x1e41, 0x1e41,
-	0x1e43, 0x1e43,
-	0x1e45, 0x1e45,
-	0x1e47, 0x1e47,
-	0x1e49, 0x1e49,
-	0x1e4b, 0x1e4b,
-	0x1e4d, 0x1e4d,
-	0x1e4f, 0x1e4f,
-	0x1e51, 0x1e51,
-	0x1e53, 0x1e53,
-	0x1e55, 0x1e55,
-	0x1e57, 0x1e57,
-	0x1e59, 0x1e59,
-	0x1e5b, 0x1e5b,
-	0x1e5d, 0x1e5d,
-	0x1e5f, 0x1e5f,
-	0x1e61, 0x1e61,
-	0x1e63, 0x1e63,
-	0x1e65, 0x1e65,
-	0x1e67, 0x1e67,
-	0x1e69, 0x1e69,
-	0x1e6b, 0x1e6b,
-	0x1e6d, 0x1e6d,
-	0x1e6f, 0x1e6f,
-	0x1e71, 0x1e71,
-	0x1e73, 0x1e73,
-	0x1e75, 0x1e75,
-	0x1e77, 0x1e77,
-	0x1e79, 0x1e79,
-	0x1e7b, 0x1e7b,
-	0x1e7d, 0x1e7d,
-	0x1e7f, 0x1e7f,
-	0x1e81, 0x1e81,
-	0x1e83, 0x1e83,
-	0x1e85, 0x1e85,
-	0x1e87, 0x1e87,
-	0x1e89, 0x1e89,
-	0x1e8b, 0x1e8b,
-	0x1e8d, 0x1e8d,
-	0x1e8f, 0x1e8f,
-	0x1e91, 0x1e91,
-	0x1e93, 0x1e93,
-	0x1e95, 0x1e9d,
-	0x1e9f, 0x1e9f,
-	0x1ea1, 0x1ea1,
-	0x1ea3, 0x1ea3,
-	0x1ea5, 0x1ea5,
-	0x1ea7, 0x1ea7,
-	0x1ea9, 0x1ea9,
-	0x1eab, 0x1eab,
-	0x1ead, 0x1ead,
-	0x1eaf, 0x1eaf,
-	0x1eb1, 0x1eb1,
-	0x1eb3, 0x1eb3,
-	0x1eb5, 0x1eb5,
-	0x1eb7, 0x1eb7,
-	0x1eb9, 0x1eb9,
-	0x1ebb, 0x1ebb,
-	0x1ebd, 0x1ebd,
-	0x1ebf, 0x1ebf,
-	0x1ec1, 0x1ec1,
-	0x1ec3, 0x1ec3,
-	0x1ec5, 0x1ec5,
-	0x1ec7, 0x1ec7,
-	0x1ec9, 0x1ec9,
-	0x1ecb, 0x1ecb,
-	0x1ecd, 0x1ecd,
-	0x1ecf, 0x1ecf,
-	0x1ed1, 0x1ed1,
-	0x1ed3, 0x1ed3,
-	0x1ed5, 0x1ed5,
-	0x1ed7, 0x1ed7,
-	0x1ed9, 0x1ed9,
-	0x1edb, 0x1edb,
-	0x1edd, 0x1edd,
-	0x1edf, 0x1edf,
-	0x1ee1, 0x1ee1,
-	0x1ee3, 0x1ee3,
-	0x1ee5, 0x1ee5,
-	0x1ee7, 0x1ee7,
-	0x1ee9, 0x1ee9,
-	0x1eeb, 0x1eeb,
-	0x1eed, 0x1eed,
-	0x1eef, 0x1eef,
-	0x1ef1, 0x1ef1,
-	0x1ef3, 0x1ef3,
-	0x1ef5, 0x1ef5,
-	0x1ef7, 0x1ef7,
-	0x1ef9, 0x1ef9,
-	0x1efb, 0x1efb,
-	0x1efd, 0x1efd,
-	0x1eff, 0x1f07,
-	0x1f10, 0x1f15,
-	0x1f20, 0x1f27,
-	0x1f30, 0x1f37,
-	0x1f40, 0x1f45,
-	0x1f50, 0x1f57,
-	0x1f60, 0x1f67,
-	0x1f70, 0x1f7d,
-	0x1f80, 0x1f87,
-	0x1f90, 0x1f97,
-	0x1fa0, 0x1fa7,
-	0x1fb0, 0x1fb4,
-	0x1fb6, 0x1fb7,
-	0x1fbe, 0x1fbe,
-	0x1fc2, 0x1fc4,
-	0x1fc6, 0x1fc7,
-	0x1fd0, 0x1fd3,
-	0x1fd6, 0x1fd7,
-	0x1fe0, 0x1fe7,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ff7,
-	0x2090, 0x2094,
-	0x210a, 0x210a,
-	0x210e, 0x210f,
-	0x2113, 0x2113,
-	0x212f, 0x212f,
-	0x2134, 0x2134,
-	0x2139, 0x2139,
-	0x213c, 0x213d,
-	0x2146, 0x2149,
-	0x214e, 0x214e,
-	0x2170, 0x217f,
-	0x2184, 0x2184,
-	0x24d0, 0x24e9,
-	0x2c30, 0x2c5e,
-	0x2c61, 0x2c61,
-	0x2c65, 0x2c66,
-	0x2c68, 0x2c68,
-	0x2c6a, 0x2c6a,
-	0x2c6c, 0x2c6c,
-	0x2c71, 0x2c71,
-	0x2c73, 0x2c74,
-	0x2c76, 0x2c7d,
-	0x2c81, 0x2c81,
-	0x2c83, 0x2c83,
-	0x2c85, 0x2c85,
-	0x2c87, 0x2c87,
-	0x2c89, 0x2c89,
-	0x2c8b, 0x2c8b,
-	0x2c8d, 0x2c8d,
-	0x2c8f, 0x2c8f,
-	0x2c91, 0x2c91,
-	0x2c93, 0x2c93,
-	0x2c95, 0x2c95,
-	0x2c97, 0x2c97,
-	0x2c99, 0x2c99,
-	0x2c9b, 0x2c9b,
-	0x2c9d, 0x2c9d,
-	0x2c9f, 0x2c9f,
-	0x2ca1, 0x2ca1,
-	0x2ca3, 0x2ca3,
-	0x2ca5, 0x2ca5,
-	0x2ca7, 0x2ca7,
-	0x2ca9, 0x2ca9,
-	0x2cab, 0x2cab,
-	0x2cad, 0x2cad,
-	0x2caf, 0x2caf,
-	0x2cb1, 0x2cb1,
-	0x2cb3, 0x2cb3,
-	0x2cb5, 0x2cb5,
-	0x2cb7, 0x2cb7,
-	0x2cb9, 0x2cb9,
-	0x2cbb, 0x2cbb,
-	0x2cbd, 0x2cbd,
-	0x2cbf, 0x2cbf,
-	0x2cc1, 0x2cc1,
-	0x2cc3, 0x2cc3,
-	0x2cc5, 0x2cc5,
-	0x2cc7, 0x2cc7,
-	0x2cc9, 0x2cc9,
-	0x2ccb, 0x2ccb,
-	0x2ccd, 0x2ccd,
-	0x2ccf, 0x2ccf,
-	0x2cd1, 0x2cd1,
-	0x2cd3, 0x2cd3,
-	0x2cd5, 0x2cd5,
-	0x2cd7, 0x2cd7,
-	0x2cd9, 0x2cd9,
-	0x2cdb, 0x2cdb,
-	0x2cdd, 0x2cdd,
-	0x2cdf, 0x2cdf,
-	0x2ce1, 0x2ce1,
-	0x2ce3, 0x2ce4,
-	0x2cec, 0x2cec,
-	0x2cee, 0x2cee,
-	0x2d00, 0x2d25,
-	0xa641, 0xa641,
-	0xa643, 0xa643,
-	0xa645, 0xa645,
-	0xa647, 0xa647,
-	0xa649, 0xa649,
-	0xa64b, 0xa64b,
-	0xa64d, 0xa64d,
-	0xa64f, 0xa64f,
-	0xa651, 0xa651,
-	0xa653, 0xa653,
-	0xa655, 0xa655,
-	0xa657, 0xa657,
-	0xa659, 0xa659,
-	0xa65b, 0xa65b,
-	0xa65d, 0xa65d,
-	0xa65f, 0xa65f,
-	0xa663, 0xa663,
-	0xa665, 0xa665,
-	0xa667, 0xa667,
-	0xa669, 0xa669,
-	0xa66b, 0xa66b,
-	0xa66d, 0xa66d,
-	0xa681, 0xa681,
-	0xa683, 0xa683,
-	0xa685, 0xa685,
-	0xa687, 0xa687,
-	0xa689, 0xa689,
-	0xa68b, 0xa68b,
-	0xa68d, 0xa68d,
-	0xa68f, 0xa68f,
-	0xa691, 0xa691,
-	0xa693, 0xa693,
-	0xa695, 0xa695,
-	0xa697, 0xa697,
-	0xa723, 0xa723,
-	0xa725, 0xa725,
-	0xa727, 0xa727,
-	0xa729, 0xa729,
-	0xa72b, 0xa72b,
-	0xa72d, 0xa72d,
-	0xa72f, 0xa731,
-	0xa733, 0xa733,
-	0xa735, 0xa735,
-	0xa737, 0xa737,
-	0xa739, 0xa739,
-	0xa73b, 0xa73b,
-	0xa73d, 0xa73d,
-	0xa73f, 0xa73f,
-	0xa741, 0xa741,
-	0xa743, 0xa743,
-	0xa745, 0xa745,
-	0xa747, 0xa747,
-	0xa749, 0xa749,
-	0xa74b, 0xa74b,
-	0xa74d, 0xa74d,
-	0xa74f, 0xa74f,
-	0xa751, 0xa751,
-	0xa753, 0xa753,
-	0xa755, 0xa755,
-	0xa757, 0xa757,
-	0xa759, 0xa759,
-	0xa75b, 0xa75b,
-	0xa75d, 0xa75d,
-	0xa75f, 0xa75f,
-	0xa761, 0xa761,
-	0xa763, 0xa763,
-	0xa765, 0xa765,
-	0xa767, 0xa767,
-	0xa769, 0xa769,
-	0xa76b, 0xa76b,
-	0xa76d, 0xa76d,
-	0xa76f, 0xa778,
-	0xa77a, 0xa77a,
-	0xa77c, 0xa77c,
-	0xa77f, 0xa77f,
-	0xa781, 0xa781,
-	0xa783, 0xa783,
-	0xa785, 0xa785,
-	0xa787, 0xa787,
-	0xa78c, 0xa78c,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xff41, 0xff5a,
-	0x10428, 0x1044f,
-	0x1d41a, 0x1d433,
-	0x1d44e, 0x1d454,
-	0x1d456, 0x1d467,
-	0x1d482, 0x1d49b,
-	0x1d4b6, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d4cf,
-	0x1d4ea, 0x1d503,
-	0x1d51e, 0x1d537,
-	0x1d552, 0x1d56b,
-	0x1d586, 0x1d59f,
-	0x1d5ba, 0x1d5d3,
-	0x1d5ee, 0x1d607,
-	0x1d622, 0x1d63b,
-	0x1d656, 0x1d66f,
-	0x1d68a, 0x1d6a5,
-	0x1d6c2, 0x1d6da,
-	0x1d6dc, 0x1d6e1,
-	0x1d6fc, 0x1d714,
-	0x1d716, 0x1d71b,
-	0x1d736, 0x1d74e,
-	0x1d750, 0x1d755,
-	0x1d770, 0x1d788,
-	0x1d78a, 0x1d78f,
-	0x1d7aa, 0x1d7c2,
-	0x1d7c4, 0x1d7c9,
-	0x1d7cb, 0x1d7cb,
+        602,
+        0x0061, 0x007a,
+        0x00aa, 0x00aa,
+        0x00b5, 0x00b5,
+        0x00ba, 0x00ba,
+        0x00df, 0x00f6,
+        0x00f8, 0x00ff,
+        0x0101, 0x0101,
+        0x0103, 0x0103,
+        0x0105, 0x0105,
+        0x0107, 0x0107,
+        0x0109, 0x0109,
+        0x010b, 0x010b,
+        0x010d, 0x010d,
+        0x010f, 0x010f,
+        0x0111, 0x0111,
+        0x0113, 0x0113,
+        0x0115, 0x0115,
+        0x0117, 0x0117,
+        0x0119, 0x0119,
+        0x011b, 0x011b,
+        0x011d, 0x011d,
+        0x011f, 0x011f,
+        0x0121, 0x0121,
+        0x0123, 0x0123,
+        0x0125, 0x0125,
+        0x0127, 0x0127,
+        0x0129, 0x0129,
+        0x012b, 0x012b,
+        0x012d, 0x012d,
+        0x012f, 0x012f,
+        0x0131, 0x0131,
+        0x0133, 0x0133,
+        0x0135, 0x0135,
+        0x0137, 0x0138,
+        0x013a, 0x013a,
+        0x013c, 0x013c,
+        0x013e, 0x013e,
+        0x0140, 0x0140,
+        0x0142, 0x0142,
+        0x0144, 0x0144,
+        0x0146, 0x0146,
+        0x0148, 0x0149,
+        0x014b, 0x014b,
+        0x014d, 0x014d,
+        0x014f, 0x014f,
+        0x0151, 0x0151,
+        0x0153, 0x0153,
+        0x0155, 0x0155,
+        0x0157, 0x0157,
+        0x0159, 0x0159,
+        0x015b, 0x015b,
+        0x015d, 0x015d,
+        0x015f, 0x015f,
+        0x0161, 0x0161,
+        0x0163, 0x0163,
+        0x0165, 0x0165,
+        0x0167, 0x0167,
+        0x0169, 0x0169,
+        0x016b, 0x016b,
+        0x016d, 0x016d,
+        0x016f, 0x016f,
+        0x0171, 0x0171,
+        0x0173, 0x0173,
+        0x0175, 0x0175,
+        0x0177, 0x0177,
+        0x017a, 0x017a,
+        0x017c, 0x017c,
+        0x017e, 0x0180,
+        0x0183, 0x0183,
+        0x0185, 0x0185,
+        0x0188, 0x0188,
+        0x018c, 0x018d,
+        0x0192, 0x0192,
+        0x0195, 0x0195,
+        0x0199, 0x019b,
+        0x019e, 0x019e,
+        0x01a1, 0x01a1,
+        0x01a3, 0x01a3,
+        0x01a5, 0x01a5,
+        0x01a8, 0x01a8,
+        0x01aa, 0x01ab,
+        0x01ad, 0x01ad,
+        0x01b0, 0x01b0,
+        0x01b4, 0x01b4,
+        0x01b6, 0x01b6,
+        0x01b9, 0x01ba,
+        0x01bd, 0x01bf,
+        0x01c6, 0x01c6,
+        0x01c9, 0x01c9,
+        0x01cc, 0x01cc,
+        0x01ce, 0x01ce,
+        0x01d0, 0x01d0,
+        0x01d2, 0x01d2,
+        0x01d4, 0x01d4,
+        0x01d6, 0x01d6,
+        0x01d8, 0x01d8,
+        0x01da, 0x01da,
+        0x01dc, 0x01dd,
+        0x01df, 0x01df,
+        0x01e1, 0x01e1,
+        0x01e3, 0x01e3,
+        0x01e5, 0x01e5,
+        0x01e7, 0x01e7,
+        0x01e9, 0x01e9,
+        0x01eb, 0x01eb,
+        0x01ed, 0x01ed,
+        0x01ef, 0x01f0,
+        0x01f3, 0x01f3,
+        0x01f5, 0x01f5,
+        0x01f9, 0x01f9,
+        0x01fb, 0x01fb,
+        0x01fd, 0x01fd,
+        0x01ff, 0x01ff,
+        0x0201, 0x0201,
+        0x0203, 0x0203,
+        0x0205, 0x0205,
+        0x0207, 0x0207,
+        0x0209, 0x0209,
+        0x020b, 0x020b,
+        0x020d, 0x020d,
+        0x020f, 0x020f,
+        0x0211, 0x0211,
+        0x0213, 0x0213,
+        0x0215, 0x0215,
+        0x0217, 0x0217,
+        0x0219, 0x0219,
+        0x021b, 0x021b,
+        0x021d, 0x021d,
+        0x021f, 0x021f,
+        0x0221, 0x0221,
+        0x0223, 0x0223,
+        0x0225, 0x0225,
+        0x0227, 0x0227,
+        0x0229, 0x0229,
+        0x022b, 0x022b,
+        0x022d, 0x022d,
+        0x022f, 0x022f,
+        0x0231, 0x0231,
+        0x0233, 0x0239,
+        0x023c, 0x023c,
+        0x023f, 0x0240,
+        0x0242, 0x0242,
+        0x0247, 0x0247,
+        0x0249, 0x0249,
+        0x024b, 0x024b,
+        0x024d, 0x024d,
+        0x024f, 0x0293,
+        0x0295, 0x02b8,
+        0x02c0, 0x02c1,
+        0x02e0, 0x02e4,
+        0x0345, 0x0345,
+        0x0371, 0x0371,
+        0x0373, 0x0373,
+        0x0377, 0x0377,
+        0x037a, 0x037d,
+        0x0390, 0x0390,
+        0x03ac, 0x03ce,
+        0x03d0, 0x03d1,
+        0x03d5, 0x03d7,
+        0x03d9, 0x03d9,
+        0x03db, 0x03db,
+        0x03dd, 0x03dd,
+        0x03df, 0x03df,
+        0x03e1, 0x03e1,
+        0x03e3, 0x03e3,
+        0x03e5, 0x03e5,
+        0x03e7, 0x03e7,
+        0x03e9, 0x03e9,
+        0x03eb, 0x03eb,
+        0x03ed, 0x03ed,
+        0x03ef, 0x03f3,
+        0x03f5, 0x03f5,
+        0x03f8, 0x03f8,
+        0x03fb, 0x03fc,
+        0x0430, 0x045f,
+        0x0461, 0x0461,
+        0x0463, 0x0463,
+        0x0465, 0x0465,
+        0x0467, 0x0467,
+        0x0469, 0x0469,
+        0x046b, 0x046b,
+        0x046d, 0x046d,
+        0x046f, 0x046f,
+        0x0471, 0x0471,
+        0x0473, 0x0473,
+        0x0475, 0x0475,
+        0x0477, 0x0477,
+        0x0479, 0x0479,
+        0x047b, 0x047b,
+        0x047d, 0x047d,
+        0x047f, 0x047f,
+        0x0481, 0x0481,
+        0x048b, 0x048b,
+        0x048d, 0x048d,
+        0x048f, 0x048f,
+        0x0491, 0x0491,
+        0x0493, 0x0493,
+        0x0495, 0x0495,
+        0x0497, 0x0497,
+        0x0499, 0x0499,
+        0x049b, 0x049b,
+        0x049d, 0x049d,
+        0x049f, 0x049f,
+        0x04a1, 0x04a1,
+        0x04a3, 0x04a3,
+        0x04a5, 0x04a5,
+        0x04a7, 0x04a7,
+        0x04a9, 0x04a9,
+        0x04ab, 0x04ab,
+        0x04ad, 0x04ad,
+        0x04af, 0x04af,
+        0x04b1, 0x04b1,
+        0x04b3, 0x04b3,
+        0x04b5, 0x04b5,
+        0x04b7, 0x04b7,
+        0x04b9, 0x04b9,
+        0x04bb, 0x04bb,
+        0x04bd, 0x04bd,
+        0x04bf, 0x04bf,
+        0x04c2, 0x04c2,
+        0x04c4, 0x04c4,
+        0x04c6, 0x04c6,
+        0x04c8, 0x04c8,
+        0x04ca, 0x04ca,
+        0x04cc, 0x04cc,
+        0x04ce, 0x04cf,
+        0x04d1, 0x04d1,
+        0x04d3, 0x04d3,
+        0x04d5, 0x04d5,
+        0x04d7, 0x04d7,
+        0x04d9, 0x04d9,
+        0x04db, 0x04db,
+        0x04dd, 0x04dd,
+        0x04df, 0x04df,
+        0x04e1, 0x04e1,
+        0x04e3, 0x04e3,
+        0x04e5, 0x04e5,
+        0x04e7, 0x04e7,
+        0x04e9, 0x04e9,
+        0x04eb, 0x04eb,
+        0x04ed, 0x04ed,
+        0x04ef, 0x04ef,
+        0x04f1, 0x04f1,
+        0x04f3, 0x04f3,
+        0x04f5, 0x04f5,
+        0x04f7, 0x04f7,
+        0x04f9, 0x04f9,
+        0x04fb, 0x04fb,
+        0x04fd, 0x04fd,
+        0x04ff, 0x04ff,
+        0x0501, 0x0501,
+        0x0503, 0x0503,
+        0x0505, 0x0505,
+        0x0507, 0x0507,
+        0x0509, 0x0509,
+        0x050b, 0x050b,
+        0x050d, 0x050d,
+        0x050f, 0x050f,
+        0x0511, 0x0511,
+        0x0513, 0x0513,
+        0x0515, 0x0515,
+        0x0517, 0x0517,
+        0x0519, 0x0519,
+        0x051b, 0x051b,
+        0x051d, 0x051d,
+        0x051f, 0x051f,
+        0x0521, 0x0521,
+        0x0523, 0x0523,
+        0x0525, 0x0525,
+        0x0561, 0x0587,
+        0x1d00, 0x1dbf,
+        0x1e01, 0x1e01,
+        0x1e03, 0x1e03,
+        0x1e05, 0x1e05,
+        0x1e07, 0x1e07,
+        0x1e09, 0x1e09,
+        0x1e0b, 0x1e0b,
+        0x1e0d, 0x1e0d,
+        0x1e0f, 0x1e0f,
+        0x1e11, 0x1e11,
+        0x1e13, 0x1e13,
+        0x1e15, 0x1e15,
+        0x1e17, 0x1e17,
+        0x1e19, 0x1e19,
+        0x1e1b, 0x1e1b,
+        0x1e1d, 0x1e1d,
+        0x1e1f, 0x1e1f,
+        0x1e21, 0x1e21,
+        0x1e23, 0x1e23,
+        0x1e25, 0x1e25,
+        0x1e27, 0x1e27,
+        0x1e29, 0x1e29,
+        0x1e2b, 0x1e2b,
+        0x1e2d, 0x1e2d,
+        0x1e2f, 0x1e2f,
+        0x1e31, 0x1e31,
+        0x1e33, 0x1e33,
+        0x1e35, 0x1e35,
+        0x1e37, 0x1e37,
+        0x1e39, 0x1e39,
+        0x1e3b, 0x1e3b,
+        0x1e3d, 0x1e3d,
+        0x1e3f, 0x1e3f,
+        0x1e41, 0x1e41,
+        0x1e43, 0x1e43,
+        0x1e45, 0x1e45,
+        0x1e47, 0x1e47,
+        0x1e49, 0x1e49,
+        0x1e4b, 0x1e4b,
+        0x1e4d, 0x1e4d,
+        0x1e4f, 0x1e4f,
+        0x1e51, 0x1e51,
+        0x1e53, 0x1e53,
+        0x1e55, 0x1e55,
+        0x1e57, 0x1e57,
+        0x1e59, 0x1e59,
+        0x1e5b, 0x1e5b,
+        0x1e5d, 0x1e5d,
+        0x1e5f, 0x1e5f,
+        0x1e61, 0x1e61,
+        0x1e63, 0x1e63,
+        0x1e65, 0x1e65,
+        0x1e67, 0x1e67,
+        0x1e69, 0x1e69,
+        0x1e6b, 0x1e6b,
+        0x1e6d, 0x1e6d,
+        0x1e6f, 0x1e6f,
+        0x1e71, 0x1e71,
+        0x1e73, 0x1e73,
+        0x1e75, 0x1e75,
+        0x1e77, 0x1e77,
+        0x1e79, 0x1e79,
+        0x1e7b, 0x1e7b,
+        0x1e7d, 0x1e7d,
+        0x1e7f, 0x1e7f,
+        0x1e81, 0x1e81,
+        0x1e83, 0x1e83,
+        0x1e85, 0x1e85,
+        0x1e87, 0x1e87,
+        0x1e89, 0x1e89,
+        0x1e8b, 0x1e8b,
+        0x1e8d, 0x1e8d,
+        0x1e8f, 0x1e8f,
+        0x1e91, 0x1e91,
+        0x1e93, 0x1e93,
+        0x1e95, 0x1e9d,
+        0x1e9f, 0x1e9f,
+        0x1ea1, 0x1ea1,
+        0x1ea3, 0x1ea3,
+        0x1ea5, 0x1ea5,
+        0x1ea7, 0x1ea7,
+        0x1ea9, 0x1ea9,
+        0x1eab, 0x1eab,
+        0x1ead, 0x1ead,
+        0x1eaf, 0x1eaf,
+        0x1eb1, 0x1eb1,
+        0x1eb3, 0x1eb3,
+        0x1eb5, 0x1eb5,
+        0x1eb7, 0x1eb7,
+        0x1eb9, 0x1eb9,
+        0x1ebb, 0x1ebb,
+        0x1ebd, 0x1ebd,
+        0x1ebf, 0x1ebf,
+        0x1ec1, 0x1ec1,
+        0x1ec3, 0x1ec3,
+        0x1ec5, 0x1ec5,
+        0x1ec7, 0x1ec7,
+        0x1ec9, 0x1ec9,
+        0x1ecb, 0x1ecb,
+        0x1ecd, 0x1ecd,
+        0x1ecf, 0x1ecf,
+        0x1ed1, 0x1ed1,
+        0x1ed3, 0x1ed3,
+        0x1ed5, 0x1ed5,
+        0x1ed7, 0x1ed7,
+        0x1ed9, 0x1ed9,
+        0x1edb, 0x1edb,
+        0x1edd, 0x1edd,
+        0x1edf, 0x1edf,
+        0x1ee1, 0x1ee1,
+        0x1ee3, 0x1ee3,
+        0x1ee5, 0x1ee5,
+        0x1ee7, 0x1ee7,
+        0x1ee9, 0x1ee9,
+        0x1eeb, 0x1eeb,
+        0x1eed, 0x1eed,
+        0x1eef, 0x1eef,
+        0x1ef1, 0x1ef1,
+        0x1ef3, 0x1ef3,
+        0x1ef5, 0x1ef5,
+        0x1ef7, 0x1ef7,
+        0x1ef9, 0x1ef9,
+        0x1efb, 0x1efb,
+        0x1efd, 0x1efd,
+        0x1eff, 0x1f07,
+        0x1f10, 0x1f15,
+        0x1f20, 0x1f27,
+        0x1f30, 0x1f37,
+        0x1f40, 0x1f45,
+        0x1f50, 0x1f57,
+        0x1f60, 0x1f67,
+        0x1f70, 0x1f7d,
+        0x1f80, 0x1f87,
+        0x1f90, 0x1f97,
+        0x1fa0, 0x1fa7,
+        0x1fb0, 0x1fb4,
+        0x1fb6, 0x1fb7,
+        0x1fbe, 0x1fbe,
+        0x1fc2, 0x1fc4,
+        0x1fc6, 0x1fc7,
+        0x1fd0, 0x1fd3,
+        0x1fd6, 0x1fd7,
+        0x1fe0, 0x1fe7,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ff7,
+        0x2090, 0x2094,
+        0x210a, 0x210a,
+        0x210e, 0x210f,
+        0x2113, 0x2113,
+        0x212f, 0x212f,
+        0x2134, 0x2134,
+        0x2139, 0x2139,
+        0x213c, 0x213d,
+        0x2146, 0x2149,
+        0x214e, 0x214e,
+        0x2170, 0x217f,
+        0x2184, 0x2184,
+        0x24d0, 0x24e9,
+        0x2c30, 0x2c5e,
+        0x2c61, 0x2c61,
+        0x2c65, 0x2c66,
+        0x2c68, 0x2c68,
+        0x2c6a, 0x2c6a,
+        0x2c6c, 0x2c6c,
+        0x2c71, 0x2c71,
+        0x2c73, 0x2c74,
+        0x2c76, 0x2c7d,
+        0x2c81, 0x2c81,
+        0x2c83, 0x2c83,
+        0x2c85, 0x2c85,
+        0x2c87, 0x2c87,
+        0x2c89, 0x2c89,
+        0x2c8b, 0x2c8b,
+        0x2c8d, 0x2c8d,
+        0x2c8f, 0x2c8f,
+        0x2c91, 0x2c91,
+        0x2c93, 0x2c93,
+        0x2c95, 0x2c95,
+        0x2c97, 0x2c97,
+        0x2c99, 0x2c99,
+        0x2c9b, 0x2c9b,
+        0x2c9d, 0x2c9d,
+        0x2c9f, 0x2c9f,
+        0x2ca1, 0x2ca1,
+        0x2ca3, 0x2ca3,
+        0x2ca5, 0x2ca5,
+        0x2ca7, 0x2ca7,
+        0x2ca9, 0x2ca9,
+        0x2cab, 0x2cab,
+        0x2cad, 0x2cad,
+        0x2caf, 0x2caf,
+        0x2cb1, 0x2cb1,
+        0x2cb3, 0x2cb3,
+        0x2cb5, 0x2cb5,
+        0x2cb7, 0x2cb7,
+        0x2cb9, 0x2cb9,
+        0x2cbb, 0x2cbb,
+        0x2cbd, 0x2cbd,
+        0x2cbf, 0x2cbf,
+        0x2cc1, 0x2cc1,
+        0x2cc3, 0x2cc3,
+        0x2cc5, 0x2cc5,
+        0x2cc7, 0x2cc7,
+        0x2cc9, 0x2cc9,
+        0x2ccb, 0x2ccb,
+        0x2ccd, 0x2ccd,
+        0x2ccf, 0x2ccf,
+        0x2cd1, 0x2cd1,
+        0x2cd3, 0x2cd3,
+        0x2cd5, 0x2cd5,
+        0x2cd7, 0x2cd7,
+        0x2cd9, 0x2cd9,
+        0x2cdb, 0x2cdb,
+        0x2cdd, 0x2cdd,
+        0x2cdf, 0x2cdf,
+        0x2ce1, 0x2ce1,
+        0x2ce3, 0x2ce4,
+        0x2cec, 0x2cec,
+        0x2cee, 0x2cee,
+        0x2d00, 0x2d25,
+        0xa641, 0xa641,
+        0xa643, 0xa643,
+        0xa645, 0xa645,
+        0xa647, 0xa647,
+        0xa649, 0xa649,
+        0xa64b, 0xa64b,
+        0xa64d, 0xa64d,
+        0xa64f, 0xa64f,
+        0xa651, 0xa651,
+        0xa653, 0xa653,
+        0xa655, 0xa655,
+        0xa657, 0xa657,
+        0xa659, 0xa659,
+        0xa65b, 0xa65b,
+        0xa65d, 0xa65d,
+        0xa65f, 0xa65f,
+        0xa663, 0xa663,
+        0xa665, 0xa665,
+        0xa667, 0xa667,
+        0xa669, 0xa669,
+        0xa66b, 0xa66b,
+        0xa66d, 0xa66d,
+        0xa681, 0xa681,
+        0xa683, 0xa683,
+        0xa685, 0xa685,
+        0xa687, 0xa687,
+        0xa689, 0xa689,
+        0xa68b, 0xa68b,
+        0xa68d, 0xa68d,
+        0xa68f, 0xa68f,
+        0xa691, 0xa691,
+        0xa693, 0xa693,
+        0xa695, 0xa695,
+        0xa697, 0xa697,
+        0xa723, 0xa723,
+        0xa725, 0xa725,
+        0xa727, 0xa727,
+        0xa729, 0xa729,
+        0xa72b, 0xa72b,
+        0xa72d, 0xa72d,
+        0xa72f, 0xa731,
+        0xa733, 0xa733,
+        0xa735, 0xa735,
+        0xa737, 0xa737,
+        0xa739, 0xa739,
+        0xa73b, 0xa73b,
+        0xa73d, 0xa73d,
+        0xa73f, 0xa73f,
+        0xa741, 0xa741,
+        0xa743, 0xa743,
+        0xa745, 0xa745,
+        0xa747, 0xa747,
+        0xa749, 0xa749,
+        0xa74b, 0xa74b,
+        0xa74d, 0xa74d,
+        0xa74f, 0xa74f,
+        0xa751, 0xa751,
+        0xa753, 0xa753,
+        0xa755, 0xa755,
+        0xa757, 0xa757,
+        0xa759, 0xa759,
+        0xa75b, 0xa75b,
+        0xa75d, 0xa75d,
+        0xa75f, 0xa75f,
+        0xa761, 0xa761,
+        0xa763, 0xa763,
+        0xa765, 0xa765,
+        0xa767, 0xa767,
+        0xa769, 0xa769,
+        0xa76b, 0xa76b,
+        0xa76d, 0xa76d,
+        0xa76f, 0xa778,
+        0xa77a, 0xa77a,
+        0xa77c, 0xa77c,
+        0xa77f, 0xa77f,
+        0xa781, 0xa781,
+        0xa783, 0xa783,
+        0xa785, 0xa785,
+        0xa787, 0xa787,
+        0xa78c, 0xa78c,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xff41, 0xff5a,
+        0x10428, 0x1044f,
+        0x1d41a, 0x1d433,
+        0x1d44e, 0x1d454,
+        0x1d456, 0x1d467,
+        0x1d482, 0x1d49b,
+        0x1d4b6, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d4cf,
+        0x1d4ea, 0x1d503,
+        0x1d51e, 0x1d537,
+        0x1d552, 0x1d56b,
+        0x1d586, 0x1d59f,
+        0x1d5ba, 0x1d5d3,
+        0x1d5ee, 0x1d607,
+        0x1d622, 0x1d63b,
+        0x1d656, 0x1d66f,
+        0x1d68a, 0x1d6a5,
+        0x1d6c2, 0x1d6da,
+        0x1d6dc, 0x1d6e1,
+        0x1d6fc, 0x1d714,
+        0x1d716, 0x1d71b,
+        0x1d736, 0x1d74e,
+        0x1d750, 0x1d755,
+        0x1d770, 0x1d788,
+        0x1d78a, 0x1d78f,
+        0x1d7aa, 0x1d7c2,
+        0x1d7c4, 0x1d7c9,
+        0x1d7cb, 0x1d7cb,
 }; /* CR_Lowercase */
 
 /* 'Uppercase': Derived Property */
 static const OnigCodePoint CR_Uppercase[] = {
-	596,
-	0x0041, 0x005a,
-	0x00c0, 0x00d6,
-	0x00d8, 0x00de,
-	0x0100, 0x0100,
-	0x0102, 0x0102,
-	0x0104, 0x0104,
-	0x0106, 0x0106,
-	0x0108, 0x0108,
-	0x010a, 0x010a,
-	0x010c, 0x010c,
-	0x010e, 0x010e,
-	0x0110, 0x0110,
-	0x0112, 0x0112,
-	0x0114, 0x0114,
-	0x0116, 0x0116,
-	0x0118, 0x0118,
-	0x011a, 0x011a,
-	0x011c, 0x011c,
-	0x011e, 0x011e,
-	0x0120, 0x0120,
-	0x0122, 0x0122,
-	0x0124, 0x0124,
-	0x0126, 0x0126,
-	0x0128, 0x0128,
-	0x012a, 0x012a,
-	0x012c, 0x012c,
-	0x012e, 0x012e,
-	0x0130, 0x0130,
-	0x0132, 0x0132,
-	0x0134, 0x0134,
-	0x0136, 0x0136,
-	0x0139, 0x0139,
-	0x013b, 0x013b,
-	0x013d, 0x013d,
-	0x013f, 0x013f,
-	0x0141, 0x0141,
-	0x0143, 0x0143,
-	0x0145, 0x0145,
-	0x0147, 0x0147,
-	0x014a, 0x014a,
-	0x014c, 0x014c,
-	0x014e, 0x014e,
-	0x0150, 0x0150,
-	0x0152, 0x0152,
-	0x0154, 0x0154,
-	0x0156, 0x0156,
-	0x0158, 0x0158,
-	0x015a, 0x015a,
-	0x015c, 0x015c,
-	0x015e, 0x015e,
-	0x0160, 0x0160,
-	0x0162, 0x0162,
-	0x0164, 0x0164,
-	0x0166, 0x0166,
-	0x0168, 0x0168,
-	0x016a, 0x016a,
-	0x016c, 0x016c,
-	0x016e, 0x016e,
-	0x0170, 0x0170,
-	0x0172, 0x0172,
-	0x0174, 0x0174,
-	0x0176, 0x0176,
-	0x0178, 0x0179,
-	0x017b, 0x017b,
-	0x017d, 0x017d,
-	0x0181, 0x0182,
-	0x0184, 0x0184,
-	0x0186, 0x0187,
-	0x0189, 0x018b,
-	0x018e, 0x0191,
-	0x0193, 0x0194,
-	0x0196, 0x0198,
-	0x019c, 0x019d,
-	0x019f, 0x01a0,
-	0x01a2, 0x01a2,
-	0x01a4, 0x01a4,
-	0x01a6, 0x01a7,
-	0x01a9, 0x01a9,
-	0x01ac, 0x01ac,
-	0x01ae, 0x01af,
-	0x01b1, 0x01b3,
-	0x01b5, 0x01b5,
-	0x01b7, 0x01b8,
-	0x01bc, 0x01bc,
-	0x01c4, 0x01c4,
-	0x01c7, 0x01c7,
-	0x01ca, 0x01ca,
-	0x01cd, 0x01cd,
-	0x01cf, 0x01cf,
-	0x01d1, 0x01d1,
-	0x01d3, 0x01d3,
-	0x01d5, 0x01d5,
-	0x01d7, 0x01d7,
-	0x01d9, 0x01d9,
-	0x01db, 0x01db,
-	0x01de, 0x01de,
-	0x01e0, 0x01e0,
-	0x01e2, 0x01e2,
-	0x01e4, 0x01e4,
-	0x01e6, 0x01e6,
-	0x01e8, 0x01e8,
-	0x01ea, 0x01ea,
-	0x01ec, 0x01ec,
-	0x01ee, 0x01ee,
-	0x01f1, 0x01f1,
-	0x01f4, 0x01f4,
-	0x01f6, 0x01f8,
-	0x01fa, 0x01fa,
-	0x01fc, 0x01fc,
-	0x01fe, 0x01fe,
-	0x0200, 0x0200,
-	0x0202, 0x0202,
-	0x0204, 0x0204,
-	0x0206, 0x0206,
-	0x0208, 0x0208,
-	0x020a, 0x020a,
-	0x020c, 0x020c,
-	0x020e, 0x020e,
-	0x0210, 0x0210,
-	0x0212, 0x0212,
-	0x0214, 0x0214,
-	0x0216, 0x0216,
-	0x0218, 0x0218,
-	0x021a, 0x021a,
-	0x021c, 0x021c,
-	0x021e, 0x021e,
-	0x0220, 0x0220,
-	0x0222, 0x0222,
-	0x0224, 0x0224,
-	0x0226, 0x0226,
-	0x0228, 0x0228,
-	0x022a, 0x022a,
-	0x022c, 0x022c,
-	0x022e, 0x022e,
-	0x0230, 0x0230,
-	0x0232, 0x0232,
-	0x023a, 0x023b,
-	0x023d, 0x023e,
-	0x0241, 0x0241,
-	0x0243, 0x0246,
-	0x0248, 0x0248,
-	0x024a, 0x024a,
-	0x024c, 0x024c,
-	0x024e, 0x024e,
-	0x0370, 0x0370,
-	0x0372, 0x0372,
-	0x0376, 0x0376,
-	0x0386, 0x0386,
-	0x0388, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x038f,
-	0x0391, 0x03a1,
-	0x03a3, 0x03ab,
-	0x03cf, 0x03cf,
-	0x03d2, 0x03d4,
-	0x03d8, 0x03d8,
-	0x03da, 0x03da,
-	0x03dc, 0x03dc,
-	0x03de, 0x03de,
-	0x03e0, 0x03e0,
-	0x03e2, 0x03e2,
-	0x03e4, 0x03e4,
-	0x03e6, 0x03e6,
-	0x03e8, 0x03e8,
-	0x03ea, 0x03ea,
-	0x03ec, 0x03ec,
-	0x03ee, 0x03ee,
-	0x03f4, 0x03f4,
-	0x03f7, 0x03f7,
-	0x03f9, 0x03fa,
-	0x03fd, 0x042f,
-	0x0460, 0x0460,
-	0x0462, 0x0462,
-	0x0464, 0x0464,
-	0x0466, 0x0466,
-	0x0468, 0x0468,
-	0x046a, 0x046a,
-	0x046c, 0x046c,
-	0x046e, 0x046e,
-	0x0470, 0x0470,
-	0x0472, 0x0472,
-	0x0474, 0x0474,
-	0x0476, 0x0476,
-	0x0478, 0x0478,
-	0x047a, 0x047a,
-	0x047c, 0x047c,
-	0x047e, 0x047e,
-	0x0480, 0x0480,
-	0x048a, 0x048a,
-	0x048c, 0x048c,
-	0x048e, 0x048e,
-	0x0490, 0x0490,
-	0x0492, 0x0492,
-	0x0494, 0x0494,
-	0x0496, 0x0496,
-	0x0498, 0x0498,
-	0x049a, 0x049a,
-	0x049c, 0x049c,
-	0x049e, 0x049e,
-	0x04a0, 0x04a0,
-	0x04a2, 0x04a2,
-	0x04a4, 0x04a4,
-	0x04a6, 0x04a6,
-	0x04a8, 0x04a8,
-	0x04aa, 0x04aa,
-	0x04ac, 0x04ac,
-	0x04ae, 0x04ae,
-	0x04b0, 0x04b0,
-	0x04b2, 0x04b2,
-	0x04b4, 0x04b4,
-	0x04b6, 0x04b6,
-	0x04b8, 0x04b8,
-	0x04ba, 0x04ba,
-	0x04bc, 0x04bc,
-	0x04be, 0x04be,
-	0x04c0, 0x04c1,
-	0x04c3, 0x04c3,
-	0x04c5, 0x04c5,
-	0x04c7, 0x04c7,
-	0x04c9, 0x04c9,
-	0x04cb, 0x04cb,
-	0x04cd, 0x04cd,
-	0x04d0, 0x04d0,
-	0x04d2, 0x04d2,
-	0x04d4, 0x04d4,
-	0x04d6, 0x04d6,
-	0x04d8, 0x04d8,
-	0x04da, 0x04da,
-	0x04dc, 0x04dc,
-	0x04de, 0x04de,
-	0x04e0, 0x04e0,
-	0x04e2, 0x04e2,
-	0x04e4, 0x04e4,
-	0x04e6, 0x04e6,
-	0x04e8, 0x04e8,
-	0x04ea, 0x04ea,
-	0x04ec, 0x04ec,
-	0x04ee, 0x04ee,
-	0x04f0, 0x04f0,
-	0x04f2, 0x04f2,
-	0x04f4, 0x04f4,
-	0x04f6, 0x04f6,
-	0x04f8, 0x04f8,
-	0x04fa, 0x04fa,
-	0x04fc, 0x04fc,
-	0x04fe, 0x04fe,
-	0x0500, 0x0500,
-	0x0502, 0x0502,
-	0x0504, 0x0504,
-	0x0506, 0x0506,
-	0x0508, 0x0508,
-	0x050a, 0x050a,
-	0x050c, 0x050c,
-	0x050e, 0x050e,
-	0x0510, 0x0510,
-	0x0512, 0x0512,
-	0x0514, 0x0514,
-	0x0516, 0x0516,
-	0x0518, 0x0518,
-	0x051a, 0x051a,
-	0x051c, 0x051c,
-	0x051e, 0x051e,
-	0x0520, 0x0520,
-	0x0522, 0x0522,
-	0x0524, 0x0524,
-	0x0531, 0x0556,
-	0x10a0, 0x10c5,
-	0x1e00, 0x1e00,
-	0x1e02, 0x1e02,
-	0x1e04, 0x1e04,
-	0x1e06, 0x1e06,
-	0x1e08, 0x1e08,
-	0x1e0a, 0x1e0a,
-	0x1e0c, 0x1e0c,
-	0x1e0e, 0x1e0e,
-	0x1e10, 0x1e10,
-	0x1e12, 0x1e12,
-	0x1e14, 0x1e14,
-	0x1e16, 0x1e16,
-	0x1e18, 0x1e18,
-	0x1e1a, 0x1e1a,
-	0x1e1c, 0x1e1c,
-	0x1e1e, 0x1e1e,
-	0x1e20, 0x1e20,
-	0x1e22, 0x1e22,
-	0x1e24, 0x1e24,
-	0x1e26, 0x1e26,
-	0x1e28, 0x1e28,
-	0x1e2a, 0x1e2a,
-	0x1e2c, 0x1e2c,
-	0x1e2e, 0x1e2e,
-	0x1e30, 0x1e30,
-	0x1e32, 0x1e32,
-	0x1e34, 0x1e34,
-	0x1e36, 0x1e36,
-	0x1e38, 0x1e38,
-	0x1e3a, 0x1e3a,
-	0x1e3c, 0x1e3c,
-	0x1e3e, 0x1e3e,
-	0x1e40, 0x1e40,
-	0x1e42, 0x1e42,
-	0x1e44, 0x1e44,
-	0x1e46, 0x1e46,
-	0x1e48, 0x1e48,
-	0x1e4a, 0x1e4a,
-	0x1e4c, 0x1e4c,
-	0x1e4e, 0x1e4e,
-	0x1e50, 0x1e50,
-	0x1e52, 0x1e52,
-	0x1e54, 0x1e54,
-	0x1e56, 0x1e56,
-	0x1e58, 0x1e58,
-	0x1e5a, 0x1e5a,
-	0x1e5c, 0x1e5c,
-	0x1e5e, 0x1e5e,
-	0x1e60, 0x1e60,
-	0x1e62, 0x1e62,
-	0x1e64, 0x1e64,
-	0x1e66, 0x1e66,
-	0x1e68, 0x1e68,
-	0x1e6a, 0x1e6a,
-	0x1e6c, 0x1e6c,
-	0x1e6e, 0x1e6e,
-	0x1e70, 0x1e70,
-	0x1e72, 0x1e72,
-	0x1e74, 0x1e74,
-	0x1e76, 0x1e76,
-	0x1e78, 0x1e78,
-	0x1e7a, 0x1e7a,
-	0x1e7c, 0x1e7c,
-	0x1e7e, 0x1e7e,
-	0x1e80, 0x1e80,
-	0x1e82, 0x1e82,
-	0x1e84, 0x1e84,
-	0x1e86, 0x1e86,
-	0x1e88, 0x1e88,
-	0x1e8a, 0x1e8a,
-	0x1e8c, 0x1e8c,
-	0x1e8e, 0x1e8e,
-	0x1e90, 0x1e90,
-	0x1e92, 0x1e92,
-	0x1e94, 0x1e94,
-	0x1e9e, 0x1e9e,
-	0x1ea0, 0x1ea0,
-	0x1ea2, 0x1ea2,
-	0x1ea4, 0x1ea4,
-	0x1ea6, 0x1ea6,
-	0x1ea8, 0x1ea8,
-	0x1eaa, 0x1eaa,
-	0x1eac, 0x1eac,
-	0x1eae, 0x1eae,
-	0x1eb0, 0x1eb0,
-	0x1eb2, 0x1eb2,
-	0x1eb4, 0x1eb4,
-	0x1eb6, 0x1eb6,
-	0x1eb8, 0x1eb8,
-	0x1eba, 0x1eba,
-	0x1ebc, 0x1ebc,
-	0x1ebe, 0x1ebe,
-	0x1ec0, 0x1ec0,
-	0x1ec2, 0x1ec2,
-	0x1ec4, 0x1ec4,
-	0x1ec6, 0x1ec6,
-	0x1ec8, 0x1ec8,
-	0x1eca, 0x1eca,
-	0x1ecc, 0x1ecc,
-	0x1ece, 0x1ece,
-	0x1ed0, 0x1ed0,
-	0x1ed2, 0x1ed2,
-	0x1ed4, 0x1ed4,
-	0x1ed6, 0x1ed6,
-	0x1ed8, 0x1ed8,
-	0x1eda, 0x1eda,
-	0x1edc, 0x1edc,
-	0x1ede, 0x1ede,
-	0x1ee0, 0x1ee0,
-	0x1ee2, 0x1ee2,
-	0x1ee4, 0x1ee4,
-	0x1ee6, 0x1ee6,
-	0x1ee8, 0x1ee8,
-	0x1eea, 0x1eea,
-	0x1eec, 0x1eec,
-	0x1eee, 0x1eee,
-	0x1ef0, 0x1ef0,
-	0x1ef2, 0x1ef2,
-	0x1ef4, 0x1ef4,
-	0x1ef6, 0x1ef6,
-	0x1ef8, 0x1ef8,
-	0x1efa, 0x1efa,
-	0x1efc, 0x1efc,
-	0x1efe, 0x1efe,
-	0x1f08, 0x1f0f,
-	0x1f18, 0x1f1d,
-	0x1f28, 0x1f2f,
-	0x1f38, 0x1f3f,
-	0x1f48, 0x1f4d,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f5f,
-	0x1f68, 0x1f6f,
-	0x1fb8, 0x1fbb,
-	0x1fc8, 0x1fcb,
-	0x1fd8, 0x1fdb,
-	0x1fe8, 0x1fec,
-	0x1ff8, 0x1ffb,
-	0x2102, 0x2102,
-	0x2107, 0x2107,
-	0x210b, 0x210d,
-	0x2110, 0x2112,
-	0x2115, 0x2115,
-	0x2119, 0x211d,
-	0x2124, 0x2124,
-	0x2126, 0x2126,
-	0x2128, 0x2128,
-	0x212a, 0x212d,
-	0x2130, 0x2133,
-	0x213e, 0x213f,
-	0x2145, 0x2145,
-	0x2160, 0x216f,
-	0x2183, 0x2183,
-	0x24b6, 0x24cf,
-	0x2c00, 0x2c2e,
-	0x2c60, 0x2c60,
-	0x2c62, 0x2c64,
-	0x2c67, 0x2c67,
-	0x2c69, 0x2c69,
-	0x2c6b, 0x2c6b,
-	0x2c6d, 0x2c70,
-	0x2c72, 0x2c72,
-	0x2c75, 0x2c75,
-	0x2c7e, 0x2c80,
-	0x2c82, 0x2c82,
-	0x2c84, 0x2c84,
-	0x2c86, 0x2c86,
-	0x2c88, 0x2c88,
-	0x2c8a, 0x2c8a,
-	0x2c8c, 0x2c8c,
-	0x2c8e, 0x2c8e,
-	0x2c90, 0x2c90,
-	0x2c92, 0x2c92,
-	0x2c94, 0x2c94,
-	0x2c96, 0x2c96,
-	0x2c98, 0x2c98,
-	0x2c9a, 0x2c9a,
-	0x2c9c, 0x2c9c,
-	0x2c9e, 0x2c9e,
-	0x2ca0, 0x2ca0,
-	0x2ca2, 0x2ca2,
-	0x2ca4, 0x2ca4,
-	0x2ca6, 0x2ca6,
-	0x2ca8, 0x2ca8,
-	0x2caa, 0x2caa,
-	0x2cac, 0x2cac,
-	0x2cae, 0x2cae,
-	0x2cb0, 0x2cb0,
-	0x2cb2, 0x2cb2,
-	0x2cb4, 0x2cb4,
-	0x2cb6, 0x2cb6,
-	0x2cb8, 0x2cb8,
-	0x2cba, 0x2cba,
-	0x2cbc, 0x2cbc,
-	0x2cbe, 0x2cbe,
-	0x2cc0, 0x2cc0,
-	0x2cc2, 0x2cc2,
-	0x2cc4, 0x2cc4,
-	0x2cc6, 0x2cc6,
-	0x2cc8, 0x2cc8,
-	0x2cca, 0x2cca,
-	0x2ccc, 0x2ccc,
-	0x2cce, 0x2cce,
-	0x2cd0, 0x2cd0,
-	0x2cd2, 0x2cd2,
-	0x2cd4, 0x2cd4,
-	0x2cd6, 0x2cd6,
-	0x2cd8, 0x2cd8,
-	0x2cda, 0x2cda,
-	0x2cdc, 0x2cdc,
-	0x2cde, 0x2cde,
-	0x2ce0, 0x2ce0,
-	0x2ce2, 0x2ce2,
-	0x2ceb, 0x2ceb,
-	0x2ced, 0x2ced,
-	0xa640, 0xa640,
-	0xa642, 0xa642,
-	0xa644, 0xa644,
-	0xa646, 0xa646,
-	0xa648, 0xa648,
-	0xa64a, 0xa64a,
-	0xa64c, 0xa64c,
-	0xa64e, 0xa64e,
-	0xa650, 0xa650,
-	0xa652, 0xa652,
-	0xa654, 0xa654,
-	0xa656, 0xa656,
-	0xa658, 0xa658,
-	0xa65a, 0xa65a,
-	0xa65c, 0xa65c,
-	0xa65e, 0xa65e,
-	0xa662, 0xa662,
-	0xa664, 0xa664,
-	0xa666, 0xa666,
-	0xa668, 0xa668,
-	0xa66a, 0xa66a,
-	0xa66c, 0xa66c,
-	0xa680, 0xa680,
-	0xa682, 0xa682,
-	0xa684, 0xa684,
-	0xa686, 0xa686,
-	0xa688, 0xa688,
-	0xa68a, 0xa68a,
-	0xa68c, 0xa68c,
-	0xa68e, 0xa68e,
-	0xa690, 0xa690,
-	0xa692, 0xa692,
-	0xa694, 0xa694,
-	0xa696, 0xa696,
-	0xa722, 0xa722,
-	0xa724, 0xa724,
-	0xa726, 0xa726,
-	0xa728, 0xa728,
-	0xa72a, 0xa72a,
-	0xa72c, 0xa72c,
-	0xa72e, 0xa72e,
-	0xa732, 0xa732,
-	0xa734, 0xa734,
-	0xa736, 0xa736,
-	0xa738, 0xa738,
-	0xa73a, 0xa73a,
-	0xa73c, 0xa73c,
-	0xa73e, 0xa73e,
-	0xa740, 0xa740,
-	0xa742, 0xa742,
-	0xa744, 0xa744,
-	0xa746, 0xa746,
-	0xa748, 0xa748,
-	0xa74a, 0xa74a,
-	0xa74c, 0xa74c,
-	0xa74e, 0xa74e,
-	0xa750, 0xa750,
-	0xa752, 0xa752,
-	0xa754, 0xa754,
-	0xa756, 0xa756,
-	0xa758, 0xa758,
-	0xa75a, 0xa75a,
-	0xa75c, 0xa75c,
-	0xa75e, 0xa75e,
-	0xa760, 0xa760,
-	0xa762, 0xa762,
-	0xa764, 0xa764,
-	0xa766, 0xa766,
-	0xa768, 0xa768,
-	0xa76a, 0xa76a,
-	0xa76c, 0xa76c,
-	0xa76e, 0xa76e,
-	0xa779, 0xa779,
-	0xa77b, 0xa77b,
-	0xa77d, 0xa77e,
-	0xa780, 0xa780,
-	0xa782, 0xa782,
-	0xa784, 0xa784,
-	0xa786, 0xa786,
-	0xa78b, 0xa78b,
-	0xff21, 0xff3a,
-	0x10400, 0x10427,
-	0x1d400, 0x1d419,
-	0x1d434, 0x1d44d,
-	0x1d468, 0x1d481,
-	0x1d49c, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b5,
-	0x1d4d0, 0x1d4e9,
-	0x1d504, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d538, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d56c, 0x1d585,
-	0x1d5a0, 0x1d5b9,
-	0x1d5d4, 0x1d5ed,
-	0x1d608, 0x1d621,
-	0x1d63c, 0x1d655,
-	0x1d670, 0x1d689,
-	0x1d6a8, 0x1d6c0,
-	0x1d6e2, 0x1d6fa,
-	0x1d71c, 0x1d734,
-	0x1d756, 0x1d76e,
-	0x1d790, 0x1d7a8,
-	0x1d7ca, 0x1d7ca,
+        596,
+        0x0041, 0x005a,
+        0x00c0, 0x00d6,
+        0x00d8, 0x00de,
+        0x0100, 0x0100,
+        0x0102, 0x0102,
+        0x0104, 0x0104,
+        0x0106, 0x0106,
+        0x0108, 0x0108,
+        0x010a, 0x010a,
+        0x010c, 0x010c,
+        0x010e, 0x010e,
+        0x0110, 0x0110,
+        0x0112, 0x0112,
+        0x0114, 0x0114,
+        0x0116, 0x0116,
+        0x0118, 0x0118,
+        0x011a, 0x011a,
+        0x011c, 0x011c,
+        0x011e, 0x011e,
+        0x0120, 0x0120,
+        0x0122, 0x0122,
+        0x0124, 0x0124,
+        0x0126, 0x0126,
+        0x0128, 0x0128,
+        0x012a, 0x012a,
+        0x012c, 0x012c,
+        0x012e, 0x012e,
+        0x0130, 0x0130,
+        0x0132, 0x0132,
+        0x0134, 0x0134,
+        0x0136, 0x0136,
+        0x0139, 0x0139,
+        0x013b, 0x013b,
+        0x013d, 0x013d,
+        0x013f, 0x013f,
+        0x0141, 0x0141,
+        0x0143, 0x0143,
+        0x0145, 0x0145,
+        0x0147, 0x0147,
+        0x014a, 0x014a,
+        0x014c, 0x014c,
+        0x014e, 0x014e,
+        0x0150, 0x0150,
+        0x0152, 0x0152,
+        0x0154, 0x0154,
+        0x0156, 0x0156,
+        0x0158, 0x0158,
+        0x015a, 0x015a,
+        0x015c, 0x015c,
+        0x015e, 0x015e,
+        0x0160, 0x0160,
+        0x0162, 0x0162,
+        0x0164, 0x0164,
+        0x0166, 0x0166,
+        0x0168, 0x0168,
+        0x016a, 0x016a,
+        0x016c, 0x016c,
+        0x016e, 0x016e,
+        0x0170, 0x0170,
+        0x0172, 0x0172,
+        0x0174, 0x0174,
+        0x0176, 0x0176,
+        0x0178, 0x0179,
+        0x017b, 0x017b,
+        0x017d, 0x017d,
+        0x0181, 0x0182,
+        0x0184, 0x0184,
+        0x0186, 0x0187,
+        0x0189, 0x018b,
+        0x018e, 0x0191,
+        0x0193, 0x0194,
+        0x0196, 0x0198,
+        0x019c, 0x019d,
+        0x019f, 0x01a0,
+        0x01a2, 0x01a2,
+        0x01a4, 0x01a4,
+        0x01a6, 0x01a7,
+        0x01a9, 0x01a9,
+        0x01ac, 0x01ac,
+        0x01ae, 0x01af,
+        0x01b1, 0x01b3,
+        0x01b5, 0x01b5,
+        0x01b7, 0x01b8,
+        0x01bc, 0x01bc,
+        0x01c4, 0x01c4,
+        0x01c7, 0x01c7,
+        0x01ca, 0x01ca,
+        0x01cd, 0x01cd,
+        0x01cf, 0x01cf,
+        0x01d1, 0x01d1,
+        0x01d3, 0x01d3,
+        0x01d5, 0x01d5,
+        0x01d7, 0x01d7,
+        0x01d9, 0x01d9,
+        0x01db, 0x01db,
+        0x01de, 0x01de,
+        0x01e0, 0x01e0,
+        0x01e2, 0x01e2,
+        0x01e4, 0x01e4,
+        0x01e6, 0x01e6,
+        0x01e8, 0x01e8,
+        0x01ea, 0x01ea,
+        0x01ec, 0x01ec,
+        0x01ee, 0x01ee,
+        0x01f1, 0x01f1,
+        0x01f4, 0x01f4,
+        0x01f6, 0x01f8,
+        0x01fa, 0x01fa,
+        0x01fc, 0x01fc,
+        0x01fe, 0x01fe,
+        0x0200, 0x0200,
+        0x0202, 0x0202,
+        0x0204, 0x0204,
+        0x0206, 0x0206,
+        0x0208, 0x0208,
+        0x020a, 0x020a,
+        0x020c, 0x020c,
+        0x020e, 0x020e,
+        0x0210, 0x0210,
+        0x0212, 0x0212,
+        0x0214, 0x0214,
+        0x0216, 0x0216,
+        0x0218, 0x0218,
+        0x021a, 0x021a,
+        0x021c, 0x021c,
+        0x021e, 0x021e,
+        0x0220, 0x0220,
+        0x0222, 0x0222,
+        0x0224, 0x0224,
+        0x0226, 0x0226,
+        0x0228, 0x0228,
+        0x022a, 0x022a,
+        0x022c, 0x022c,
+        0x022e, 0x022e,
+        0x0230, 0x0230,
+        0x0232, 0x0232,
+        0x023a, 0x023b,
+        0x023d, 0x023e,
+        0x0241, 0x0241,
+        0x0243, 0x0246,
+        0x0248, 0x0248,
+        0x024a, 0x024a,
+        0x024c, 0x024c,
+        0x024e, 0x024e,
+        0x0370, 0x0370,
+        0x0372, 0x0372,
+        0x0376, 0x0376,
+        0x0386, 0x0386,
+        0x0388, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x038f,
+        0x0391, 0x03a1,
+        0x03a3, 0x03ab,
+        0x03cf, 0x03cf,
+        0x03d2, 0x03d4,
+        0x03d8, 0x03d8,
+        0x03da, 0x03da,
+        0x03dc, 0x03dc,
+        0x03de, 0x03de,
+        0x03e0, 0x03e0,
+        0x03e2, 0x03e2,
+        0x03e4, 0x03e4,
+        0x03e6, 0x03e6,
+        0x03e8, 0x03e8,
+        0x03ea, 0x03ea,
+        0x03ec, 0x03ec,
+        0x03ee, 0x03ee,
+        0x03f4, 0x03f4,
+        0x03f7, 0x03f7,
+        0x03f9, 0x03fa,
+        0x03fd, 0x042f,
+        0x0460, 0x0460,
+        0x0462, 0x0462,
+        0x0464, 0x0464,
+        0x0466, 0x0466,
+        0x0468, 0x0468,
+        0x046a, 0x046a,
+        0x046c, 0x046c,
+        0x046e, 0x046e,
+        0x0470, 0x0470,
+        0x0472, 0x0472,
+        0x0474, 0x0474,
+        0x0476, 0x0476,
+        0x0478, 0x0478,
+        0x047a, 0x047a,
+        0x047c, 0x047c,
+        0x047e, 0x047e,
+        0x0480, 0x0480,
+        0x048a, 0x048a,
+        0x048c, 0x048c,
+        0x048e, 0x048e,
+        0x0490, 0x0490,
+        0x0492, 0x0492,
+        0x0494, 0x0494,
+        0x0496, 0x0496,
+        0x0498, 0x0498,
+        0x049a, 0x049a,
+        0x049c, 0x049c,
+        0x049e, 0x049e,
+        0x04a0, 0x04a0,
+        0x04a2, 0x04a2,
+        0x04a4, 0x04a4,
+        0x04a6, 0x04a6,
+        0x04a8, 0x04a8,
+        0x04aa, 0x04aa,
+        0x04ac, 0x04ac,
+        0x04ae, 0x04ae,
+        0x04b0, 0x04b0,
+        0x04b2, 0x04b2,
+        0x04b4, 0x04b4,
+        0x04b6, 0x04b6,
+        0x04b8, 0x04b8,
+        0x04ba, 0x04ba,
+        0x04bc, 0x04bc,
+        0x04be, 0x04be,
+        0x04c0, 0x04c1,
+        0x04c3, 0x04c3,
+        0x04c5, 0x04c5,
+        0x04c7, 0x04c7,
+        0x04c9, 0x04c9,
+        0x04cb, 0x04cb,
+        0x04cd, 0x04cd,
+        0x04d0, 0x04d0,
+        0x04d2, 0x04d2,
+        0x04d4, 0x04d4,
+        0x04d6, 0x04d6,
+        0x04d8, 0x04d8,
+        0x04da, 0x04da,
+        0x04dc, 0x04dc,
+        0x04de, 0x04de,
+        0x04e0, 0x04e0,
+        0x04e2, 0x04e2,
+        0x04e4, 0x04e4,
+        0x04e6, 0x04e6,
+        0x04e8, 0x04e8,
+        0x04ea, 0x04ea,
+        0x04ec, 0x04ec,
+        0x04ee, 0x04ee,
+        0x04f0, 0x04f0,
+        0x04f2, 0x04f2,
+        0x04f4, 0x04f4,
+        0x04f6, 0x04f6,
+        0x04f8, 0x04f8,
+        0x04fa, 0x04fa,
+        0x04fc, 0x04fc,
+        0x04fe, 0x04fe,
+        0x0500, 0x0500,
+        0x0502, 0x0502,
+        0x0504, 0x0504,
+        0x0506, 0x0506,
+        0x0508, 0x0508,
+        0x050a, 0x050a,
+        0x050c, 0x050c,
+        0x050e, 0x050e,
+        0x0510, 0x0510,
+        0x0512, 0x0512,
+        0x0514, 0x0514,
+        0x0516, 0x0516,
+        0x0518, 0x0518,
+        0x051a, 0x051a,
+        0x051c, 0x051c,
+        0x051e, 0x051e,
+        0x0520, 0x0520,
+        0x0522, 0x0522,
+        0x0524, 0x0524,
+        0x0531, 0x0556,
+        0x10a0, 0x10c5,
+        0x1e00, 0x1e00,
+        0x1e02, 0x1e02,
+        0x1e04, 0x1e04,
+        0x1e06, 0x1e06,
+        0x1e08, 0x1e08,
+        0x1e0a, 0x1e0a,
+        0x1e0c, 0x1e0c,
+        0x1e0e, 0x1e0e,
+        0x1e10, 0x1e10,
+        0x1e12, 0x1e12,
+        0x1e14, 0x1e14,
+        0x1e16, 0x1e16,
+        0x1e18, 0x1e18,
+        0x1e1a, 0x1e1a,
+        0x1e1c, 0x1e1c,
+        0x1e1e, 0x1e1e,
+        0x1e20, 0x1e20,
+        0x1e22, 0x1e22,
+        0x1e24, 0x1e24,
+        0x1e26, 0x1e26,
+        0x1e28, 0x1e28,
+        0x1e2a, 0x1e2a,
+        0x1e2c, 0x1e2c,
+        0x1e2e, 0x1e2e,
+        0x1e30, 0x1e30,
+        0x1e32, 0x1e32,
+        0x1e34, 0x1e34,
+        0x1e36, 0x1e36,
+        0x1e38, 0x1e38,
+        0x1e3a, 0x1e3a,
+        0x1e3c, 0x1e3c,
+        0x1e3e, 0x1e3e,
+        0x1e40, 0x1e40,
+        0x1e42, 0x1e42,
+        0x1e44, 0x1e44,
+        0x1e46, 0x1e46,
+        0x1e48, 0x1e48,
+        0x1e4a, 0x1e4a,
+        0x1e4c, 0x1e4c,
+        0x1e4e, 0x1e4e,
+        0x1e50, 0x1e50,
+        0x1e52, 0x1e52,
+        0x1e54, 0x1e54,
+        0x1e56, 0x1e56,
+        0x1e58, 0x1e58,
+        0x1e5a, 0x1e5a,
+        0x1e5c, 0x1e5c,
+        0x1e5e, 0x1e5e,
+        0x1e60, 0x1e60,
+        0x1e62, 0x1e62,
+        0x1e64, 0x1e64,
+        0x1e66, 0x1e66,
+        0x1e68, 0x1e68,
+        0x1e6a, 0x1e6a,
+        0x1e6c, 0x1e6c,
+        0x1e6e, 0x1e6e,
+        0x1e70, 0x1e70,
+        0x1e72, 0x1e72,
+        0x1e74, 0x1e74,
+        0x1e76, 0x1e76,
+        0x1e78, 0x1e78,
+        0x1e7a, 0x1e7a,
+        0x1e7c, 0x1e7c,
+        0x1e7e, 0x1e7e,
+        0x1e80, 0x1e80,
+        0x1e82, 0x1e82,
+        0x1e84, 0x1e84,
+        0x1e86, 0x1e86,
+        0x1e88, 0x1e88,
+        0x1e8a, 0x1e8a,
+        0x1e8c, 0x1e8c,
+        0x1e8e, 0x1e8e,
+        0x1e90, 0x1e90,
+        0x1e92, 0x1e92,
+        0x1e94, 0x1e94,
+        0x1e9e, 0x1e9e,
+        0x1ea0, 0x1ea0,
+        0x1ea2, 0x1ea2,
+        0x1ea4, 0x1ea4,
+        0x1ea6, 0x1ea6,
+        0x1ea8, 0x1ea8,
+        0x1eaa, 0x1eaa,
+        0x1eac, 0x1eac,
+        0x1eae, 0x1eae,
+        0x1eb0, 0x1eb0,
+        0x1eb2, 0x1eb2,
+        0x1eb4, 0x1eb4,
+        0x1eb6, 0x1eb6,
+        0x1eb8, 0x1eb8,
+        0x1eba, 0x1eba,
+        0x1ebc, 0x1ebc,
+        0x1ebe, 0x1ebe,
+        0x1ec0, 0x1ec0,
+        0x1ec2, 0x1ec2,
+        0x1ec4, 0x1ec4,
+        0x1ec6, 0x1ec6,
+        0x1ec8, 0x1ec8,
+        0x1eca, 0x1eca,
+        0x1ecc, 0x1ecc,
+        0x1ece, 0x1ece,
+        0x1ed0, 0x1ed0,
+        0x1ed2, 0x1ed2,
+        0x1ed4, 0x1ed4,
+        0x1ed6, 0x1ed6,
+        0x1ed8, 0x1ed8,
+        0x1eda, 0x1eda,
+        0x1edc, 0x1edc,
+        0x1ede, 0x1ede,
+        0x1ee0, 0x1ee0,
+        0x1ee2, 0x1ee2,
+        0x1ee4, 0x1ee4,
+        0x1ee6, 0x1ee6,
+        0x1ee8, 0x1ee8,
+        0x1eea, 0x1eea,
+        0x1eec, 0x1eec,
+        0x1eee, 0x1eee,
+        0x1ef0, 0x1ef0,
+        0x1ef2, 0x1ef2,
+        0x1ef4, 0x1ef4,
+        0x1ef6, 0x1ef6,
+        0x1ef8, 0x1ef8,
+        0x1efa, 0x1efa,
+        0x1efc, 0x1efc,
+        0x1efe, 0x1efe,
+        0x1f08, 0x1f0f,
+        0x1f18, 0x1f1d,
+        0x1f28, 0x1f2f,
+        0x1f38, 0x1f3f,
+        0x1f48, 0x1f4d,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f5f,
+        0x1f68, 0x1f6f,
+        0x1fb8, 0x1fbb,
+        0x1fc8, 0x1fcb,
+        0x1fd8, 0x1fdb,
+        0x1fe8, 0x1fec,
+        0x1ff8, 0x1ffb,
+        0x2102, 0x2102,
+        0x2107, 0x2107,
+        0x210b, 0x210d,
+        0x2110, 0x2112,
+        0x2115, 0x2115,
+        0x2119, 0x211d,
+        0x2124, 0x2124,
+        0x2126, 0x2126,
+        0x2128, 0x2128,
+        0x212a, 0x212d,
+        0x2130, 0x2133,
+        0x213e, 0x213f,
+        0x2145, 0x2145,
+        0x2160, 0x216f,
+        0x2183, 0x2183,
+        0x24b6, 0x24cf,
+        0x2c00, 0x2c2e,
+        0x2c60, 0x2c60,
+        0x2c62, 0x2c64,
+        0x2c67, 0x2c67,
+        0x2c69, 0x2c69,
+        0x2c6b, 0x2c6b,
+        0x2c6d, 0x2c70,
+        0x2c72, 0x2c72,
+        0x2c75, 0x2c75,
+        0x2c7e, 0x2c80,
+        0x2c82, 0x2c82,
+        0x2c84, 0x2c84,
+        0x2c86, 0x2c86,
+        0x2c88, 0x2c88,
+        0x2c8a, 0x2c8a,
+        0x2c8c, 0x2c8c,
+        0x2c8e, 0x2c8e,
+        0x2c90, 0x2c90,
+        0x2c92, 0x2c92,
+        0x2c94, 0x2c94,
+        0x2c96, 0x2c96,
+        0x2c98, 0x2c98,
+        0x2c9a, 0x2c9a,
+        0x2c9c, 0x2c9c,
+        0x2c9e, 0x2c9e,
+        0x2ca0, 0x2ca0,
+        0x2ca2, 0x2ca2,
+        0x2ca4, 0x2ca4,
+        0x2ca6, 0x2ca6,
+        0x2ca8, 0x2ca8,
+        0x2caa, 0x2caa,
+        0x2cac, 0x2cac,
+        0x2cae, 0x2cae,
+        0x2cb0, 0x2cb0,
+        0x2cb2, 0x2cb2,
+        0x2cb4, 0x2cb4,
+        0x2cb6, 0x2cb6,
+        0x2cb8, 0x2cb8,
+        0x2cba, 0x2cba,
+        0x2cbc, 0x2cbc,
+        0x2cbe, 0x2cbe,
+        0x2cc0, 0x2cc0,
+        0x2cc2, 0x2cc2,
+        0x2cc4, 0x2cc4,
+        0x2cc6, 0x2cc6,
+        0x2cc8, 0x2cc8,
+        0x2cca, 0x2cca,
+        0x2ccc, 0x2ccc,
+        0x2cce, 0x2cce,
+        0x2cd0, 0x2cd0,
+        0x2cd2, 0x2cd2,
+        0x2cd4, 0x2cd4,
+        0x2cd6, 0x2cd6,
+        0x2cd8, 0x2cd8,
+        0x2cda, 0x2cda,
+        0x2cdc, 0x2cdc,
+        0x2cde, 0x2cde,
+        0x2ce0, 0x2ce0,
+        0x2ce2, 0x2ce2,
+        0x2ceb, 0x2ceb,
+        0x2ced, 0x2ced,
+        0xa640, 0xa640,
+        0xa642, 0xa642,
+        0xa644, 0xa644,
+        0xa646, 0xa646,
+        0xa648, 0xa648,
+        0xa64a, 0xa64a,
+        0xa64c, 0xa64c,
+        0xa64e, 0xa64e,
+        0xa650, 0xa650,
+        0xa652, 0xa652,
+        0xa654, 0xa654,
+        0xa656, 0xa656,
+        0xa658, 0xa658,
+        0xa65a, 0xa65a,
+        0xa65c, 0xa65c,
+        0xa65e, 0xa65e,
+        0xa662, 0xa662,
+        0xa664, 0xa664,
+        0xa666, 0xa666,
+        0xa668, 0xa668,
+        0xa66a, 0xa66a,
+        0xa66c, 0xa66c,
+        0xa680, 0xa680,
+        0xa682, 0xa682,
+        0xa684, 0xa684,
+        0xa686, 0xa686,
+        0xa688, 0xa688,
+        0xa68a, 0xa68a,
+        0xa68c, 0xa68c,
+        0xa68e, 0xa68e,
+        0xa690, 0xa690,
+        0xa692, 0xa692,
+        0xa694, 0xa694,
+        0xa696, 0xa696,
+        0xa722, 0xa722,
+        0xa724, 0xa724,
+        0xa726, 0xa726,
+        0xa728, 0xa728,
+        0xa72a, 0xa72a,
+        0xa72c, 0xa72c,
+        0xa72e, 0xa72e,
+        0xa732, 0xa732,
+        0xa734, 0xa734,
+        0xa736, 0xa736,
+        0xa738, 0xa738,
+        0xa73a, 0xa73a,
+        0xa73c, 0xa73c,
+        0xa73e, 0xa73e,
+        0xa740, 0xa740,
+        0xa742, 0xa742,
+        0xa744, 0xa744,
+        0xa746, 0xa746,
+        0xa748, 0xa748,
+        0xa74a, 0xa74a,
+        0xa74c, 0xa74c,
+        0xa74e, 0xa74e,
+        0xa750, 0xa750,
+        0xa752, 0xa752,
+        0xa754, 0xa754,
+        0xa756, 0xa756,
+        0xa758, 0xa758,
+        0xa75a, 0xa75a,
+        0xa75c, 0xa75c,
+        0xa75e, 0xa75e,
+        0xa760, 0xa760,
+        0xa762, 0xa762,
+        0xa764, 0xa764,
+        0xa766, 0xa766,
+        0xa768, 0xa768,
+        0xa76a, 0xa76a,
+        0xa76c, 0xa76c,
+        0xa76e, 0xa76e,
+        0xa779, 0xa779,
+        0xa77b, 0xa77b,
+        0xa77d, 0xa77e,
+        0xa780, 0xa780,
+        0xa782, 0xa782,
+        0xa784, 0xa784,
+        0xa786, 0xa786,
+        0xa78b, 0xa78b,
+        0xff21, 0xff3a,
+        0x10400, 0x10427,
+        0x1d400, 0x1d419,
+        0x1d434, 0x1d44d,
+        0x1d468, 0x1d481,
+        0x1d49c, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b5,
+        0x1d4d0, 0x1d4e9,
+        0x1d504, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d538, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d56c, 0x1d585,
+        0x1d5a0, 0x1d5b9,
+        0x1d5d4, 0x1d5ed,
+        0x1d608, 0x1d621,
+        0x1d63c, 0x1d655,
+        0x1d670, 0x1d689,
+        0x1d6a8, 0x1d6c0,
+        0x1d6e2, 0x1d6fa,
+        0x1d71c, 0x1d734,
+        0x1d756, 0x1d76e,
+        0x1d790, 0x1d7a8,
+        0x1d7ca, 0x1d7ca,
 }; /* CR_Uppercase */
 
 /* 'Cased': Derived Property */
 static const OnigCodePoint CR_Cased[] = {
-	110,
-	0x0041, 0x005a,
-	0x0061, 0x007a,
-	0x00aa, 0x00aa,
-	0x00b5, 0x00b5,
-	0x00ba, 0x00ba,
-	0x00c0, 0x00d6,
-	0x00d8, 0x00f6,
-	0x00f8, 0x01ba,
-	0x01bc, 0x01bf,
-	0x01c4, 0x0293,
-	0x0295, 0x02b8,
-	0x02c0, 0x02c1,
-	0x02e0, 0x02e4,
-	0x0345, 0x0345,
-	0x0370, 0x0373,
-	0x0376, 0x0377,
-	0x037a, 0x037d,
-	0x0386, 0x0386,
-	0x0388, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x03a1,
-	0x03a3, 0x03f5,
-	0x03f7, 0x0481,
-	0x048a, 0x0525,
-	0x0531, 0x0556,
-	0x0561, 0x0587,
-	0x10a0, 0x10c5,
-	0x1d00, 0x1dbf,
-	0x1e00, 0x1f15,
-	0x1f18, 0x1f1d,
-	0x1f20, 0x1f45,
-	0x1f48, 0x1f4d,
-	0x1f50, 0x1f57,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f7d,
-	0x1f80, 0x1fb4,
-	0x1fb6, 0x1fbc,
-	0x1fbe, 0x1fbe,
-	0x1fc2, 0x1fc4,
-	0x1fc6, 0x1fcc,
-	0x1fd0, 0x1fd3,
-	0x1fd6, 0x1fdb,
-	0x1fe0, 0x1fec,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ffc,
-	0x2090, 0x2094,
-	0x2102, 0x2102,
-	0x2107, 0x2107,
-	0x210a, 0x2113,
-	0x2115, 0x2115,
-	0x2119, 0x211d,
-	0x2124, 0x2124,
-	0x2126, 0x2126,
-	0x2128, 0x2128,
-	0x212a, 0x212d,
-	0x212f, 0x2134,
-	0x2139, 0x2139,
-	0x213c, 0x213f,
-	0x2145, 0x2149,
-	0x214e, 0x214e,
-	0x2160, 0x217f,
-	0x2183, 0x2184,
-	0x24b6, 0x24e9,
-	0x2c00, 0x2c2e,
-	0x2c30, 0x2c5e,
-	0x2c60, 0x2ce4,
-	0x2ceb, 0x2cee,
-	0x2d00, 0x2d25,
-	0xa640, 0xa65f,
-	0xa662, 0xa66d,
-	0xa680, 0xa697,
-	0xa722, 0xa787,
-	0xa78b, 0xa78c,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xff21, 0xff3a,
-	0xff41, 0xff5a,
-	0x10400, 0x1044f,
-	0x1d400, 0x1d454,
-	0x1d456, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d51e, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d552, 0x1d6a5,
-	0x1d6a8, 0x1d6c0,
-	0x1d6c2, 0x1d6da,
-	0x1d6dc, 0x1d6fa,
-	0x1d6fc, 0x1d714,
-	0x1d716, 0x1d734,
-	0x1d736, 0x1d74e,
-	0x1d750, 0x1d76e,
-	0x1d770, 0x1d788,
-	0x1d78a, 0x1d7a8,
-	0x1d7aa, 0x1d7c2,
-	0x1d7c4, 0x1d7cb,
+        110,
+        0x0041, 0x005a,
+        0x0061, 0x007a,
+        0x00aa, 0x00aa,
+        0x00b5, 0x00b5,
+        0x00ba, 0x00ba,
+        0x00c0, 0x00d6,
+        0x00d8, 0x00f6,
+        0x00f8, 0x01ba,
+        0x01bc, 0x01bf,
+        0x01c4, 0x0293,
+        0x0295, 0x02b8,
+        0x02c0, 0x02c1,
+        0x02e0, 0x02e4,
+        0x0345, 0x0345,
+        0x0370, 0x0373,
+        0x0376, 0x0377,
+        0x037a, 0x037d,
+        0x0386, 0x0386,
+        0x0388, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x03a1,
+        0x03a3, 0x03f5,
+        0x03f7, 0x0481,
+        0x048a, 0x0525,
+        0x0531, 0x0556,
+        0x0561, 0x0587,
+        0x10a0, 0x10c5,
+        0x1d00, 0x1dbf,
+        0x1e00, 0x1f15,
+        0x1f18, 0x1f1d,
+        0x1f20, 0x1f45,
+        0x1f48, 0x1f4d,
+        0x1f50, 0x1f57,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f7d,
+        0x1f80, 0x1fb4,
+        0x1fb6, 0x1fbc,
+        0x1fbe, 0x1fbe,
+        0x1fc2, 0x1fc4,
+        0x1fc6, 0x1fcc,
+        0x1fd0, 0x1fd3,
+        0x1fd6, 0x1fdb,
+        0x1fe0, 0x1fec,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ffc,
+        0x2090, 0x2094,
+        0x2102, 0x2102,
+        0x2107, 0x2107,
+        0x210a, 0x2113,
+        0x2115, 0x2115,
+        0x2119, 0x211d,
+        0x2124, 0x2124,
+        0x2126, 0x2126,
+        0x2128, 0x2128,
+        0x212a, 0x212d,
+        0x212f, 0x2134,
+        0x2139, 0x2139,
+        0x213c, 0x213f,
+        0x2145, 0x2149,
+        0x214e, 0x214e,
+        0x2160, 0x217f,
+        0x2183, 0x2184,
+        0x24b6, 0x24e9,
+        0x2c00, 0x2c2e,
+        0x2c30, 0x2c5e,
+        0x2c60, 0x2ce4,
+        0x2ceb, 0x2cee,
+        0x2d00, 0x2d25,
+        0xa640, 0xa65f,
+        0xa662, 0xa66d,
+        0xa680, 0xa697,
+        0xa722, 0xa787,
+        0xa78b, 0xa78c,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xff21, 0xff3a,
+        0xff41, 0xff5a,
+        0x10400, 0x1044f,
+        0x1d400, 0x1d454,
+        0x1d456, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d51e, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d552, 0x1d6a5,
+        0x1d6a8, 0x1d6c0,
+        0x1d6c2, 0x1d6da,
+        0x1d6dc, 0x1d6fa,
+        0x1d6fc, 0x1d714,
+        0x1d716, 0x1d734,
+        0x1d736, 0x1d74e,
+        0x1d750, 0x1d76e,
+        0x1d770, 0x1d788,
+        0x1d78a, 0x1d7a8,
+        0x1d7aa, 0x1d7c2,
+        0x1d7c4, 0x1d7cb,
 }; /* CR_Cased */
 
 /* 'Case_Ignorable': Derived Property */
 static const OnigCodePoint CR_Case_Ignorable[] = {
-	266,
-	0x0027, 0x0027,
-	0x002e, 0x002e,
-	0x003a, 0x003a,
-	0x005e, 0x005e,
-	0x0060, 0x0060,
-	0x00a8, 0x00a8,
-	0x00ad, 0x00ad,
-	0x00af, 0x00af,
-	0x00b4, 0x00b4,
-	0x00b7, 0x00b8,
-	0x02b0, 0x036f,
-	0x0374, 0x0375,
-	0x037a, 0x037a,
-	0x0384, 0x0385,
-	0x0387, 0x0387,
-	0x0483, 0x0489,
-	0x0559, 0x0559,
-	0x0591, 0x05bd,
-	0x05bf, 0x05bf,
-	0x05c1, 0x05c2,
-	0x05c4, 0x05c5,
-	0x05c7, 0x05c7,
-	0x05f4, 0x05f4,
-	0x0600, 0x0603,
-	0x0610, 0x061a,
-	0x0640, 0x0640,
-	0x064b, 0x065e,
-	0x0670, 0x0670,
-	0x06d6, 0x06e8,
-	0x06ea, 0x06ed,
-	0x070f, 0x070f,
-	0x0711, 0x0711,
-	0x0730, 0x074a,
-	0x07a6, 0x07b0,
-	0x07eb, 0x07f5,
-	0x07fa, 0x07fa,
-	0x0816, 0x082d,
-	0x0900, 0x0902,
-	0x093c, 0x093c,
-	0x0941, 0x0948,
-	0x094d, 0x094d,
-	0x0951, 0x0955,
-	0x0962, 0x0963,
-	0x0971, 0x0971,
-	0x0981, 0x0981,
-	0x09bc, 0x09bc,
-	0x09c1, 0x09c4,
-	0x09cd, 0x09cd,
-	0x09e2, 0x09e3,
-	0x0a01, 0x0a02,
-	0x0a3c, 0x0a3c,
-	0x0a41, 0x0a42,
-	0x0a47, 0x0a48,
-	0x0a4b, 0x0a4d,
-	0x0a51, 0x0a51,
-	0x0a70, 0x0a71,
-	0x0a75, 0x0a75,
-	0x0a81, 0x0a82,
-	0x0abc, 0x0abc,
-	0x0ac1, 0x0ac5,
-	0x0ac7, 0x0ac8,
-	0x0acd, 0x0acd,
-	0x0ae2, 0x0ae3,
-	0x0b01, 0x0b01,
-	0x0b3c, 0x0b3c,
-	0x0b3f, 0x0b3f,
-	0x0b41, 0x0b44,
-	0x0b4d, 0x0b4d,
-	0x0b56, 0x0b56,
-	0x0b62, 0x0b63,
-	0x0b82, 0x0b82,
-	0x0bc0, 0x0bc0,
-	0x0bcd, 0x0bcd,
-	0x0c3e, 0x0c40,
-	0x0c46, 0x0c48,
-	0x0c4a, 0x0c4d,
-	0x0c55, 0x0c56,
-	0x0c62, 0x0c63,
-	0x0cbc, 0x0cbc,
-	0x0cbf, 0x0cbf,
-	0x0cc6, 0x0cc6,
-	0x0ccc, 0x0ccd,
-	0x0ce2, 0x0ce3,
-	0x0d41, 0x0d44,
-	0x0d4d, 0x0d4d,
-	0x0d62, 0x0d63,
-	0x0dca, 0x0dca,
-	0x0dd2, 0x0dd4,
-	0x0dd6, 0x0dd6,
-	0x0e31, 0x0e31,
-	0x0e34, 0x0e3a,
-	0x0e46, 0x0e4e,
-	0x0eb1, 0x0eb1,
-	0x0eb4, 0x0eb9,
-	0x0ebb, 0x0ebc,
-	0x0ec6, 0x0ec6,
-	0x0ec8, 0x0ecd,
-	0x0f18, 0x0f19,
-	0x0f35, 0x0f35,
-	0x0f37, 0x0f37,
-	0x0f39, 0x0f39,
-	0x0f71, 0x0f7e,
-	0x0f80, 0x0f84,
-	0x0f86, 0x0f87,
-	0x0f90, 0x0f97,
-	0x0f99, 0x0fbc,
-	0x0fc6, 0x0fc6,
-	0x102d, 0x1030,
-	0x1032, 0x1037,
-	0x1039, 0x103a,
-	0x103d, 0x103e,
-	0x1058, 0x1059,
-	0x105e, 0x1060,
-	0x1071, 0x1074,
-	0x1082, 0x1082,
-	0x1085, 0x1086,
-	0x108d, 0x108d,
-	0x109d, 0x109d,
-	0x10fc, 0x10fc,
-	0x135f, 0x135f,
-	0x1712, 0x1714,
-	0x1732, 0x1734,
-	0x1752, 0x1753,
-	0x1772, 0x1773,
-	0x17b4, 0x17b5,
-	0x17b7, 0x17bd,
-	0x17c6, 0x17c6,
-	0x17c9, 0x17d3,
-	0x17d7, 0x17d7,
-	0x17dd, 0x17dd,
-	0x180b, 0x180d,
-	0x1843, 0x1843,
-	0x18a9, 0x18a9,
-	0x1920, 0x1922,
-	0x1927, 0x1928,
-	0x1932, 0x1932,
-	0x1939, 0x193b,
-	0x1a17, 0x1a18,
-	0x1a56, 0x1a56,
-	0x1a58, 0x1a5e,
-	0x1a60, 0x1a60,
-	0x1a62, 0x1a62,
-	0x1a65, 0x1a6c,
-	0x1a73, 0x1a7c,
-	0x1a7f, 0x1a7f,
-	0x1aa7, 0x1aa7,
-	0x1b00, 0x1b03,
-	0x1b34, 0x1b34,
-	0x1b36, 0x1b3a,
-	0x1b3c, 0x1b3c,
-	0x1b42, 0x1b42,
-	0x1b6b, 0x1b73,
-	0x1b80, 0x1b81,
-	0x1ba2, 0x1ba5,
-	0x1ba8, 0x1ba9,
-	0x1c2c, 0x1c33,
-	0x1c36, 0x1c37,
-	0x1c78, 0x1c7d,
-	0x1cd0, 0x1cd2,
-	0x1cd4, 0x1ce0,
-	0x1ce2, 0x1ce8,
-	0x1ced, 0x1ced,
-	0x1d2c, 0x1d61,
-	0x1d78, 0x1d78,
-	0x1d9b, 0x1de6,
-	0x1dfd, 0x1dff,
-	0x1fbd, 0x1fbd,
-	0x1fbf, 0x1fc1,
-	0x1fcd, 0x1fcf,
-	0x1fdd, 0x1fdf,
-	0x1fed, 0x1fef,
-	0x1ffd, 0x1ffe,
-	0x200b, 0x200f,
-	0x2018, 0x2019,
-	0x2024, 0x2024,
-	0x2027, 0x2027,
-	0x202a, 0x202e,
-	0x2060, 0x2064,
-	0x206a, 0x206f,
-	0x2071, 0x2071,
-	0x207f, 0x207f,
-	0x2090, 0x2094,
-	0x20d0, 0x20f0,
-	0x2c7d, 0x2c7d,
-	0x2cef, 0x2cf1,
-	0x2d6f, 0x2d6f,
-	0x2de0, 0x2dff,
-	0x2e2f, 0x2e2f,
-	0x3005, 0x3005,
-	0x302a, 0x302f,
-	0x3031, 0x3035,
-	0x303b, 0x303b,
-	0x3099, 0x309e,
-	0x30fc, 0x30fe,
-	0xa015, 0xa015,
-	0xa4f8, 0xa4fd,
-	0xa60c, 0xa60c,
-	0xa66f, 0xa672,
-	0xa67c, 0xa67d,
-	0xa67f, 0xa67f,
-	0xa6f0, 0xa6f1,
-	0xa700, 0xa721,
-	0xa770, 0xa770,
-	0xa788, 0xa78a,
-	0xa802, 0xa802,
-	0xa806, 0xa806,
-	0xa80b, 0xa80b,
-	0xa825, 0xa826,
-	0xa8c4, 0xa8c4,
-	0xa8e0, 0xa8f1,
-	0xa926, 0xa92d,
-	0xa947, 0xa951,
-	0xa980, 0xa982,
-	0xa9b3, 0xa9b3,
-	0xa9b6, 0xa9b9,
-	0xa9bc, 0xa9bc,
-	0xa9cf, 0xa9cf,
-	0xaa29, 0xaa2e,
-	0xaa31, 0xaa32,
-	0xaa35, 0xaa36,
-	0xaa43, 0xaa43,
-	0xaa4c, 0xaa4c,
-	0xaa70, 0xaa70,
-	0xaab0, 0xaab0,
-	0xaab2, 0xaab4,
-	0xaab7, 0xaab8,
-	0xaabe, 0xaabf,
-	0xaac1, 0xaac1,
-	0xaadd, 0xaadd,
-	0xabe5, 0xabe5,
-	0xabe8, 0xabe8,
-	0xabed, 0xabed,
-	0xfb1e, 0xfb1e,
-	0xfe00, 0xfe0f,
-	0xfe13, 0xfe13,
-	0xfe20, 0xfe26,
-	0xfe52, 0xfe52,
-	0xfe55, 0xfe55,
-	0xfeff, 0xfeff,
-	0xff07, 0xff07,
-	0xff0e, 0xff0e,
-	0xff1a, 0xff1a,
-	0xff3e, 0xff3e,
-	0xff40, 0xff40,
-	0xff70, 0xff70,
-	0xff9e, 0xff9f,
-	0xffe3, 0xffe3,
-	0xfff9, 0xfffb,
-	0x101fd, 0x101fd,
-	0x10a01, 0x10a03,
-	0x10a05, 0x10a06,
-	0x10a0c, 0x10a0f,
-	0x10a38, 0x10a3a,
-	0x10a3f, 0x10a3f,
-	0x11080, 0x11081,
-	0x110b3, 0x110b6,
-	0x110b9, 0x110ba,
-	0x110bd, 0x110bd,
-	0x1d167, 0x1d169,
-	0x1d173, 0x1d182,
-	0x1d185, 0x1d18b,
-	0x1d1aa, 0x1d1ad,
-	0x1d242, 0x1d244,
-	0xe0001, 0xe0001,
-	0xe0020, 0xe007f,
-	0xe0100, 0xe01ef,
+        266,
+        0x0027, 0x0027,
+        0x002e, 0x002e,
+        0x003a, 0x003a,
+        0x005e, 0x005e,
+        0x0060, 0x0060,
+        0x00a8, 0x00a8,
+        0x00ad, 0x00ad,
+        0x00af, 0x00af,
+        0x00b4, 0x00b4,
+        0x00b7, 0x00b8,
+        0x02b0, 0x036f,
+        0x0374, 0x0375,
+        0x037a, 0x037a,
+        0x0384, 0x0385,
+        0x0387, 0x0387,
+        0x0483, 0x0489,
+        0x0559, 0x0559,
+        0x0591, 0x05bd,
+        0x05bf, 0x05bf,
+        0x05c1, 0x05c2,
+        0x05c4, 0x05c5,
+        0x05c7, 0x05c7,
+        0x05f4, 0x05f4,
+        0x0600, 0x0603,
+        0x0610, 0x061a,
+        0x0640, 0x0640,
+        0x064b, 0x065e,
+        0x0670, 0x0670,
+        0x06d6, 0x06e8,
+        0x06ea, 0x06ed,
+        0x070f, 0x070f,
+        0x0711, 0x0711,
+        0x0730, 0x074a,
+        0x07a6, 0x07b0,
+        0x07eb, 0x07f5,
+        0x07fa, 0x07fa,
+        0x0816, 0x082d,
+        0x0900, 0x0902,
+        0x093c, 0x093c,
+        0x0941, 0x0948,
+        0x094d, 0x094d,
+        0x0951, 0x0955,
+        0x0962, 0x0963,
+        0x0971, 0x0971,
+        0x0981, 0x0981,
+        0x09bc, 0x09bc,
+        0x09c1, 0x09c4,
+        0x09cd, 0x09cd,
+        0x09e2, 0x09e3,
+        0x0a01, 0x0a02,
+        0x0a3c, 0x0a3c,
+        0x0a41, 0x0a42,
+        0x0a47, 0x0a48,
+        0x0a4b, 0x0a4d,
+        0x0a51, 0x0a51,
+        0x0a70, 0x0a71,
+        0x0a75, 0x0a75,
+        0x0a81, 0x0a82,
+        0x0abc, 0x0abc,
+        0x0ac1, 0x0ac5,
+        0x0ac7, 0x0ac8,
+        0x0acd, 0x0acd,
+        0x0ae2, 0x0ae3,
+        0x0b01, 0x0b01,
+        0x0b3c, 0x0b3c,
+        0x0b3f, 0x0b3f,
+        0x0b41, 0x0b44,
+        0x0b4d, 0x0b4d,
+        0x0b56, 0x0b56,
+        0x0b62, 0x0b63,
+        0x0b82, 0x0b82,
+        0x0bc0, 0x0bc0,
+        0x0bcd, 0x0bcd,
+        0x0c3e, 0x0c40,
+        0x0c46, 0x0c48,
+        0x0c4a, 0x0c4d,
+        0x0c55, 0x0c56,
+        0x0c62, 0x0c63,
+        0x0cbc, 0x0cbc,
+        0x0cbf, 0x0cbf,
+        0x0cc6, 0x0cc6,
+        0x0ccc, 0x0ccd,
+        0x0ce2, 0x0ce3,
+        0x0d41, 0x0d44,
+        0x0d4d, 0x0d4d,
+        0x0d62, 0x0d63,
+        0x0dca, 0x0dca,
+        0x0dd2, 0x0dd4,
+        0x0dd6, 0x0dd6,
+        0x0e31, 0x0e31,
+        0x0e34, 0x0e3a,
+        0x0e46, 0x0e4e,
+        0x0eb1, 0x0eb1,
+        0x0eb4, 0x0eb9,
+        0x0ebb, 0x0ebc,
+        0x0ec6, 0x0ec6,
+        0x0ec8, 0x0ecd,
+        0x0f18, 0x0f19,
+        0x0f35, 0x0f35,
+        0x0f37, 0x0f37,
+        0x0f39, 0x0f39,
+        0x0f71, 0x0f7e,
+        0x0f80, 0x0f84,
+        0x0f86, 0x0f87,
+        0x0f90, 0x0f97,
+        0x0f99, 0x0fbc,
+        0x0fc6, 0x0fc6,
+        0x102d, 0x1030,
+        0x1032, 0x1037,
+        0x1039, 0x103a,
+        0x103d, 0x103e,
+        0x1058, 0x1059,
+        0x105e, 0x1060,
+        0x1071, 0x1074,
+        0x1082, 0x1082,
+        0x1085, 0x1086,
+        0x108d, 0x108d,
+        0x109d, 0x109d,
+        0x10fc, 0x10fc,
+        0x135f, 0x135f,
+        0x1712, 0x1714,
+        0x1732, 0x1734,
+        0x1752, 0x1753,
+        0x1772, 0x1773,
+        0x17b4, 0x17b5,
+        0x17b7, 0x17bd,
+        0x17c6, 0x17c6,
+        0x17c9, 0x17d3,
+        0x17d7, 0x17d7,
+        0x17dd, 0x17dd,
+        0x180b, 0x180d,
+        0x1843, 0x1843,
+        0x18a9, 0x18a9,
+        0x1920, 0x1922,
+        0x1927, 0x1928,
+        0x1932, 0x1932,
+        0x1939, 0x193b,
+        0x1a17, 0x1a18,
+        0x1a56, 0x1a56,
+        0x1a58, 0x1a5e,
+        0x1a60, 0x1a60,
+        0x1a62, 0x1a62,
+        0x1a65, 0x1a6c,
+        0x1a73, 0x1a7c,
+        0x1a7f, 0x1a7f,
+        0x1aa7, 0x1aa7,
+        0x1b00, 0x1b03,
+        0x1b34, 0x1b34,
+        0x1b36, 0x1b3a,
+        0x1b3c, 0x1b3c,
+        0x1b42, 0x1b42,
+        0x1b6b, 0x1b73,
+        0x1b80, 0x1b81,
+        0x1ba2, 0x1ba5,
+        0x1ba8, 0x1ba9,
+        0x1c2c, 0x1c33,
+        0x1c36, 0x1c37,
+        0x1c78, 0x1c7d,
+        0x1cd0, 0x1cd2,
+        0x1cd4, 0x1ce0,
+        0x1ce2, 0x1ce8,
+        0x1ced, 0x1ced,
+        0x1d2c, 0x1d61,
+        0x1d78, 0x1d78,
+        0x1d9b, 0x1de6,
+        0x1dfd, 0x1dff,
+        0x1fbd, 0x1fbd,
+        0x1fbf, 0x1fc1,
+        0x1fcd, 0x1fcf,
+        0x1fdd, 0x1fdf,
+        0x1fed, 0x1fef,
+        0x1ffd, 0x1ffe,
+        0x200b, 0x200f,
+        0x2018, 0x2019,
+        0x2024, 0x2024,
+        0x2027, 0x2027,
+        0x202a, 0x202e,
+        0x2060, 0x2064,
+        0x206a, 0x206f,
+        0x2071, 0x2071,
+        0x207f, 0x207f,
+        0x2090, 0x2094,
+        0x20d0, 0x20f0,
+        0x2c7d, 0x2c7d,
+        0x2cef, 0x2cf1,
+        0x2d6f, 0x2d6f,
+        0x2de0, 0x2dff,
+        0x2e2f, 0x2e2f,
+        0x3005, 0x3005,
+        0x302a, 0x302f,
+        0x3031, 0x3035,
+        0x303b, 0x303b,
+        0x3099, 0x309e,
+        0x30fc, 0x30fe,
+        0xa015, 0xa015,
+        0xa4f8, 0xa4fd,
+        0xa60c, 0xa60c,
+        0xa66f, 0xa672,
+        0xa67c, 0xa67d,
+        0xa67f, 0xa67f,
+        0xa6f0, 0xa6f1,
+        0xa700, 0xa721,
+        0xa770, 0xa770,
+        0xa788, 0xa78a,
+        0xa802, 0xa802,
+        0xa806, 0xa806,
+        0xa80b, 0xa80b,
+        0xa825, 0xa826,
+        0xa8c4, 0xa8c4,
+        0xa8e0, 0xa8f1,
+        0xa926, 0xa92d,
+        0xa947, 0xa951,
+        0xa980, 0xa982,
+        0xa9b3, 0xa9b3,
+        0xa9b6, 0xa9b9,
+        0xa9bc, 0xa9bc,
+        0xa9cf, 0xa9cf,
+        0xaa29, 0xaa2e,
+        0xaa31, 0xaa32,
+        0xaa35, 0xaa36,
+        0xaa43, 0xaa43,
+        0xaa4c, 0xaa4c,
+        0xaa70, 0xaa70,
+        0xaab0, 0xaab0,
+        0xaab2, 0xaab4,
+        0xaab7, 0xaab8,
+        0xaabe, 0xaabf,
+        0xaac1, 0xaac1,
+        0xaadd, 0xaadd,
+        0xabe5, 0xabe5,
+        0xabe8, 0xabe8,
+        0xabed, 0xabed,
+        0xfb1e, 0xfb1e,
+        0xfe00, 0xfe0f,
+        0xfe13, 0xfe13,
+        0xfe20, 0xfe26,
+        0xfe52, 0xfe52,
+        0xfe55, 0xfe55,
+        0xfeff, 0xfeff,
+        0xff07, 0xff07,
+        0xff0e, 0xff0e,
+        0xff1a, 0xff1a,
+        0xff3e, 0xff3e,
+        0xff40, 0xff40,
+        0xff70, 0xff70,
+        0xff9e, 0xff9f,
+        0xffe3, 0xffe3,
+        0xfff9, 0xfffb,
+        0x101fd, 0x101fd,
+        0x10a01, 0x10a03,
+        0x10a05, 0x10a06,
+        0x10a0c, 0x10a0f,
+        0x10a38, 0x10a3a,
+        0x10a3f, 0x10a3f,
+        0x11080, 0x11081,
+        0x110b3, 0x110b6,
+        0x110b9, 0x110ba,
+        0x110bd, 0x110bd,
+        0x1d167, 0x1d169,
+        0x1d173, 0x1d182,
+        0x1d185, 0x1d18b,
+        0x1d1aa, 0x1d1ad,
+        0x1d242, 0x1d244,
+        0xe0001, 0xe0001,
+        0xe0020, 0xe007f,
+        0xe0100, 0xe01ef,
 }; /* CR_Case_Ignorable */
 
 /* 'Changes_When_Lowercased': Derived Property */
 static const OnigCodePoint CR_Changes_When_Lowercased[] = {
-	557,
-	0x0041, 0x005a,
-	0x00c0, 0x00d6,
-	0x00d8, 0x00de,
-	0x0100, 0x0100,
-	0x0102, 0x0102,
-	0x0104, 0x0104,
-	0x0106, 0x0106,
-	0x0108, 0x0108,
-	0x010a, 0x010a,
-	0x010c, 0x010c,
-	0x010e, 0x010e,
-	0x0110, 0x0110,
-	0x0112, 0x0112,
-	0x0114, 0x0114,
-	0x0116, 0x0116,
-	0x0118, 0x0118,
-	0x011a, 0x011a,
-	0x011c, 0x011c,
-	0x011e, 0x011e,
-	0x0120, 0x0120,
-	0x0122, 0x0122,
-	0x0124, 0x0124,
-	0x0126, 0x0126,
-	0x0128, 0x0128,
-	0x012a, 0x012a,
-	0x012c, 0x012c,
-	0x012e, 0x012e,
-	0x0130, 0x0130,
-	0x0132, 0x0132,
-	0x0134, 0x0134,
-	0x0136, 0x0136,
-	0x0139, 0x0139,
-	0x013b, 0x013b,
-	0x013d, 0x013d,
-	0x013f, 0x013f,
-	0x0141, 0x0141,
-	0x0143, 0x0143,
-	0x0145, 0x0145,
-	0x0147, 0x0147,
-	0x014a, 0x014a,
-	0x014c, 0x014c,
-	0x014e, 0x014e,
-	0x0150, 0x0150,
-	0x0152, 0x0152,
-	0x0154, 0x0154,
-	0x0156, 0x0156,
-	0x0158, 0x0158,
-	0x015a, 0x015a,
-	0x015c, 0x015c,
-	0x015e, 0x015e,
-	0x0160, 0x0160,
-	0x0162, 0x0162,
-	0x0164, 0x0164,
-	0x0166, 0x0166,
-	0x0168, 0x0168,
-	0x016a, 0x016a,
-	0x016c, 0x016c,
-	0x016e, 0x016e,
-	0x0170, 0x0170,
-	0x0172, 0x0172,
-	0x0174, 0x0174,
-	0x0176, 0x0176,
-	0x0178, 0x0179,
-	0x017b, 0x017b,
-	0x017d, 0x017d,
-	0x0181, 0x0182,
-	0x0184, 0x0184,
-	0x0186, 0x0187,
-	0x0189, 0x018b,
-	0x018e, 0x0191,
-	0x0193, 0x0194,
-	0x0196, 0x0198,
-	0x019c, 0x019d,
-	0x019f, 0x01a0,
-	0x01a2, 0x01a2,
-	0x01a4, 0x01a4,
-	0x01a6, 0x01a7,
-	0x01a9, 0x01a9,
-	0x01ac, 0x01ac,
-	0x01ae, 0x01af,
-	0x01b1, 0x01b3,
-	0x01b5, 0x01b5,
-	0x01b7, 0x01b8,
-	0x01bc, 0x01bc,
-	0x01c4, 0x01c5,
-	0x01c7, 0x01c8,
-	0x01ca, 0x01cb,
-	0x01cd, 0x01cd,
-	0x01cf, 0x01cf,
-	0x01d1, 0x01d1,
-	0x01d3, 0x01d3,
-	0x01d5, 0x01d5,
-	0x01d7, 0x01d7,
-	0x01d9, 0x01d9,
-	0x01db, 0x01db,
-	0x01de, 0x01de,
-	0x01e0, 0x01e0,
-	0x01e2, 0x01e2,
-	0x01e4, 0x01e4,
-	0x01e6, 0x01e6,
-	0x01e8, 0x01e8,
-	0x01ea, 0x01ea,
-	0x01ec, 0x01ec,
-	0x01ee, 0x01ee,
-	0x01f1, 0x01f2,
-	0x01f4, 0x01f4,
-	0x01f6, 0x01f8,
-	0x01fa, 0x01fa,
-	0x01fc, 0x01fc,
-	0x01fe, 0x01fe,
-	0x0200, 0x0200,
-	0x0202, 0x0202,
-	0x0204, 0x0204,
-	0x0206, 0x0206,
-	0x0208, 0x0208,
-	0x020a, 0x020a,
-	0x020c, 0x020c,
-	0x020e, 0x020e,
-	0x0210, 0x0210,
-	0x0212, 0x0212,
-	0x0214, 0x0214,
-	0x0216, 0x0216,
-	0x0218, 0x0218,
-	0x021a, 0x021a,
-	0x021c, 0x021c,
-	0x021e, 0x021e,
-	0x0220, 0x0220,
-	0x0222, 0x0222,
-	0x0224, 0x0224,
-	0x0226, 0x0226,
-	0x0228, 0x0228,
-	0x022a, 0x022a,
-	0x022c, 0x022c,
-	0x022e, 0x022e,
-	0x0230, 0x0230,
-	0x0232, 0x0232,
-	0x023a, 0x023b,
-	0x023d, 0x023e,
-	0x0241, 0x0241,
-	0x0243, 0x0246,
-	0x0248, 0x0248,
-	0x024a, 0x024a,
-	0x024c, 0x024c,
-	0x024e, 0x024e,
-	0x0370, 0x0370,
-	0x0372, 0x0372,
-	0x0376, 0x0376,
-	0x0386, 0x0386,
-	0x0388, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x038f,
-	0x0391, 0x03a1,
-	0x03a3, 0x03ab,
-	0x03cf, 0x03cf,
-	0x03d8, 0x03d8,
-	0x03da, 0x03da,
-	0x03dc, 0x03dc,
-	0x03de, 0x03de,
-	0x03e0, 0x03e0,
-	0x03e2, 0x03e2,
-	0x03e4, 0x03e4,
-	0x03e6, 0x03e6,
-	0x03e8, 0x03e8,
-	0x03ea, 0x03ea,
-	0x03ec, 0x03ec,
-	0x03ee, 0x03ee,
-	0x03f4, 0x03f4,
-	0x03f7, 0x03f7,
-	0x03f9, 0x03fa,
-	0x03fd, 0x042f,
-	0x0460, 0x0460,
-	0x0462, 0x0462,
-	0x0464, 0x0464,
-	0x0466, 0x0466,
-	0x0468, 0x0468,
-	0x046a, 0x046a,
-	0x046c, 0x046c,
-	0x046e, 0x046e,
-	0x0470, 0x0470,
-	0x0472, 0x0472,
-	0x0474, 0x0474,
-	0x0476, 0x0476,
-	0x0478, 0x0478,
-	0x047a, 0x047a,
-	0x047c, 0x047c,
-	0x047e, 0x047e,
-	0x0480, 0x0480,
-	0x048a, 0x048a,
-	0x048c, 0x048c,
-	0x048e, 0x048e,
-	0x0490, 0x0490,
-	0x0492, 0x0492,
-	0x0494, 0x0494,
-	0x0496, 0x0496,
-	0x0498, 0x0498,
-	0x049a, 0x049a,
-	0x049c, 0x049c,
-	0x049e, 0x049e,
-	0x04a0, 0x04a0,
-	0x04a2, 0x04a2,
-	0x04a4, 0x04a4,
-	0x04a6, 0x04a6,
-	0x04a8, 0x04a8,
-	0x04aa, 0x04aa,
-	0x04ac, 0x04ac,
-	0x04ae, 0x04ae,
-	0x04b0, 0x04b0,
-	0x04b2, 0x04b2,
-	0x04b4, 0x04b4,
-	0x04b6, 0x04b6,
-	0x04b8, 0x04b8,
-	0x04ba, 0x04ba,
-	0x04bc, 0x04bc,
-	0x04be, 0x04be,
-	0x04c0, 0x04c1,
-	0x04c3, 0x04c3,
-	0x04c5, 0x04c5,
-	0x04c7, 0x04c7,
-	0x04c9, 0x04c9,
-	0x04cb, 0x04cb,
-	0x04cd, 0x04cd,
-	0x04d0, 0x04d0,
-	0x04d2, 0x04d2,
-	0x04d4, 0x04d4,
-	0x04d6, 0x04d6,
-	0x04d8, 0x04d8,
-	0x04da, 0x04da,
-	0x04dc, 0x04dc,
-	0x04de, 0x04de,
-	0x04e0, 0x04e0,
-	0x04e2, 0x04e2,
-	0x04e4, 0x04e4,
-	0x04e6, 0x04e6,
-	0x04e8, 0x04e8,
-	0x04ea, 0x04ea,
-	0x04ec, 0x04ec,
-	0x04ee, 0x04ee,
-	0x04f0, 0x04f0,
-	0x04f2, 0x04f2,
-	0x04f4, 0x04f4,
-	0x04f6, 0x04f6,
-	0x04f8, 0x04f8,
-	0x04fa, 0x04fa,
-	0x04fc, 0x04fc,
-	0x04fe, 0x04fe,
-	0x0500, 0x0500,
-	0x0502, 0x0502,
-	0x0504, 0x0504,
-	0x0506, 0x0506,
-	0x0508, 0x0508,
-	0x050a, 0x050a,
-	0x050c, 0x050c,
-	0x050e, 0x050e,
-	0x0510, 0x0510,
-	0x0512, 0x0512,
-	0x0514, 0x0514,
-	0x0516, 0x0516,
-	0x0518, 0x0518,
-	0x051a, 0x051a,
-	0x051c, 0x051c,
-	0x051e, 0x051e,
-	0x0520, 0x0520,
-	0x0522, 0x0522,
-	0x0524, 0x0524,
-	0x0531, 0x0556,
-	0x10a0, 0x10c5,
-	0x1e00, 0x1e00,
-	0x1e02, 0x1e02,
-	0x1e04, 0x1e04,
-	0x1e06, 0x1e06,
-	0x1e08, 0x1e08,
-	0x1e0a, 0x1e0a,
-	0x1e0c, 0x1e0c,
-	0x1e0e, 0x1e0e,
-	0x1e10, 0x1e10,
-	0x1e12, 0x1e12,
-	0x1e14, 0x1e14,
-	0x1e16, 0x1e16,
-	0x1e18, 0x1e18,
-	0x1e1a, 0x1e1a,
-	0x1e1c, 0x1e1c,
-	0x1e1e, 0x1e1e,
-	0x1e20, 0x1e20,
-	0x1e22, 0x1e22,
-	0x1e24, 0x1e24,
-	0x1e26, 0x1e26,
-	0x1e28, 0x1e28,
-	0x1e2a, 0x1e2a,
-	0x1e2c, 0x1e2c,
-	0x1e2e, 0x1e2e,
-	0x1e30, 0x1e30,
-	0x1e32, 0x1e32,
-	0x1e34, 0x1e34,
-	0x1e36, 0x1e36,
-	0x1e38, 0x1e38,
-	0x1e3a, 0x1e3a,
-	0x1e3c, 0x1e3c,
-	0x1e3e, 0x1e3e,
-	0x1e40, 0x1e40,
-	0x1e42, 0x1e42,
-	0x1e44, 0x1e44,
-	0x1e46, 0x1e46,
-	0x1e48, 0x1e48,
-	0x1e4a, 0x1e4a,
-	0x1e4c, 0x1e4c,
-	0x1e4e, 0x1e4e,
-	0x1e50, 0x1e50,
-	0x1e52, 0x1e52,
-	0x1e54, 0x1e54,
-	0x1e56, 0x1e56,
-	0x1e58, 0x1e58,
-	0x1e5a, 0x1e5a,
-	0x1e5c, 0x1e5c,
-	0x1e5e, 0x1e5e,
-	0x1e60, 0x1e60,
-	0x1e62, 0x1e62,
-	0x1e64, 0x1e64,
-	0x1e66, 0x1e66,
-	0x1e68, 0x1e68,
-	0x1e6a, 0x1e6a,
-	0x1e6c, 0x1e6c,
-	0x1e6e, 0x1e6e,
-	0x1e70, 0x1e70,
-	0x1e72, 0x1e72,
-	0x1e74, 0x1e74,
-	0x1e76, 0x1e76,
-	0x1e78, 0x1e78,
-	0x1e7a, 0x1e7a,
-	0x1e7c, 0x1e7c,
-	0x1e7e, 0x1e7e,
-	0x1e80, 0x1e80,
-	0x1e82, 0x1e82,
-	0x1e84, 0x1e84,
-	0x1e86, 0x1e86,
-	0x1e88, 0x1e88,
-	0x1e8a, 0x1e8a,
-	0x1e8c, 0x1e8c,
-	0x1e8e, 0x1e8e,
-	0x1e90, 0x1e90,
-	0x1e92, 0x1e92,
-	0x1e94, 0x1e94,
-	0x1e9e, 0x1e9e,
-	0x1ea0, 0x1ea0,
-	0x1ea2, 0x1ea2,
-	0x1ea4, 0x1ea4,
-	0x1ea6, 0x1ea6,
-	0x1ea8, 0x1ea8,
-	0x1eaa, 0x1eaa,
-	0x1eac, 0x1eac,
-	0x1eae, 0x1eae,
-	0x1eb0, 0x1eb0,
-	0x1eb2, 0x1eb2,
-	0x1eb4, 0x1eb4,
-	0x1eb6, 0x1eb6,
-	0x1eb8, 0x1eb8,
-	0x1eba, 0x1eba,
-	0x1ebc, 0x1ebc,
-	0x1ebe, 0x1ebe,
-	0x1ec0, 0x1ec0,
-	0x1ec2, 0x1ec2,
-	0x1ec4, 0x1ec4,
-	0x1ec6, 0x1ec6,
-	0x1ec8, 0x1ec8,
-	0x1eca, 0x1eca,
-	0x1ecc, 0x1ecc,
-	0x1ece, 0x1ece,
-	0x1ed0, 0x1ed0,
-	0x1ed2, 0x1ed2,
-	0x1ed4, 0x1ed4,
-	0x1ed6, 0x1ed6,
-	0x1ed8, 0x1ed8,
-	0x1eda, 0x1eda,
-	0x1edc, 0x1edc,
-	0x1ede, 0x1ede,
-	0x1ee0, 0x1ee0,
-	0x1ee2, 0x1ee2,
-	0x1ee4, 0x1ee4,
-	0x1ee6, 0x1ee6,
-	0x1ee8, 0x1ee8,
-	0x1eea, 0x1eea,
-	0x1eec, 0x1eec,
-	0x1eee, 0x1eee,
-	0x1ef0, 0x1ef0,
-	0x1ef2, 0x1ef2,
-	0x1ef4, 0x1ef4,
-	0x1ef6, 0x1ef6,
-	0x1ef8, 0x1ef8,
-	0x1efa, 0x1efa,
-	0x1efc, 0x1efc,
-	0x1efe, 0x1efe,
-	0x1f08, 0x1f0f,
-	0x1f18, 0x1f1d,
-	0x1f28, 0x1f2f,
-	0x1f38, 0x1f3f,
-	0x1f48, 0x1f4d,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f5f,
-	0x1f68, 0x1f6f,
-	0x1f88, 0x1f8f,
-	0x1f98, 0x1f9f,
-	0x1fa8, 0x1faf,
-	0x1fb8, 0x1fbc,
-	0x1fc8, 0x1fcc,
-	0x1fd8, 0x1fdb,
-	0x1fe8, 0x1fec,
-	0x1ff8, 0x1ffc,
-	0x2126, 0x2126,
-	0x212a, 0x212b,
-	0x2132, 0x2132,
-	0x2160, 0x216f,
-	0x2183, 0x2183,
-	0x24b6, 0x24cf,
-	0x2c00, 0x2c2e,
-	0x2c60, 0x2c60,
-	0x2c62, 0x2c64,
-	0x2c67, 0x2c67,
-	0x2c69, 0x2c69,
-	0x2c6b, 0x2c6b,
-	0x2c6d, 0x2c70,
-	0x2c72, 0x2c72,
-	0x2c75, 0x2c75,
-	0x2c7e, 0x2c80,
-	0x2c82, 0x2c82,
-	0x2c84, 0x2c84,
-	0x2c86, 0x2c86,
-	0x2c88, 0x2c88,
-	0x2c8a, 0x2c8a,
-	0x2c8c, 0x2c8c,
-	0x2c8e, 0x2c8e,
-	0x2c90, 0x2c90,
-	0x2c92, 0x2c92,
-	0x2c94, 0x2c94,
-	0x2c96, 0x2c96,
-	0x2c98, 0x2c98,
-	0x2c9a, 0x2c9a,
-	0x2c9c, 0x2c9c,
-	0x2c9e, 0x2c9e,
-	0x2ca0, 0x2ca0,
-	0x2ca2, 0x2ca2,
-	0x2ca4, 0x2ca4,
-	0x2ca6, 0x2ca6,
-	0x2ca8, 0x2ca8,
-	0x2caa, 0x2caa,
-	0x2cac, 0x2cac,
-	0x2cae, 0x2cae,
-	0x2cb0, 0x2cb0,
-	0x2cb2, 0x2cb2,
-	0x2cb4, 0x2cb4,
-	0x2cb6, 0x2cb6,
-	0x2cb8, 0x2cb8,
-	0x2cba, 0x2cba,
-	0x2cbc, 0x2cbc,
-	0x2cbe, 0x2cbe,
-	0x2cc0, 0x2cc0,
-	0x2cc2, 0x2cc2,
-	0x2cc4, 0x2cc4,
-	0x2cc6, 0x2cc6,
-	0x2cc8, 0x2cc8,
-	0x2cca, 0x2cca,
-	0x2ccc, 0x2ccc,
-	0x2cce, 0x2cce,
-	0x2cd0, 0x2cd0,
-	0x2cd2, 0x2cd2,
-	0x2cd4, 0x2cd4,
-	0x2cd6, 0x2cd6,
-	0x2cd8, 0x2cd8,
-	0x2cda, 0x2cda,
-	0x2cdc, 0x2cdc,
-	0x2cde, 0x2cde,
-	0x2ce0, 0x2ce0,
-	0x2ce2, 0x2ce2,
-	0x2ceb, 0x2ceb,
-	0x2ced, 0x2ced,
-	0xa640, 0xa640,
-	0xa642, 0xa642,
-	0xa644, 0xa644,
-	0xa646, 0xa646,
-	0xa648, 0xa648,
-	0xa64a, 0xa64a,
-	0xa64c, 0xa64c,
-	0xa64e, 0xa64e,
-	0xa650, 0xa650,
-	0xa652, 0xa652,
-	0xa654, 0xa654,
-	0xa656, 0xa656,
-	0xa658, 0xa658,
-	0xa65a, 0xa65a,
-	0xa65c, 0xa65c,
-	0xa65e, 0xa65e,
-	0xa662, 0xa662,
-	0xa664, 0xa664,
-	0xa666, 0xa666,
-	0xa668, 0xa668,
-	0xa66a, 0xa66a,
-	0xa66c, 0xa66c,
-	0xa680, 0xa680,
-	0xa682, 0xa682,
-	0xa684, 0xa684,
-	0xa686, 0xa686,
-	0xa688, 0xa688,
-	0xa68a, 0xa68a,
-	0xa68c, 0xa68c,
-	0xa68e, 0xa68e,
-	0xa690, 0xa690,
-	0xa692, 0xa692,
-	0xa694, 0xa694,
-	0xa696, 0xa696,
-	0xa722, 0xa722,
-	0xa724, 0xa724,
-	0xa726, 0xa726,
-	0xa728, 0xa728,
-	0xa72a, 0xa72a,
-	0xa72c, 0xa72c,
-	0xa72e, 0xa72e,
-	0xa732, 0xa732,
-	0xa734, 0xa734,
-	0xa736, 0xa736,
-	0xa738, 0xa738,
-	0xa73a, 0xa73a,
-	0xa73c, 0xa73c,
-	0xa73e, 0xa73e,
-	0xa740, 0xa740,
-	0xa742, 0xa742,
-	0xa744, 0xa744,
-	0xa746, 0xa746,
-	0xa748, 0xa748,
-	0xa74a, 0xa74a,
-	0xa74c, 0xa74c,
-	0xa74e, 0xa74e,
-	0xa750, 0xa750,
-	0xa752, 0xa752,
-	0xa754, 0xa754,
-	0xa756, 0xa756,
-	0xa758, 0xa758,
-	0xa75a, 0xa75a,
-	0xa75c, 0xa75c,
-	0xa75e, 0xa75e,
-	0xa760, 0xa760,
-	0xa762, 0xa762,
-	0xa764, 0xa764,
-	0xa766, 0xa766,
-	0xa768, 0xa768,
-	0xa76a, 0xa76a,
-	0xa76c, 0xa76c,
-	0xa76e, 0xa76e,
-	0xa779, 0xa779,
-	0xa77b, 0xa77b,
-	0xa77d, 0xa77e,
-	0xa780, 0xa780,
-	0xa782, 0xa782,
-	0xa784, 0xa784,
-	0xa786, 0xa786,
-	0xa78b, 0xa78b,
-	0xff21, 0xff3a,
-	0x10400, 0x10427,
+        557,
+        0x0041, 0x005a,
+        0x00c0, 0x00d6,
+        0x00d8, 0x00de,
+        0x0100, 0x0100,
+        0x0102, 0x0102,
+        0x0104, 0x0104,
+        0x0106, 0x0106,
+        0x0108, 0x0108,
+        0x010a, 0x010a,
+        0x010c, 0x010c,
+        0x010e, 0x010e,
+        0x0110, 0x0110,
+        0x0112, 0x0112,
+        0x0114, 0x0114,
+        0x0116, 0x0116,
+        0x0118, 0x0118,
+        0x011a, 0x011a,
+        0x011c, 0x011c,
+        0x011e, 0x011e,
+        0x0120, 0x0120,
+        0x0122, 0x0122,
+        0x0124, 0x0124,
+        0x0126, 0x0126,
+        0x0128, 0x0128,
+        0x012a, 0x012a,
+        0x012c, 0x012c,
+        0x012e, 0x012e,
+        0x0130, 0x0130,
+        0x0132, 0x0132,
+        0x0134, 0x0134,
+        0x0136, 0x0136,
+        0x0139, 0x0139,
+        0x013b, 0x013b,
+        0x013d, 0x013d,
+        0x013f, 0x013f,
+        0x0141, 0x0141,
+        0x0143, 0x0143,
+        0x0145, 0x0145,
+        0x0147, 0x0147,
+        0x014a, 0x014a,
+        0x014c, 0x014c,
+        0x014e, 0x014e,
+        0x0150, 0x0150,
+        0x0152, 0x0152,
+        0x0154, 0x0154,
+        0x0156, 0x0156,
+        0x0158, 0x0158,
+        0x015a, 0x015a,
+        0x015c, 0x015c,
+        0x015e, 0x015e,
+        0x0160, 0x0160,
+        0x0162, 0x0162,
+        0x0164, 0x0164,
+        0x0166, 0x0166,
+        0x0168, 0x0168,
+        0x016a, 0x016a,
+        0x016c, 0x016c,
+        0x016e, 0x016e,
+        0x0170, 0x0170,
+        0x0172, 0x0172,
+        0x0174, 0x0174,
+        0x0176, 0x0176,
+        0x0178, 0x0179,
+        0x017b, 0x017b,
+        0x017d, 0x017d,
+        0x0181, 0x0182,
+        0x0184, 0x0184,
+        0x0186, 0x0187,
+        0x0189, 0x018b,
+        0x018e, 0x0191,
+        0x0193, 0x0194,
+        0x0196, 0x0198,
+        0x019c, 0x019d,
+        0x019f, 0x01a0,
+        0x01a2, 0x01a2,
+        0x01a4, 0x01a4,
+        0x01a6, 0x01a7,
+        0x01a9, 0x01a9,
+        0x01ac, 0x01ac,
+        0x01ae, 0x01af,
+        0x01b1, 0x01b3,
+        0x01b5, 0x01b5,
+        0x01b7, 0x01b8,
+        0x01bc, 0x01bc,
+        0x01c4, 0x01c5,
+        0x01c7, 0x01c8,
+        0x01ca, 0x01cb,
+        0x01cd, 0x01cd,
+        0x01cf, 0x01cf,
+        0x01d1, 0x01d1,
+        0x01d3, 0x01d3,
+        0x01d5, 0x01d5,
+        0x01d7, 0x01d7,
+        0x01d9, 0x01d9,
+        0x01db, 0x01db,
+        0x01de, 0x01de,
+        0x01e0, 0x01e0,
+        0x01e2, 0x01e2,
+        0x01e4, 0x01e4,
+        0x01e6, 0x01e6,
+        0x01e8, 0x01e8,
+        0x01ea, 0x01ea,
+        0x01ec, 0x01ec,
+        0x01ee, 0x01ee,
+        0x01f1, 0x01f2,
+        0x01f4, 0x01f4,
+        0x01f6, 0x01f8,
+        0x01fa, 0x01fa,
+        0x01fc, 0x01fc,
+        0x01fe, 0x01fe,
+        0x0200, 0x0200,
+        0x0202, 0x0202,
+        0x0204, 0x0204,
+        0x0206, 0x0206,
+        0x0208, 0x0208,
+        0x020a, 0x020a,
+        0x020c, 0x020c,
+        0x020e, 0x020e,
+        0x0210, 0x0210,
+        0x0212, 0x0212,
+        0x0214, 0x0214,
+        0x0216, 0x0216,
+        0x0218, 0x0218,
+        0x021a, 0x021a,
+        0x021c, 0x021c,
+        0x021e, 0x021e,
+        0x0220, 0x0220,
+        0x0222, 0x0222,
+        0x0224, 0x0224,
+        0x0226, 0x0226,
+        0x0228, 0x0228,
+        0x022a, 0x022a,
+        0x022c, 0x022c,
+        0x022e, 0x022e,
+        0x0230, 0x0230,
+        0x0232, 0x0232,
+        0x023a, 0x023b,
+        0x023d, 0x023e,
+        0x0241, 0x0241,
+        0x0243, 0x0246,
+        0x0248, 0x0248,
+        0x024a, 0x024a,
+        0x024c, 0x024c,
+        0x024e, 0x024e,
+        0x0370, 0x0370,
+        0x0372, 0x0372,
+        0x0376, 0x0376,
+        0x0386, 0x0386,
+        0x0388, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x038f,
+        0x0391, 0x03a1,
+        0x03a3, 0x03ab,
+        0x03cf, 0x03cf,
+        0x03d8, 0x03d8,
+        0x03da, 0x03da,
+        0x03dc, 0x03dc,
+        0x03de, 0x03de,
+        0x03e0, 0x03e0,
+        0x03e2, 0x03e2,
+        0x03e4, 0x03e4,
+        0x03e6, 0x03e6,
+        0x03e8, 0x03e8,
+        0x03ea, 0x03ea,
+        0x03ec, 0x03ec,
+        0x03ee, 0x03ee,
+        0x03f4, 0x03f4,
+        0x03f7, 0x03f7,
+        0x03f9, 0x03fa,
+        0x03fd, 0x042f,
+        0x0460, 0x0460,
+        0x0462, 0x0462,
+        0x0464, 0x0464,
+        0x0466, 0x0466,
+        0x0468, 0x0468,
+        0x046a, 0x046a,
+        0x046c, 0x046c,
+        0x046e, 0x046e,
+        0x0470, 0x0470,
+        0x0472, 0x0472,
+        0x0474, 0x0474,
+        0x0476, 0x0476,
+        0x0478, 0x0478,
+        0x047a, 0x047a,
+        0x047c, 0x047c,
+        0x047e, 0x047e,
+        0x0480, 0x0480,
+        0x048a, 0x048a,
+        0x048c, 0x048c,
+        0x048e, 0x048e,
+        0x0490, 0x0490,
+        0x0492, 0x0492,
+        0x0494, 0x0494,
+        0x0496, 0x0496,
+        0x0498, 0x0498,
+        0x049a, 0x049a,
+        0x049c, 0x049c,
+        0x049e, 0x049e,
+        0x04a0, 0x04a0,
+        0x04a2, 0x04a2,
+        0x04a4, 0x04a4,
+        0x04a6, 0x04a6,
+        0x04a8, 0x04a8,
+        0x04aa, 0x04aa,
+        0x04ac, 0x04ac,
+        0x04ae, 0x04ae,
+        0x04b0, 0x04b0,
+        0x04b2, 0x04b2,
+        0x04b4, 0x04b4,
+        0x04b6, 0x04b6,
+        0x04b8, 0x04b8,
+        0x04ba, 0x04ba,
+        0x04bc, 0x04bc,
+        0x04be, 0x04be,
+        0x04c0, 0x04c1,
+        0x04c3, 0x04c3,
+        0x04c5, 0x04c5,
+        0x04c7, 0x04c7,
+        0x04c9, 0x04c9,
+        0x04cb, 0x04cb,
+        0x04cd, 0x04cd,
+        0x04d0, 0x04d0,
+        0x04d2, 0x04d2,
+        0x04d4, 0x04d4,
+        0x04d6, 0x04d6,
+        0x04d8, 0x04d8,
+        0x04da, 0x04da,
+        0x04dc, 0x04dc,
+        0x04de, 0x04de,
+        0x04e0, 0x04e0,
+        0x04e2, 0x04e2,
+        0x04e4, 0x04e4,
+        0x04e6, 0x04e6,
+        0x04e8, 0x04e8,
+        0x04ea, 0x04ea,
+        0x04ec, 0x04ec,
+        0x04ee, 0x04ee,
+        0x04f0, 0x04f0,
+        0x04f2, 0x04f2,
+        0x04f4, 0x04f4,
+        0x04f6, 0x04f6,
+        0x04f8, 0x04f8,
+        0x04fa, 0x04fa,
+        0x04fc, 0x04fc,
+        0x04fe, 0x04fe,
+        0x0500, 0x0500,
+        0x0502, 0x0502,
+        0x0504, 0x0504,
+        0x0506, 0x0506,
+        0x0508, 0x0508,
+        0x050a, 0x050a,
+        0x050c, 0x050c,
+        0x050e, 0x050e,
+        0x0510, 0x0510,
+        0x0512, 0x0512,
+        0x0514, 0x0514,
+        0x0516, 0x0516,
+        0x0518, 0x0518,
+        0x051a, 0x051a,
+        0x051c, 0x051c,
+        0x051e, 0x051e,
+        0x0520, 0x0520,
+        0x0522, 0x0522,
+        0x0524, 0x0524,
+        0x0531, 0x0556,
+        0x10a0, 0x10c5,
+        0x1e00, 0x1e00,
+        0x1e02, 0x1e02,
+        0x1e04, 0x1e04,
+        0x1e06, 0x1e06,
+        0x1e08, 0x1e08,
+        0x1e0a, 0x1e0a,
+        0x1e0c, 0x1e0c,
+        0x1e0e, 0x1e0e,
+        0x1e10, 0x1e10,
+        0x1e12, 0x1e12,
+        0x1e14, 0x1e14,
+        0x1e16, 0x1e16,
+        0x1e18, 0x1e18,
+        0x1e1a, 0x1e1a,
+        0x1e1c, 0x1e1c,
+        0x1e1e, 0x1e1e,
+        0x1e20, 0x1e20,
+        0x1e22, 0x1e22,
+        0x1e24, 0x1e24,
+        0x1e26, 0x1e26,
+        0x1e28, 0x1e28,
+        0x1e2a, 0x1e2a,
+        0x1e2c, 0x1e2c,
+        0x1e2e, 0x1e2e,
+        0x1e30, 0x1e30,
+        0x1e32, 0x1e32,
+        0x1e34, 0x1e34,
+        0x1e36, 0x1e36,
+        0x1e38, 0x1e38,
+        0x1e3a, 0x1e3a,
+        0x1e3c, 0x1e3c,
+        0x1e3e, 0x1e3e,
+        0x1e40, 0x1e40,
+        0x1e42, 0x1e42,
+        0x1e44, 0x1e44,
+        0x1e46, 0x1e46,
+        0x1e48, 0x1e48,
+        0x1e4a, 0x1e4a,
+        0x1e4c, 0x1e4c,
+        0x1e4e, 0x1e4e,
+        0x1e50, 0x1e50,
+        0x1e52, 0x1e52,
+        0x1e54, 0x1e54,
+        0x1e56, 0x1e56,
+        0x1e58, 0x1e58,
+        0x1e5a, 0x1e5a,
+        0x1e5c, 0x1e5c,
+        0x1e5e, 0x1e5e,
+        0x1e60, 0x1e60,
+        0x1e62, 0x1e62,
+        0x1e64, 0x1e64,
+        0x1e66, 0x1e66,
+        0x1e68, 0x1e68,
+        0x1e6a, 0x1e6a,
+        0x1e6c, 0x1e6c,
+        0x1e6e, 0x1e6e,
+        0x1e70, 0x1e70,
+        0x1e72, 0x1e72,
+        0x1e74, 0x1e74,
+        0x1e76, 0x1e76,
+        0x1e78, 0x1e78,
+        0x1e7a, 0x1e7a,
+        0x1e7c, 0x1e7c,
+        0x1e7e, 0x1e7e,
+        0x1e80, 0x1e80,
+        0x1e82, 0x1e82,
+        0x1e84, 0x1e84,
+        0x1e86, 0x1e86,
+        0x1e88, 0x1e88,
+        0x1e8a, 0x1e8a,
+        0x1e8c, 0x1e8c,
+        0x1e8e, 0x1e8e,
+        0x1e90, 0x1e90,
+        0x1e92, 0x1e92,
+        0x1e94, 0x1e94,
+        0x1e9e, 0x1e9e,
+        0x1ea0, 0x1ea0,
+        0x1ea2, 0x1ea2,
+        0x1ea4, 0x1ea4,
+        0x1ea6, 0x1ea6,
+        0x1ea8, 0x1ea8,
+        0x1eaa, 0x1eaa,
+        0x1eac, 0x1eac,
+        0x1eae, 0x1eae,
+        0x1eb0, 0x1eb0,
+        0x1eb2, 0x1eb2,
+        0x1eb4, 0x1eb4,
+        0x1eb6, 0x1eb6,
+        0x1eb8, 0x1eb8,
+        0x1eba, 0x1eba,
+        0x1ebc, 0x1ebc,
+        0x1ebe, 0x1ebe,
+        0x1ec0, 0x1ec0,
+        0x1ec2, 0x1ec2,
+        0x1ec4, 0x1ec4,
+        0x1ec6, 0x1ec6,
+        0x1ec8, 0x1ec8,
+        0x1eca, 0x1eca,
+        0x1ecc, 0x1ecc,
+        0x1ece, 0x1ece,
+        0x1ed0, 0x1ed0,
+        0x1ed2, 0x1ed2,
+        0x1ed4, 0x1ed4,
+        0x1ed6, 0x1ed6,
+        0x1ed8, 0x1ed8,
+        0x1eda, 0x1eda,
+        0x1edc, 0x1edc,
+        0x1ede, 0x1ede,
+        0x1ee0, 0x1ee0,
+        0x1ee2, 0x1ee2,
+        0x1ee4, 0x1ee4,
+        0x1ee6, 0x1ee6,
+        0x1ee8, 0x1ee8,
+        0x1eea, 0x1eea,
+        0x1eec, 0x1eec,
+        0x1eee, 0x1eee,
+        0x1ef0, 0x1ef0,
+        0x1ef2, 0x1ef2,
+        0x1ef4, 0x1ef4,
+        0x1ef6, 0x1ef6,
+        0x1ef8, 0x1ef8,
+        0x1efa, 0x1efa,
+        0x1efc, 0x1efc,
+        0x1efe, 0x1efe,
+        0x1f08, 0x1f0f,
+        0x1f18, 0x1f1d,
+        0x1f28, 0x1f2f,
+        0x1f38, 0x1f3f,
+        0x1f48, 0x1f4d,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f5f,
+        0x1f68, 0x1f6f,
+        0x1f88, 0x1f8f,
+        0x1f98, 0x1f9f,
+        0x1fa8, 0x1faf,
+        0x1fb8, 0x1fbc,
+        0x1fc8, 0x1fcc,
+        0x1fd8, 0x1fdb,
+        0x1fe8, 0x1fec,
+        0x1ff8, 0x1ffc,
+        0x2126, 0x2126,
+        0x212a, 0x212b,
+        0x2132, 0x2132,
+        0x2160, 0x216f,
+        0x2183, 0x2183,
+        0x24b6, 0x24cf,
+        0x2c00, 0x2c2e,
+        0x2c60, 0x2c60,
+        0x2c62, 0x2c64,
+        0x2c67, 0x2c67,
+        0x2c69, 0x2c69,
+        0x2c6b, 0x2c6b,
+        0x2c6d, 0x2c70,
+        0x2c72, 0x2c72,
+        0x2c75, 0x2c75,
+        0x2c7e, 0x2c80,
+        0x2c82, 0x2c82,
+        0x2c84, 0x2c84,
+        0x2c86, 0x2c86,
+        0x2c88, 0x2c88,
+        0x2c8a, 0x2c8a,
+        0x2c8c, 0x2c8c,
+        0x2c8e, 0x2c8e,
+        0x2c90, 0x2c90,
+        0x2c92, 0x2c92,
+        0x2c94, 0x2c94,
+        0x2c96, 0x2c96,
+        0x2c98, 0x2c98,
+        0x2c9a, 0x2c9a,
+        0x2c9c, 0x2c9c,
+        0x2c9e, 0x2c9e,
+        0x2ca0, 0x2ca0,
+        0x2ca2, 0x2ca2,
+        0x2ca4, 0x2ca4,
+        0x2ca6, 0x2ca6,
+        0x2ca8, 0x2ca8,
+        0x2caa, 0x2caa,
+        0x2cac, 0x2cac,
+        0x2cae, 0x2cae,
+        0x2cb0, 0x2cb0,
+        0x2cb2, 0x2cb2,
+        0x2cb4, 0x2cb4,
+        0x2cb6, 0x2cb6,
+        0x2cb8, 0x2cb8,
+        0x2cba, 0x2cba,
+        0x2cbc, 0x2cbc,
+        0x2cbe, 0x2cbe,
+        0x2cc0, 0x2cc0,
+        0x2cc2, 0x2cc2,
+        0x2cc4, 0x2cc4,
+        0x2cc6, 0x2cc6,
+        0x2cc8, 0x2cc8,
+        0x2cca, 0x2cca,
+        0x2ccc, 0x2ccc,
+        0x2cce, 0x2cce,
+        0x2cd0, 0x2cd0,
+        0x2cd2, 0x2cd2,
+        0x2cd4, 0x2cd4,
+        0x2cd6, 0x2cd6,
+        0x2cd8, 0x2cd8,
+        0x2cda, 0x2cda,
+        0x2cdc, 0x2cdc,
+        0x2cde, 0x2cde,
+        0x2ce0, 0x2ce0,
+        0x2ce2, 0x2ce2,
+        0x2ceb, 0x2ceb,
+        0x2ced, 0x2ced,
+        0xa640, 0xa640,
+        0xa642, 0xa642,
+        0xa644, 0xa644,
+        0xa646, 0xa646,
+        0xa648, 0xa648,
+        0xa64a, 0xa64a,
+        0xa64c, 0xa64c,
+        0xa64e, 0xa64e,
+        0xa650, 0xa650,
+        0xa652, 0xa652,
+        0xa654, 0xa654,
+        0xa656, 0xa656,
+        0xa658, 0xa658,
+        0xa65a, 0xa65a,
+        0xa65c, 0xa65c,
+        0xa65e, 0xa65e,
+        0xa662, 0xa662,
+        0xa664, 0xa664,
+        0xa666, 0xa666,
+        0xa668, 0xa668,
+        0xa66a, 0xa66a,
+        0xa66c, 0xa66c,
+        0xa680, 0xa680,
+        0xa682, 0xa682,
+        0xa684, 0xa684,
+        0xa686, 0xa686,
+        0xa688, 0xa688,
+        0xa68a, 0xa68a,
+        0xa68c, 0xa68c,
+        0xa68e, 0xa68e,
+        0xa690, 0xa690,
+        0xa692, 0xa692,
+        0xa694, 0xa694,
+        0xa696, 0xa696,
+        0xa722, 0xa722,
+        0xa724, 0xa724,
+        0xa726, 0xa726,
+        0xa728, 0xa728,
+        0xa72a, 0xa72a,
+        0xa72c, 0xa72c,
+        0xa72e, 0xa72e,
+        0xa732, 0xa732,
+        0xa734, 0xa734,
+        0xa736, 0xa736,
+        0xa738, 0xa738,
+        0xa73a, 0xa73a,
+        0xa73c, 0xa73c,
+        0xa73e, 0xa73e,
+        0xa740, 0xa740,
+        0xa742, 0xa742,
+        0xa744, 0xa744,
+        0xa746, 0xa746,
+        0xa748, 0xa748,
+        0xa74a, 0xa74a,
+        0xa74c, 0xa74c,
+        0xa74e, 0xa74e,
+        0xa750, 0xa750,
+        0xa752, 0xa752,
+        0xa754, 0xa754,
+        0xa756, 0xa756,
+        0xa758, 0xa758,
+        0xa75a, 0xa75a,
+        0xa75c, 0xa75c,
+        0xa75e, 0xa75e,
+        0xa760, 0xa760,
+        0xa762, 0xa762,
+        0xa764, 0xa764,
+        0xa766, 0xa766,
+        0xa768, 0xa768,
+        0xa76a, 0xa76a,
+        0xa76c, 0xa76c,
+        0xa76e, 0xa76e,
+        0xa779, 0xa779,
+        0xa77b, 0xa77b,
+        0xa77d, 0xa77e,
+        0xa780, 0xa780,
+        0xa782, 0xa782,
+        0xa784, 0xa784,
+        0xa786, 0xa786,
+        0xa78b, 0xa78b,
+        0xff21, 0xff3a,
+        0x10400, 0x10427,
 }; /* CR_Changes_When_Lowercased */
 
 /* 'Changes_When_Uppercased': Derived Property */
 static const OnigCodePoint CR_Changes_When_Uppercased[] = {
-	573,
-	0x0061, 0x007a,
-	0x00b5, 0x00b5,
-	0x00df, 0x00f6,
-	0x00f8, 0x00ff,
-	0x0101, 0x0101,
-	0x0103, 0x0103,
-	0x0105, 0x0105,
-	0x0107, 0x0107,
-	0x0109, 0x0109,
-	0x010b, 0x010b,
-	0x010d, 0x010d,
-	0x010f, 0x010f,
-	0x0111, 0x0111,
-	0x0113, 0x0113,
-	0x0115, 0x0115,
-	0x0117, 0x0117,
-	0x0119, 0x0119,
-	0x011b, 0x011b,
-	0x011d, 0x011d,
-	0x011f, 0x011f,
-	0x0121, 0x0121,
-	0x0123, 0x0123,
-	0x0125, 0x0125,
-	0x0127, 0x0127,
-	0x0129, 0x0129,
-	0x012b, 0x012b,
-	0x012d, 0x012d,
-	0x012f, 0x012f,
-	0x0131, 0x0131,
-	0x0133, 0x0133,
-	0x0135, 0x0135,
-	0x0137, 0x0137,
-	0x013a, 0x013a,
-	0x013c, 0x013c,
-	0x013e, 0x013e,
-	0x0140, 0x0140,
-	0x0142, 0x0142,
-	0x0144, 0x0144,
-	0x0146, 0x0146,
-	0x0148, 0x0149,
-	0x014b, 0x014b,
-	0x014d, 0x014d,
-	0x014f, 0x014f,
-	0x0151, 0x0151,
-	0x0153, 0x0153,
-	0x0155, 0x0155,
-	0x0157, 0x0157,
-	0x0159, 0x0159,
-	0x015b, 0x015b,
-	0x015d, 0x015d,
-	0x015f, 0x015f,
-	0x0161, 0x0161,
-	0x0163, 0x0163,
-	0x0165, 0x0165,
-	0x0167, 0x0167,
-	0x0169, 0x0169,
-	0x016b, 0x016b,
-	0x016d, 0x016d,
-	0x016f, 0x016f,
-	0x0171, 0x0171,
-	0x0173, 0x0173,
-	0x0175, 0x0175,
-	0x0177, 0x0177,
-	0x017a, 0x017a,
-	0x017c, 0x017c,
-	0x017e, 0x0180,
-	0x0183, 0x0183,
-	0x0185, 0x0185,
-	0x0188, 0x0188,
-	0x018c, 0x018c,
-	0x0192, 0x0192,
-	0x0195, 0x0195,
-	0x0199, 0x019a,
-	0x019e, 0x019e,
-	0x01a1, 0x01a1,
-	0x01a3, 0x01a3,
-	0x01a5, 0x01a5,
-	0x01a8, 0x01a8,
-	0x01ad, 0x01ad,
-	0x01b0, 0x01b0,
-	0x01b4, 0x01b4,
-	0x01b6, 0x01b6,
-	0x01b9, 0x01b9,
-	0x01bd, 0x01bd,
-	0x01bf, 0x01bf,
-	0x01c5, 0x01c6,
-	0x01c8, 0x01c9,
-	0x01cb, 0x01cc,
-	0x01ce, 0x01ce,
-	0x01d0, 0x01d0,
-	0x01d2, 0x01d2,
-	0x01d4, 0x01d4,
-	0x01d6, 0x01d6,
-	0x01d8, 0x01d8,
-	0x01da, 0x01da,
-	0x01dc, 0x01dd,
-	0x01df, 0x01df,
-	0x01e1, 0x01e1,
-	0x01e3, 0x01e3,
-	0x01e5, 0x01e5,
-	0x01e7, 0x01e7,
-	0x01e9, 0x01e9,
-	0x01eb, 0x01eb,
-	0x01ed, 0x01ed,
-	0x01ef, 0x01f0,
-	0x01f2, 0x01f3,
-	0x01f5, 0x01f5,
-	0x01f9, 0x01f9,
-	0x01fb, 0x01fb,
-	0x01fd, 0x01fd,
-	0x01ff, 0x01ff,
-	0x0201, 0x0201,
-	0x0203, 0x0203,
-	0x0205, 0x0205,
-	0x0207, 0x0207,
-	0x0209, 0x0209,
-	0x020b, 0x020b,
-	0x020d, 0x020d,
-	0x020f, 0x020f,
-	0x0211, 0x0211,
-	0x0213, 0x0213,
-	0x0215, 0x0215,
-	0x0217, 0x0217,
-	0x0219, 0x0219,
-	0x021b, 0x021b,
-	0x021d, 0x021d,
-	0x021f, 0x021f,
-	0x0223, 0x0223,
-	0x0225, 0x0225,
-	0x0227, 0x0227,
-	0x0229, 0x0229,
-	0x022b, 0x022b,
-	0x022d, 0x022d,
-	0x022f, 0x022f,
-	0x0231, 0x0231,
-	0x0233, 0x0233,
-	0x023c, 0x023c,
-	0x023f, 0x0240,
-	0x0242, 0x0242,
-	0x0247, 0x0247,
-	0x0249, 0x0249,
-	0x024b, 0x024b,
-	0x024d, 0x024d,
-	0x024f, 0x0254,
-	0x0256, 0x0257,
-	0x0259, 0x0259,
-	0x025b, 0x025b,
-	0x0260, 0x0260,
-	0x0263, 0x0263,
-	0x0268, 0x0269,
-	0x026b, 0x026b,
-	0x026f, 0x026f,
-	0x0271, 0x0272,
-	0x0275, 0x0275,
-	0x027d, 0x027d,
-	0x0280, 0x0280,
-	0x0283, 0x0283,
-	0x0288, 0x028c,
-	0x0292, 0x0292,
-	0x0345, 0x0345,
-	0x0371, 0x0371,
-	0x0373, 0x0373,
-	0x0377, 0x0377,
-	0x037b, 0x037d,
-	0x0390, 0x0390,
-	0x03ac, 0x03ce,
-	0x03d0, 0x03d1,
-	0x03d5, 0x03d7,
-	0x03d9, 0x03d9,
-	0x03db, 0x03db,
-	0x03dd, 0x03dd,
-	0x03df, 0x03df,
-	0x03e1, 0x03e1,
-	0x03e3, 0x03e3,
-	0x03e5, 0x03e5,
-	0x03e7, 0x03e7,
-	0x03e9, 0x03e9,
-	0x03eb, 0x03eb,
-	0x03ed, 0x03ed,
-	0x03ef, 0x03f2,
-	0x03f5, 0x03f5,
-	0x03f8, 0x03f8,
-	0x03fb, 0x03fb,
-	0x0430, 0x045f,
-	0x0461, 0x0461,
-	0x0463, 0x0463,
-	0x0465, 0x0465,
-	0x0467, 0x0467,
-	0x0469, 0x0469,
-	0x046b, 0x046b,
-	0x046d, 0x046d,
-	0x046f, 0x046f,
-	0x0471, 0x0471,
-	0x0473, 0x0473,
-	0x0475, 0x0475,
-	0x0477, 0x0477,
-	0x0479, 0x0479,
-	0x047b, 0x047b,
-	0x047d, 0x047d,
-	0x047f, 0x047f,
-	0x0481, 0x0481,
-	0x048b, 0x048b,
-	0x048d, 0x048d,
-	0x048f, 0x048f,
-	0x0491, 0x0491,
-	0x0493, 0x0493,
-	0x0495, 0x0495,
-	0x0497, 0x0497,
-	0x0499, 0x0499,
-	0x049b, 0x049b,
-	0x049d, 0x049d,
-	0x049f, 0x049f,
-	0x04a1, 0x04a1,
-	0x04a3, 0x04a3,
-	0x04a5, 0x04a5,
-	0x04a7, 0x04a7,
-	0x04a9, 0x04a9,
-	0x04ab, 0x04ab,
-	0x04ad, 0x04ad,
-	0x04af, 0x04af,
-	0x04b1, 0x04b1,
-	0x04b3, 0x04b3,
-	0x04b5, 0x04b5,
-	0x04b7, 0x04b7,
-	0x04b9, 0x04b9,
-	0x04bb, 0x04bb,
-	0x04bd, 0x04bd,
-	0x04bf, 0x04bf,
-	0x04c2, 0x04c2,
-	0x04c4, 0x04c4,
-	0x04c6, 0x04c6,
-	0x04c8, 0x04c8,
-	0x04ca, 0x04ca,
-	0x04cc, 0x04cc,
-	0x04ce, 0x04cf,
-	0x04d1, 0x04d1,
-	0x04d3, 0x04d3,
-	0x04d5, 0x04d5,
-	0x04d7, 0x04d7,
-	0x04d9, 0x04d9,
-	0x04db, 0x04db,
-	0x04dd, 0x04dd,
-	0x04df, 0x04df,
-	0x04e1, 0x04e1,
-	0x04e3, 0x04e3,
-	0x04e5, 0x04e5,
-	0x04e7, 0x04e7,
-	0x04e9, 0x04e9,
-	0x04eb, 0x04eb,
-	0x04ed, 0x04ed,
-	0x04ef, 0x04ef,
-	0x04f1, 0x04f1,
-	0x04f3, 0x04f3,
-	0x04f5, 0x04f5,
-	0x04f7, 0x04f7,
-	0x04f9, 0x04f9,
-	0x04fb, 0x04fb,
-	0x04fd, 0x04fd,
-	0x04ff, 0x04ff,
-	0x0501, 0x0501,
-	0x0503, 0x0503,
-	0x0505, 0x0505,
-	0x0507, 0x0507,
-	0x0509, 0x0509,
-	0x050b, 0x050b,
-	0x050d, 0x050d,
-	0x050f, 0x050f,
-	0x0511, 0x0511,
-	0x0513, 0x0513,
-	0x0515, 0x0515,
-	0x0517, 0x0517,
-	0x0519, 0x0519,
-	0x051b, 0x051b,
-	0x051d, 0x051d,
-	0x051f, 0x051f,
-	0x0521, 0x0521,
-	0x0523, 0x0523,
-	0x0525, 0x0525,
-	0x0561, 0x0587,
-	0x1d79, 0x1d79,
-	0x1d7d, 0x1d7d,
-	0x1e01, 0x1e01,
-	0x1e03, 0x1e03,
-	0x1e05, 0x1e05,
-	0x1e07, 0x1e07,
-	0x1e09, 0x1e09,
-	0x1e0b, 0x1e0b,
-	0x1e0d, 0x1e0d,
-	0x1e0f, 0x1e0f,
-	0x1e11, 0x1e11,
-	0x1e13, 0x1e13,
-	0x1e15, 0x1e15,
-	0x1e17, 0x1e17,
-	0x1e19, 0x1e19,
-	0x1e1b, 0x1e1b,
-	0x1e1d, 0x1e1d,
-	0x1e1f, 0x1e1f,
-	0x1e21, 0x1e21,
-	0x1e23, 0x1e23,
-	0x1e25, 0x1e25,
-	0x1e27, 0x1e27,
-	0x1e29, 0x1e29,
-	0x1e2b, 0x1e2b,
-	0x1e2d, 0x1e2d,
-	0x1e2f, 0x1e2f,
-	0x1e31, 0x1e31,
-	0x1e33, 0x1e33,
-	0x1e35, 0x1e35,
-	0x1e37, 0x1e37,
-	0x1e39, 0x1e39,
-	0x1e3b, 0x1e3b,
-	0x1e3d, 0x1e3d,
-	0x1e3f, 0x1e3f,
-	0x1e41, 0x1e41,
-	0x1e43, 0x1e43,
-	0x1e45, 0x1e45,
-	0x1e47, 0x1e47,
-	0x1e49, 0x1e49,
-	0x1e4b, 0x1e4b,
-	0x1e4d, 0x1e4d,
-	0x1e4f, 0x1e4f,
-	0x1e51, 0x1e51,
-	0x1e53, 0x1e53,
-	0x1e55, 0x1e55,
-	0x1e57, 0x1e57,
-	0x1e59, 0x1e59,
-	0x1e5b, 0x1e5b,
-	0x1e5d, 0x1e5d,
-	0x1e5f, 0x1e5f,
-	0x1e61, 0x1e61,
-	0x1e63, 0x1e63,
-	0x1e65, 0x1e65,
-	0x1e67, 0x1e67,
-	0x1e69, 0x1e69,
-	0x1e6b, 0x1e6b,
-	0x1e6d, 0x1e6d,
-	0x1e6f, 0x1e6f,
-	0x1e71, 0x1e71,
-	0x1e73, 0x1e73,
-	0x1e75, 0x1e75,
-	0x1e77, 0x1e77,
-	0x1e79, 0x1e79,
-	0x1e7b, 0x1e7b,
-	0x1e7d, 0x1e7d,
-	0x1e7f, 0x1e7f,
-	0x1e81, 0x1e81,
-	0x1e83, 0x1e83,
-	0x1e85, 0x1e85,
-	0x1e87, 0x1e87,
-	0x1e89, 0x1e89,
-	0x1e8b, 0x1e8b,
-	0x1e8d, 0x1e8d,
-	0x1e8f, 0x1e8f,
-	0x1e91, 0x1e91,
-	0x1e93, 0x1e93,
-	0x1e95, 0x1e9b,
-	0x1ea1, 0x1ea1,
-	0x1ea3, 0x1ea3,
-	0x1ea5, 0x1ea5,
-	0x1ea7, 0x1ea7,
-	0x1ea9, 0x1ea9,
-	0x1eab, 0x1eab,
-	0x1ead, 0x1ead,
-	0x1eaf, 0x1eaf,
-	0x1eb1, 0x1eb1,
-	0x1eb3, 0x1eb3,
-	0x1eb5, 0x1eb5,
-	0x1eb7, 0x1eb7,
-	0x1eb9, 0x1eb9,
-	0x1ebb, 0x1ebb,
-	0x1ebd, 0x1ebd,
-	0x1ebf, 0x1ebf,
-	0x1ec1, 0x1ec1,
-	0x1ec3, 0x1ec3,
-	0x1ec5, 0x1ec5,
-	0x1ec7, 0x1ec7,
-	0x1ec9, 0x1ec9,
-	0x1ecb, 0x1ecb,
-	0x1ecd, 0x1ecd,
-	0x1ecf, 0x1ecf,
-	0x1ed1, 0x1ed1,
-	0x1ed3, 0x1ed3,
-	0x1ed5, 0x1ed5,
-	0x1ed7, 0x1ed7,
-	0x1ed9, 0x1ed9,
-	0x1edb, 0x1edb,
-	0x1edd, 0x1edd,
-	0x1edf, 0x1edf,
-	0x1ee1, 0x1ee1,
-	0x1ee3, 0x1ee3,
-	0x1ee5, 0x1ee5,
-	0x1ee7, 0x1ee7,
-	0x1ee9, 0x1ee9,
-	0x1eeb, 0x1eeb,
-	0x1eed, 0x1eed,
-	0x1eef, 0x1eef,
-	0x1ef1, 0x1ef1,
-	0x1ef3, 0x1ef3,
-	0x1ef5, 0x1ef5,
-	0x1ef7, 0x1ef7,
-	0x1ef9, 0x1ef9,
-	0x1efb, 0x1efb,
-	0x1efd, 0x1efd,
-	0x1eff, 0x1f07,
-	0x1f10, 0x1f15,
-	0x1f20, 0x1f27,
-	0x1f30, 0x1f37,
-	0x1f40, 0x1f45,
-	0x1f50, 0x1f57,
-	0x1f60, 0x1f67,
-	0x1f70, 0x1f7d,
-	0x1f80, 0x1fb4,
-	0x1fb6, 0x1fb7,
-	0x1fbc, 0x1fbc,
-	0x1fbe, 0x1fbe,
-	0x1fc2, 0x1fc4,
-	0x1fc6, 0x1fc7,
-	0x1fcc, 0x1fcc,
-	0x1fd0, 0x1fd3,
-	0x1fd6, 0x1fd7,
-	0x1fe0, 0x1fe7,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ff7,
-	0x1ffc, 0x1ffc,
-	0x214e, 0x214e,
-	0x2170, 0x217f,
-	0x2184, 0x2184,
-	0x24d0, 0x24e9,
-	0x2c30, 0x2c5e,
-	0x2c61, 0x2c61,
-	0x2c65, 0x2c66,
-	0x2c68, 0x2c68,
-	0x2c6a, 0x2c6a,
-	0x2c6c, 0x2c6c,
-	0x2c73, 0x2c73,
-	0x2c76, 0x2c76,
-	0x2c81, 0x2c81,
-	0x2c83, 0x2c83,
-	0x2c85, 0x2c85,
-	0x2c87, 0x2c87,
-	0x2c89, 0x2c89,
-	0x2c8b, 0x2c8b,
-	0x2c8d, 0x2c8d,
-	0x2c8f, 0x2c8f,
-	0x2c91, 0x2c91,
-	0x2c93, 0x2c93,
-	0x2c95, 0x2c95,
-	0x2c97, 0x2c97,
-	0x2c99, 0x2c99,
-	0x2c9b, 0x2c9b,
-	0x2c9d, 0x2c9d,
-	0x2c9f, 0x2c9f,
-	0x2ca1, 0x2ca1,
-	0x2ca3, 0x2ca3,
-	0x2ca5, 0x2ca5,
-	0x2ca7, 0x2ca7,
-	0x2ca9, 0x2ca9,
-	0x2cab, 0x2cab,
-	0x2cad, 0x2cad,
-	0x2caf, 0x2caf,
-	0x2cb1, 0x2cb1,
-	0x2cb3, 0x2cb3,
-	0x2cb5, 0x2cb5,
-	0x2cb7, 0x2cb7,
-	0x2cb9, 0x2cb9,
-	0x2cbb, 0x2cbb,
-	0x2cbd, 0x2cbd,
-	0x2cbf, 0x2cbf,
-	0x2cc1, 0x2cc1,
-	0x2cc3, 0x2cc3,
-	0x2cc5, 0x2cc5,
-	0x2cc7, 0x2cc7,
-	0x2cc9, 0x2cc9,
-	0x2ccb, 0x2ccb,
-	0x2ccd, 0x2ccd,
-	0x2ccf, 0x2ccf,
-	0x2cd1, 0x2cd1,
-	0x2cd3, 0x2cd3,
-	0x2cd5, 0x2cd5,
-	0x2cd7, 0x2cd7,
-	0x2cd9, 0x2cd9,
-	0x2cdb, 0x2cdb,
-	0x2cdd, 0x2cdd,
-	0x2cdf, 0x2cdf,
-	0x2ce1, 0x2ce1,
-	0x2ce3, 0x2ce3,
-	0x2cec, 0x2cec,
-	0x2cee, 0x2cee,
-	0x2d00, 0x2d25,
-	0xa641, 0xa641,
-	0xa643, 0xa643,
-	0xa645, 0xa645,
-	0xa647, 0xa647,
-	0xa649, 0xa649,
-	0xa64b, 0xa64b,
-	0xa64d, 0xa64d,
-	0xa64f, 0xa64f,
-	0xa651, 0xa651,
-	0xa653, 0xa653,
-	0xa655, 0xa655,
-	0xa657, 0xa657,
-	0xa659, 0xa659,
-	0xa65b, 0xa65b,
-	0xa65d, 0xa65d,
-	0xa65f, 0xa65f,
-	0xa663, 0xa663,
-	0xa665, 0xa665,
-	0xa667, 0xa667,
-	0xa669, 0xa669,
-	0xa66b, 0xa66b,
-	0xa66d, 0xa66d,
-	0xa681, 0xa681,
-	0xa683, 0xa683,
-	0xa685, 0xa685,
-	0xa687, 0xa687,
-	0xa689, 0xa689,
-	0xa68b, 0xa68b,
-	0xa68d, 0xa68d,
-	0xa68f, 0xa68f,
-	0xa691, 0xa691,
-	0xa693, 0xa693,
-	0xa695, 0xa695,
-	0xa697, 0xa697,
-	0xa723, 0xa723,
-	0xa725, 0xa725,
-	0xa727, 0xa727,
-	0xa729, 0xa729,
-	0xa72b, 0xa72b,
-	0xa72d, 0xa72d,
-	0xa72f, 0xa72f,
-	0xa733, 0xa733,
-	0xa735, 0xa735,
-	0xa737, 0xa737,
-	0xa739, 0xa739,
-	0xa73b, 0xa73b,
-	0xa73d, 0xa73d,
-	0xa73f, 0xa73f,
-	0xa741, 0xa741,
-	0xa743, 0xa743,
-	0xa745, 0xa745,
-	0xa747, 0xa747,
-	0xa749, 0xa749,
-	0xa74b, 0xa74b,
-	0xa74d, 0xa74d,
-	0xa74f, 0xa74f,
-	0xa751, 0xa751,
-	0xa753, 0xa753,
-	0xa755, 0xa755,
-	0xa757, 0xa757,
-	0xa759, 0xa759,
-	0xa75b, 0xa75b,
-	0xa75d, 0xa75d,
-	0xa75f, 0xa75f,
-	0xa761, 0xa761,
-	0xa763, 0xa763,
-	0xa765, 0xa765,
-	0xa767, 0xa767,
-	0xa769, 0xa769,
-	0xa76b, 0xa76b,
-	0xa76d, 0xa76d,
-	0xa76f, 0xa76f,
-	0xa77a, 0xa77a,
-	0xa77c, 0xa77c,
-	0xa77f, 0xa77f,
-	0xa781, 0xa781,
-	0xa783, 0xa783,
-	0xa785, 0xa785,
-	0xa787, 0xa787,
-	0xa78c, 0xa78c,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xff41, 0xff5a,
-	0x10428, 0x1044f,
+        573,
+        0x0061, 0x007a,
+        0x00b5, 0x00b5,
+        0x00df, 0x00f6,
+        0x00f8, 0x00ff,
+        0x0101, 0x0101,
+        0x0103, 0x0103,
+        0x0105, 0x0105,
+        0x0107, 0x0107,
+        0x0109, 0x0109,
+        0x010b, 0x010b,
+        0x010d, 0x010d,
+        0x010f, 0x010f,
+        0x0111, 0x0111,
+        0x0113, 0x0113,
+        0x0115, 0x0115,
+        0x0117, 0x0117,
+        0x0119, 0x0119,
+        0x011b, 0x011b,
+        0x011d, 0x011d,
+        0x011f, 0x011f,
+        0x0121, 0x0121,
+        0x0123, 0x0123,
+        0x0125, 0x0125,
+        0x0127, 0x0127,
+        0x0129, 0x0129,
+        0x012b, 0x012b,
+        0x012d, 0x012d,
+        0x012f, 0x012f,
+        0x0131, 0x0131,
+        0x0133, 0x0133,
+        0x0135, 0x0135,
+        0x0137, 0x0137,
+        0x013a, 0x013a,
+        0x013c, 0x013c,
+        0x013e, 0x013e,
+        0x0140, 0x0140,
+        0x0142, 0x0142,
+        0x0144, 0x0144,
+        0x0146, 0x0146,
+        0x0148, 0x0149,
+        0x014b, 0x014b,
+        0x014d, 0x014d,
+        0x014f, 0x014f,
+        0x0151, 0x0151,
+        0x0153, 0x0153,
+        0x0155, 0x0155,
+        0x0157, 0x0157,
+        0x0159, 0x0159,
+        0x015b, 0x015b,
+        0x015d, 0x015d,
+        0x015f, 0x015f,
+        0x0161, 0x0161,
+        0x0163, 0x0163,
+        0x0165, 0x0165,
+        0x0167, 0x0167,
+        0x0169, 0x0169,
+        0x016b, 0x016b,
+        0x016d, 0x016d,
+        0x016f, 0x016f,
+        0x0171, 0x0171,
+        0x0173, 0x0173,
+        0x0175, 0x0175,
+        0x0177, 0x0177,
+        0x017a, 0x017a,
+        0x017c, 0x017c,
+        0x017e, 0x0180,
+        0x0183, 0x0183,
+        0x0185, 0x0185,
+        0x0188, 0x0188,
+        0x018c, 0x018c,
+        0x0192, 0x0192,
+        0x0195, 0x0195,
+        0x0199, 0x019a,
+        0x019e, 0x019e,
+        0x01a1, 0x01a1,
+        0x01a3, 0x01a3,
+        0x01a5, 0x01a5,
+        0x01a8, 0x01a8,
+        0x01ad, 0x01ad,
+        0x01b0, 0x01b0,
+        0x01b4, 0x01b4,
+        0x01b6, 0x01b6,
+        0x01b9, 0x01b9,
+        0x01bd, 0x01bd,
+        0x01bf, 0x01bf,
+        0x01c5, 0x01c6,
+        0x01c8, 0x01c9,
+        0x01cb, 0x01cc,
+        0x01ce, 0x01ce,
+        0x01d0, 0x01d0,
+        0x01d2, 0x01d2,
+        0x01d4, 0x01d4,
+        0x01d6, 0x01d6,
+        0x01d8, 0x01d8,
+        0x01da, 0x01da,
+        0x01dc, 0x01dd,
+        0x01df, 0x01df,
+        0x01e1, 0x01e1,
+        0x01e3, 0x01e3,
+        0x01e5, 0x01e5,
+        0x01e7, 0x01e7,
+        0x01e9, 0x01e9,
+        0x01eb, 0x01eb,
+        0x01ed, 0x01ed,
+        0x01ef, 0x01f0,
+        0x01f2, 0x01f3,
+        0x01f5, 0x01f5,
+        0x01f9, 0x01f9,
+        0x01fb, 0x01fb,
+        0x01fd, 0x01fd,
+        0x01ff, 0x01ff,
+        0x0201, 0x0201,
+        0x0203, 0x0203,
+        0x0205, 0x0205,
+        0x0207, 0x0207,
+        0x0209, 0x0209,
+        0x020b, 0x020b,
+        0x020d, 0x020d,
+        0x020f, 0x020f,
+        0x0211, 0x0211,
+        0x0213, 0x0213,
+        0x0215, 0x0215,
+        0x0217, 0x0217,
+        0x0219, 0x0219,
+        0x021b, 0x021b,
+        0x021d, 0x021d,
+        0x021f, 0x021f,
+        0x0223, 0x0223,
+        0x0225, 0x0225,
+        0x0227, 0x0227,
+        0x0229, 0x0229,
+        0x022b, 0x022b,
+        0x022d, 0x022d,
+        0x022f, 0x022f,
+        0x0231, 0x0231,
+        0x0233, 0x0233,
+        0x023c, 0x023c,
+        0x023f, 0x0240,
+        0x0242, 0x0242,
+        0x0247, 0x0247,
+        0x0249, 0x0249,
+        0x024b, 0x024b,
+        0x024d, 0x024d,
+        0x024f, 0x0254,
+        0x0256, 0x0257,
+        0x0259, 0x0259,
+        0x025b, 0x025b,
+        0x0260, 0x0260,
+        0x0263, 0x0263,
+        0x0268, 0x0269,
+        0x026b, 0x026b,
+        0x026f, 0x026f,
+        0x0271, 0x0272,
+        0x0275, 0x0275,
+        0x027d, 0x027d,
+        0x0280, 0x0280,
+        0x0283, 0x0283,
+        0x0288, 0x028c,
+        0x0292, 0x0292,
+        0x0345, 0x0345,
+        0x0371, 0x0371,
+        0x0373, 0x0373,
+        0x0377, 0x0377,
+        0x037b, 0x037d,
+        0x0390, 0x0390,
+        0x03ac, 0x03ce,
+        0x03d0, 0x03d1,
+        0x03d5, 0x03d7,
+        0x03d9, 0x03d9,
+        0x03db, 0x03db,
+        0x03dd, 0x03dd,
+        0x03df, 0x03df,
+        0x03e1, 0x03e1,
+        0x03e3, 0x03e3,
+        0x03e5, 0x03e5,
+        0x03e7, 0x03e7,
+        0x03e9, 0x03e9,
+        0x03eb, 0x03eb,
+        0x03ed, 0x03ed,
+        0x03ef, 0x03f2,
+        0x03f5, 0x03f5,
+        0x03f8, 0x03f8,
+        0x03fb, 0x03fb,
+        0x0430, 0x045f,
+        0x0461, 0x0461,
+        0x0463, 0x0463,
+        0x0465, 0x0465,
+        0x0467, 0x0467,
+        0x0469, 0x0469,
+        0x046b, 0x046b,
+        0x046d, 0x046d,
+        0x046f, 0x046f,
+        0x0471, 0x0471,
+        0x0473, 0x0473,
+        0x0475, 0x0475,
+        0x0477, 0x0477,
+        0x0479, 0x0479,
+        0x047b, 0x047b,
+        0x047d, 0x047d,
+        0x047f, 0x047f,
+        0x0481, 0x0481,
+        0x048b, 0x048b,
+        0x048d, 0x048d,
+        0x048f, 0x048f,
+        0x0491, 0x0491,
+        0x0493, 0x0493,
+        0x0495, 0x0495,
+        0x0497, 0x0497,
+        0x0499, 0x0499,
+        0x049b, 0x049b,
+        0x049d, 0x049d,
+        0x049f, 0x049f,
+        0x04a1, 0x04a1,
+        0x04a3, 0x04a3,
+        0x04a5, 0x04a5,
+        0x04a7, 0x04a7,
+        0x04a9, 0x04a9,
+        0x04ab, 0x04ab,
+        0x04ad, 0x04ad,
+        0x04af, 0x04af,
+        0x04b1, 0x04b1,
+        0x04b3, 0x04b3,
+        0x04b5, 0x04b5,
+        0x04b7, 0x04b7,
+        0x04b9, 0x04b9,
+        0x04bb, 0x04bb,
+        0x04bd, 0x04bd,
+        0x04bf, 0x04bf,
+        0x04c2, 0x04c2,
+        0x04c4, 0x04c4,
+        0x04c6, 0x04c6,
+        0x04c8, 0x04c8,
+        0x04ca, 0x04ca,
+        0x04cc, 0x04cc,
+        0x04ce, 0x04cf,
+        0x04d1, 0x04d1,
+        0x04d3, 0x04d3,
+        0x04d5, 0x04d5,
+        0x04d7, 0x04d7,
+        0x04d9, 0x04d9,
+        0x04db, 0x04db,
+        0x04dd, 0x04dd,
+        0x04df, 0x04df,
+        0x04e1, 0x04e1,
+        0x04e3, 0x04e3,
+        0x04e5, 0x04e5,
+        0x04e7, 0x04e7,
+        0x04e9, 0x04e9,
+        0x04eb, 0x04eb,
+        0x04ed, 0x04ed,
+        0x04ef, 0x04ef,
+        0x04f1, 0x04f1,
+        0x04f3, 0x04f3,
+        0x04f5, 0x04f5,
+        0x04f7, 0x04f7,
+        0x04f9, 0x04f9,
+        0x04fb, 0x04fb,
+        0x04fd, 0x04fd,
+        0x04ff, 0x04ff,
+        0x0501, 0x0501,
+        0x0503, 0x0503,
+        0x0505, 0x0505,
+        0x0507, 0x0507,
+        0x0509, 0x0509,
+        0x050b, 0x050b,
+        0x050d, 0x050d,
+        0x050f, 0x050f,
+        0x0511, 0x0511,
+        0x0513, 0x0513,
+        0x0515, 0x0515,
+        0x0517, 0x0517,
+        0x0519, 0x0519,
+        0x051b, 0x051b,
+        0x051d, 0x051d,
+        0x051f, 0x051f,
+        0x0521, 0x0521,
+        0x0523, 0x0523,
+        0x0525, 0x0525,
+        0x0561, 0x0587,
+        0x1d79, 0x1d79,
+        0x1d7d, 0x1d7d,
+        0x1e01, 0x1e01,
+        0x1e03, 0x1e03,
+        0x1e05, 0x1e05,
+        0x1e07, 0x1e07,
+        0x1e09, 0x1e09,
+        0x1e0b, 0x1e0b,
+        0x1e0d, 0x1e0d,
+        0x1e0f, 0x1e0f,
+        0x1e11, 0x1e11,
+        0x1e13, 0x1e13,
+        0x1e15, 0x1e15,
+        0x1e17, 0x1e17,
+        0x1e19, 0x1e19,
+        0x1e1b, 0x1e1b,
+        0x1e1d, 0x1e1d,
+        0x1e1f, 0x1e1f,
+        0x1e21, 0x1e21,
+        0x1e23, 0x1e23,
+        0x1e25, 0x1e25,
+        0x1e27, 0x1e27,
+        0x1e29, 0x1e29,
+        0x1e2b, 0x1e2b,
+        0x1e2d, 0x1e2d,
+        0x1e2f, 0x1e2f,
+        0x1e31, 0x1e31,
+        0x1e33, 0x1e33,
+        0x1e35, 0x1e35,
+        0x1e37, 0x1e37,
+        0x1e39, 0x1e39,
+        0x1e3b, 0x1e3b,
+        0x1e3d, 0x1e3d,
+        0x1e3f, 0x1e3f,
+        0x1e41, 0x1e41,
+        0x1e43, 0x1e43,
+        0x1e45, 0x1e45,
+        0x1e47, 0x1e47,
+        0x1e49, 0x1e49,
+        0x1e4b, 0x1e4b,
+        0x1e4d, 0x1e4d,
+        0x1e4f, 0x1e4f,
+        0x1e51, 0x1e51,
+        0x1e53, 0x1e53,
+        0x1e55, 0x1e55,
+        0x1e57, 0x1e57,
+        0x1e59, 0x1e59,
+        0x1e5b, 0x1e5b,
+        0x1e5d, 0x1e5d,
+        0x1e5f, 0x1e5f,
+        0x1e61, 0x1e61,
+        0x1e63, 0x1e63,
+        0x1e65, 0x1e65,
+        0x1e67, 0x1e67,
+        0x1e69, 0x1e69,
+        0x1e6b, 0x1e6b,
+        0x1e6d, 0x1e6d,
+        0x1e6f, 0x1e6f,
+        0x1e71, 0x1e71,
+        0x1e73, 0x1e73,
+        0x1e75, 0x1e75,
+        0x1e77, 0x1e77,
+        0x1e79, 0x1e79,
+        0x1e7b, 0x1e7b,
+        0x1e7d, 0x1e7d,
+        0x1e7f, 0x1e7f,
+        0x1e81, 0x1e81,
+        0x1e83, 0x1e83,
+        0x1e85, 0x1e85,
+        0x1e87, 0x1e87,
+        0x1e89, 0x1e89,
+        0x1e8b, 0x1e8b,
+        0x1e8d, 0x1e8d,
+        0x1e8f, 0x1e8f,
+        0x1e91, 0x1e91,
+        0x1e93, 0x1e93,
+        0x1e95, 0x1e9b,
+        0x1ea1, 0x1ea1,
+        0x1ea3, 0x1ea3,
+        0x1ea5, 0x1ea5,
+        0x1ea7, 0x1ea7,
+        0x1ea9, 0x1ea9,
+        0x1eab, 0x1eab,
+        0x1ead, 0x1ead,
+        0x1eaf, 0x1eaf,
+        0x1eb1, 0x1eb1,
+        0x1eb3, 0x1eb3,
+        0x1eb5, 0x1eb5,
+        0x1eb7, 0x1eb7,
+        0x1eb9, 0x1eb9,
+        0x1ebb, 0x1ebb,
+        0x1ebd, 0x1ebd,
+        0x1ebf, 0x1ebf,
+        0x1ec1, 0x1ec1,
+        0x1ec3, 0x1ec3,
+        0x1ec5, 0x1ec5,
+        0x1ec7, 0x1ec7,
+        0x1ec9, 0x1ec9,
+        0x1ecb, 0x1ecb,
+        0x1ecd, 0x1ecd,
+        0x1ecf, 0x1ecf,
+        0x1ed1, 0x1ed1,
+        0x1ed3, 0x1ed3,
+        0x1ed5, 0x1ed5,
+        0x1ed7, 0x1ed7,
+        0x1ed9, 0x1ed9,
+        0x1edb, 0x1edb,
+        0x1edd, 0x1edd,
+        0x1edf, 0x1edf,
+        0x1ee1, 0x1ee1,
+        0x1ee3, 0x1ee3,
+        0x1ee5, 0x1ee5,
+        0x1ee7, 0x1ee7,
+        0x1ee9, 0x1ee9,
+        0x1eeb, 0x1eeb,
+        0x1eed, 0x1eed,
+        0x1eef, 0x1eef,
+        0x1ef1, 0x1ef1,
+        0x1ef3, 0x1ef3,
+        0x1ef5, 0x1ef5,
+        0x1ef7, 0x1ef7,
+        0x1ef9, 0x1ef9,
+        0x1efb, 0x1efb,
+        0x1efd, 0x1efd,
+        0x1eff, 0x1f07,
+        0x1f10, 0x1f15,
+        0x1f20, 0x1f27,
+        0x1f30, 0x1f37,
+        0x1f40, 0x1f45,
+        0x1f50, 0x1f57,
+        0x1f60, 0x1f67,
+        0x1f70, 0x1f7d,
+        0x1f80, 0x1fb4,
+        0x1fb6, 0x1fb7,
+        0x1fbc, 0x1fbc,
+        0x1fbe, 0x1fbe,
+        0x1fc2, 0x1fc4,
+        0x1fc6, 0x1fc7,
+        0x1fcc, 0x1fcc,
+        0x1fd0, 0x1fd3,
+        0x1fd6, 0x1fd7,
+        0x1fe0, 0x1fe7,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ff7,
+        0x1ffc, 0x1ffc,
+        0x214e, 0x214e,
+        0x2170, 0x217f,
+        0x2184, 0x2184,
+        0x24d0, 0x24e9,
+        0x2c30, 0x2c5e,
+        0x2c61, 0x2c61,
+        0x2c65, 0x2c66,
+        0x2c68, 0x2c68,
+        0x2c6a, 0x2c6a,
+        0x2c6c, 0x2c6c,
+        0x2c73, 0x2c73,
+        0x2c76, 0x2c76,
+        0x2c81, 0x2c81,
+        0x2c83, 0x2c83,
+        0x2c85, 0x2c85,
+        0x2c87, 0x2c87,
+        0x2c89, 0x2c89,
+        0x2c8b, 0x2c8b,
+        0x2c8d, 0x2c8d,
+        0x2c8f, 0x2c8f,
+        0x2c91, 0x2c91,
+        0x2c93, 0x2c93,
+        0x2c95, 0x2c95,
+        0x2c97, 0x2c97,
+        0x2c99, 0x2c99,
+        0x2c9b, 0x2c9b,
+        0x2c9d, 0x2c9d,
+        0x2c9f, 0x2c9f,
+        0x2ca1, 0x2ca1,
+        0x2ca3, 0x2ca3,
+        0x2ca5, 0x2ca5,
+        0x2ca7, 0x2ca7,
+        0x2ca9, 0x2ca9,
+        0x2cab, 0x2cab,
+        0x2cad, 0x2cad,
+        0x2caf, 0x2caf,
+        0x2cb1, 0x2cb1,
+        0x2cb3, 0x2cb3,
+        0x2cb5, 0x2cb5,
+        0x2cb7, 0x2cb7,
+        0x2cb9, 0x2cb9,
+        0x2cbb, 0x2cbb,
+        0x2cbd, 0x2cbd,
+        0x2cbf, 0x2cbf,
+        0x2cc1, 0x2cc1,
+        0x2cc3, 0x2cc3,
+        0x2cc5, 0x2cc5,
+        0x2cc7, 0x2cc7,
+        0x2cc9, 0x2cc9,
+        0x2ccb, 0x2ccb,
+        0x2ccd, 0x2ccd,
+        0x2ccf, 0x2ccf,
+        0x2cd1, 0x2cd1,
+        0x2cd3, 0x2cd3,
+        0x2cd5, 0x2cd5,
+        0x2cd7, 0x2cd7,
+        0x2cd9, 0x2cd9,
+        0x2cdb, 0x2cdb,
+        0x2cdd, 0x2cdd,
+        0x2cdf, 0x2cdf,
+        0x2ce1, 0x2ce1,
+        0x2ce3, 0x2ce3,
+        0x2cec, 0x2cec,
+        0x2cee, 0x2cee,
+        0x2d00, 0x2d25,
+        0xa641, 0xa641,
+        0xa643, 0xa643,
+        0xa645, 0xa645,
+        0xa647, 0xa647,
+        0xa649, 0xa649,
+        0xa64b, 0xa64b,
+        0xa64d, 0xa64d,
+        0xa64f, 0xa64f,
+        0xa651, 0xa651,
+        0xa653, 0xa653,
+        0xa655, 0xa655,
+        0xa657, 0xa657,
+        0xa659, 0xa659,
+        0xa65b, 0xa65b,
+        0xa65d, 0xa65d,
+        0xa65f, 0xa65f,
+        0xa663, 0xa663,
+        0xa665, 0xa665,
+        0xa667, 0xa667,
+        0xa669, 0xa669,
+        0xa66b, 0xa66b,
+        0xa66d, 0xa66d,
+        0xa681, 0xa681,
+        0xa683, 0xa683,
+        0xa685, 0xa685,
+        0xa687, 0xa687,
+        0xa689, 0xa689,
+        0xa68b, 0xa68b,
+        0xa68d, 0xa68d,
+        0xa68f, 0xa68f,
+        0xa691, 0xa691,
+        0xa693, 0xa693,
+        0xa695, 0xa695,
+        0xa697, 0xa697,
+        0xa723, 0xa723,
+        0xa725, 0xa725,
+        0xa727, 0xa727,
+        0xa729, 0xa729,
+        0xa72b, 0xa72b,
+        0xa72d, 0xa72d,
+        0xa72f, 0xa72f,
+        0xa733, 0xa733,
+        0xa735, 0xa735,
+        0xa737, 0xa737,
+        0xa739, 0xa739,
+        0xa73b, 0xa73b,
+        0xa73d, 0xa73d,
+        0xa73f, 0xa73f,
+        0xa741, 0xa741,
+        0xa743, 0xa743,
+        0xa745, 0xa745,
+        0xa747, 0xa747,
+        0xa749, 0xa749,
+        0xa74b, 0xa74b,
+        0xa74d, 0xa74d,
+        0xa74f, 0xa74f,
+        0xa751, 0xa751,
+        0xa753, 0xa753,
+        0xa755, 0xa755,
+        0xa757, 0xa757,
+        0xa759, 0xa759,
+        0xa75b, 0xa75b,
+        0xa75d, 0xa75d,
+        0xa75f, 0xa75f,
+        0xa761, 0xa761,
+        0xa763, 0xa763,
+        0xa765, 0xa765,
+        0xa767, 0xa767,
+        0xa769, 0xa769,
+        0xa76b, 0xa76b,
+        0xa76d, 0xa76d,
+        0xa76f, 0xa76f,
+        0xa77a, 0xa77a,
+        0xa77c, 0xa77c,
+        0xa77f, 0xa77f,
+        0xa781, 0xa781,
+        0xa783, 0xa783,
+        0xa785, 0xa785,
+        0xa787, 0xa787,
+        0xa78c, 0xa78c,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xff41, 0xff5a,
+        0x10428, 0x1044f,
 }; /* CR_Changes_When_Uppercased */
 
 /* 'Changes_When_Titlecased': Derived Property */
 static const OnigCodePoint CR_Changes_When_Titlecased[] = {
-	574,
-	0x0061, 0x007a,
-	0x00b5, 0x00b5,
-	0x00df, 0x00f6,
-	0x00f8, 0x00ff,
-	0x0101, 0x0101,
-	0x0103, 0x0103,
-	0x0105, 0x0105,
-	0x0107, 0x0107,
-	0x0109, 0x0109,
-	0x010b, 0x010b,
-	0x010d, 0x010d,
-	0x010f, 0x010f,
-	0x0111, 0x0111,
-	0x0113, 0x0113,
-	0x0115, 0x0115,
-	0x0117, 0x0117,
-	0x0119, 0x0119,
-	0x011b, 0x011b,
-	0x011d, 0x011d,
-	0x011f, 0x011f,
-	0x0121, 0x0121,
-	0x0123, 0x0123,
-	0x0125, 0x0125,
-	0x0127, 0x0127,
-	0x0129, 0x0129,
-	0x012b, 0x012b,
-	0x012d, 0x012d,
-	0x012f, 0x012f,
-	0x0131, 0x0131,
-	0x0133, 0x0133,
-	0x0135, 0x0135,
-	0x0137, 0x0137,
-	0x013a, 0x013a,
-	0x013c, 0x013c,
-	0x013e, 0x013e,
-	0x0140, 0x0140,
-	0x0142, 0x0142,
-	0x0144, 0x0144,
-	0x0146, 0x0146,
-	0x0148, 0x0149,
-	0x014b, 0x014b,
-	0x014d, 0x014d,
-	0x014f, 0x014f,
-	0x0151, 0x0151,
-	0x0153, 0x0153,
-	0x0155, 0x0155,
-	0x0157, 0x0157,
-	0x0159, 0x0159,
-	0x015b, 0x015b,
-	0x015d, 0x015d,
-	0x015f, 0x015f,
-	0x0161, 0x0161,
-	0x0163, 0x0163,
-	0x0165, 0x0165,
-	0x0167, 0x0167,
-	0x0169, 0x0169,
-	0x016b, 0x016b,
-	0x016d, 0x016d,
-	0x016f, 0x016f,
-	0x0171, 0x0171,
-	0x0173, 0x0173,
-	0x0175, 0x0175,
-	0x0177, 0x0177,
-	0x017a, 0x017a,
-	0x017c, 0x017c,
-	0x017e, 0x0180,
-	0x0183, 0x0183,
-	0x0185, 0x0185,
-	0x0188, 0x0188,
-	0x018c, 0x018c,
-	0x0192, 0x0192,
-	0x0195, 0x0195,
-	0x0199, 0x019a,
-	0x019e, 0x019e,
-	0x01a1, 0x01a1,
-	0x01a3, 0x01a3,
-	0x01a5, 0x01a5,
-	0x01a8, 0x01a8,
-	0x01ad, 0x01ad,
-	0x01b0, 0x01b0,
-	0x01b4, 0x01b4,
-	0x01b6, 0x01b6,
-	0x01b9, 0x01b9,
-	0x01bd, 0x01bd,
-	0x01bf, 0x01bf,
-	0x01c4, 0x01c4,
-	0x01c6, 0x01c7,
-	0x01c9, 0x01ca,
-	0x01cc, 0x01cc,
-	0x01ce, 0x01ce,
-	0x01d0, 0x01d0,
-	0x01d2, 0x01d2,
-	0x01d4, 0x01d4,
-	0x01d6, 0x01d6,
-	0x01d8, 0x01d8,
-	0x01da, 0x01da,
-	0x01dc, 0x01dd,
-	0x01df, 0x01df,
-	0x01e1, 0x01e1,
-	0x01e3, 0x01e3,
-	0x01e5, 0x01e5,
-	0x01e7, 0x01e7,
-	0x01e9, 0x01e9,
-	0x01eb, 0x01eb,
-	0x01ed, 0x01ed,
-	0x01ef, 0x01f1,
-	0x01f3, 0x01f3,
-	0x01f5, 0x01f5,
-	0x01f9, 0x01f9,
-	0x01fb, 0x01fb,
-	0x01fd, 0x01fd,
-	0x01ff, 0x01ff,
-	0x0201, 0x0201,
-	0x0203, 0x0203,
-	0x0205, 0x0205,
-	0x0207, 0x0207,
-	0x0209, 0x0209,
-	0x020b, 0x020b,
-	0x020d, 0x020d,
-	0x020f, 0x020f,
-	0x0211, 0x0211,
-	0x0213, 0x0213,
-	0x0215, 0x0215,
-	0x0217, 0x0217,
-	0x0219, 0x0219,
-	0x021b, 0x021b,
-	0x021d, 0x021d,
-	0x021f, 0x021f,
-	0x0223, 0x0223,
-	0x0225, 0x0225,
-	0x0227, 0x0227,
-	0x0229, 0x0229,
-	0x022b, 0x022b,
-	0x022d, 0x022d,
-	0x022f, 0x022f,
-	0x0231, 0x0231,
-	0x0233, 0x0233,
-	0x023c, 0x023c,
-	0x023f, 0x0240,
-	0x0242, 0x0242,
-	0x0247, 0x0247,
-	0x0249, 0x0249,
-	0x024b, 0x024b,
-	0x024d, 0x024d,
-	0x024f, 0x0254,
-	0x0256, 0x0257,
-	0x0259, 0x0259,
-	0x025b, 0x025b,
-	0x0260, 0x0260,
-	0x0263, 0x0263,
-	0x0268, 0x0269,
-	0x026b, 0x026b,
-	0x026f, 0x026f,
-	0x0271, 0x0272,
-	0x0275, 0x0275,
-	0x027d, 0x027d,
-	0x0280, 0x0280,
-	0x0283, 0x0283,
-	0x0288, 0x028c,
-	0x0292, 0x0292,
-	0x0345, 0x0345,
-	0x0371, 0x0371,
-	0x0373, 0x0373,
-	0x0377, 0x0377,
-	0x037b, 0x037d,
-	0x0390, 0x0390,
-	0x03ac, 0x03ce,
-	0x03d0, 0x03d1,
-	0x03d5, 0x03d7,
-	0x03d9, 0x03d9,
-	0x03db, 0x03db,
-	0x03dd, 0x03dd,
-	0x03df, 0x03df,
-	0x03e1, 0x03e1,
-	0x03e3, 0x03e3,
-	0x03e5, 0x03e5,
-	0x03e7, 0x03e7,
-	0x03e9, 0x03e9,
-	0x03eb, 0x03eb,
-	0x03ed, 0x03ed,
-	0x03ef, 0x03f2,
-	0x03f5, 0x03f5,
-	0x03f8, 0x03f8,
-	0x03fb, 0x03fb,
-	0x0430, 0x045f,
-	0x0461, 0x0461,
-	0x0463, 0x0463,
-	0x0465, 0x0465,
-	0x0467, 0x0467,
-	0x0469, 0x0469,
-	0x046b, 0x046b,
-	0x046d, 0x046d,
-	0x046f, 0x046f,
-	0x0471, 0x0471,
-	0x0473, 0x0473,
-	0x0475, 0x0475,
-	0x0477, 0x0477,
-	0x0479, 0x0479,
-	0x047b, 0x047b,
-	0x047d, 0x047d,
-	0x047f, 0x047f,
-	0x0481, 0x0481,
-	0x048b, 0x048b,
-	0x048d, 0x048d,
-	0x048f, 0x048f,
-	0x0491, 0x0491,
-	0x0493, 0x0493,
-	0x0495, 0x0495,
-	0x0497, 0x0497,
-	0x0499, 0x0499,
-	0x049b, 0x049b,
-	0x049d, 0x049d,
-	0x049f, 0x049f,
-	0x04a1, 0x04a1,
-	0x04a3, 0x04a3,
-	0x04a5, 0x04a5,
-	0x04a7, 0x04a7,
-	0x04a9, 0x04a9,
-	0x04ab, 0x04ab,
-	0x04ad, 0x04ad,
-	0x04af, 0x04af,
-	0x04b1, 0x04b1,
-	0x04b3, 0x04b3,
-	0x04b5, 0x04b5,
-	0x04b7, 0x04b7,
-	0x04b9, 0x04b9,
-	0x04bb, 0x04bb,
-	0x04bd, 0x04bd,
-	0x04bf, 0x04bf,
-	0x04c2, 0x04c2,
-	0x04c4, 0x04c4,
-	0x04c6, 0x04c6,
-	0x04c8, 0x04c8,
-	0x04ca, 0x04ca,
-	0x04cc, 0x04cc,
-	0x04ce, 0x04cf,
-	0x04d1, 0x04d1,
-	0x04d3, 0x04d3,
-	0x04d5, 0x04d5,
-	0x04d7, 0x04d7,
-	0x04d9, 0x04d9,
-	0x04db, 0x04db,
-	0x04dd, 0x04dd,
-	0x04df, 0x04df,
-	0x04e1, 0x04e1,
-	0x04e3, 0x04e3,
-	0x04e5, 0x04e5,
-	0x04e7, 0x04e7,
-	0x04e9, 0x04e9,
-	0x04eb, 0x04eb,
-	0x04ed, 0x04ed,
-	0x04ef, 0x04ef,
-	0x04f1, 0x04f1,
-	0x04f3, 0x04f3,
-	0x04f5, 0x04f5,
-	0x04f7, 0x04f7,
-	0x04f9, 0x04f9,
-	0x04fb, 0x04fb,
-	0x04fd, 0x04fd,
-	0x04ff, 0x04ff,
-	0x0501, 0x0501,
-	0x0503, 0x0503,
-	0x0505, 0x0505,
-	0x0507, 0x0507,
-	0x0509, 0x0509,
-	0x050b, 0x050b,
-	0x050d, 0x050d,
-	0x050f, 0x050f,
-	0x0511, 0x0511,
-	0x0513, 0x0513,
-	0x0515, 0x0515,
-	0x0517, 0x0517,
-	0x0519, 0x0519,
-	0x051b, 0x051b,
-	0x051d, 0x051d,
-	0x051f, 0x051f,
-	0x0521, 0x0521,
-	0x0523, 0x0523,
-	0x0525, 0x0525,
-	0x0561, 0x0587,
-	0x1d79, 0x1d79,
-	0x1d7d, 0x1d7d,
-	0x1e01, 0x1e01,
-	0x1e03, 0x1e03,
-	0x1e05, 0x1e05,
-	0x1e07, 0x1e07,
-	0x1e09, 0x1e09,
-	0x1e0b, 0x1e0b,
-	0x1e0d, 0x1e0d,
-	0x1e0f, 0x1e0f,
-	0x1e11, 0x1e11,
-	0x1e13, 0x1e13,
-	0x1e15, 0x1e15,
-	0x1e17, 0x1e17,
-	0x1e19, 0x1e19,
-	0x1e1b, 0x1e1b,
-	0x1e1d, 0x1e1d,
-	0x1e1f, 0x1e1f,
-	0x1e21, 0x1e21,
-	0x1e23, 0x1e23,
-	0x1e25, 0x1e25,
-	0x1e27, 0x1e27,
-	0x1e29, 0x1e29,
-	0x1e2b, 0x1e2b,
-	0x1e2d, 0x1e2d,
-	0x1e2f, 0x1e2f,
-	0x1e31, 0x1e31,
-	0x1e33, 0x1e33,
-	0x1e35, 0x1e35,
-	0x1e37, 0x1e37,
-	0x1e39, 0x1e39,
-	0x1e3b, 0x1e3b,
-	0x1e3d, 0x1e3d,
-	0x1e3f, 0x1e3f,
-	0x1e41, 0x1e41,
-	0x1e43, 0x1e43,
-	0x1e45, 0x1e45,
-	0x1e47, 0x1e47,
-	0x1e49, 0x1e49,
-	0x1e4b, 0x1e4b,
-	0x1e4d, 0x1e4d,
-	0x1e4f, 0x1e4f,
-	0x1e51, 0x1e51,
-	0x1e53, 0x1e53,
-	0x1e55, 0x1e55,
-	0x1e57, 0x1e57,
-	0x1e59, 0x1e59,
-	0x1e5b, 0x1e5b,
-	0x1e5d, 0x1e5d,
-	0x1e5f, 0x1e5f,
-	0x1e61, 0x1e61,
-	0x1e63, 0x1e63,
-	0x1e65, 0x1e65,
-	0x1e67, 0x1e67,
-	0x1e69, 0x1e69,
-	0x1e6b, 0x1e6b,
-	0x1e6d, 0x1e6d,
-	0x1e6f, 0x1e6f,
-	0x1e71, 0x1e71,
-	0x1e73, 0x1e73,
-	0x1e75, 0x1e75,
-	0x1e77, 0x1e77,
-	0x1e79, 0x1e79,
-	0x1e7b, 0x1e7b,
-	0x1e7d, 0x1e7d,
-	0x1e7f, 0x1e7f,
-	0x1e81, 0x1e81,
-	0x1e83, 0x1e83,
-	0x1e85, 0x1e85,
-	0x1e87, 0x1e87,
-	0x1e89, 0x1e89,
-	0x1e8b, 0x1e8b,
-	0x1e8d, 0x1e8d,
-	0x1e8f, 0x1e8f,
-	0x1e91, 0x1e91,
-	0x1e93, 0x1e93,
-	0x1e95, 0x1e9b,
-	0x1ea1, 0x1ea1,
-	0x1ea3, 0x1ea3,
-	0x1ea5, 0x1ea5,
-	0x1ea7, 0x1ea7,
-	0x1ea9, 0x1ea9,
-	0x1eab, 0x1eab,
-	0x1ead, 0x1ead,
-	0x1eaf, 0x1eaf,
-	0x1eb1, 0x1eb1,
-	0x1eb3, 0x1eb3,
-	0x1eb5, 0x1eb5,
-	0x1eb7, 0x1eb7,
-	0x1eb9, 0x1eb9,
-	0x1ebb, 0x1ebb,
-	0x1ebd, 0x1ebd,
-	0x1ebf, 0x1ebf,
-	0x1ec1, 0x1ec1,
-	0x1ec3, 0x1ec3,
-	0x1ec5, 0x1ec5,
-	0x1ec7, 0x1ec7,
-	0x1ec9, 0x1ec9,
-	0x1ecb, 0x1ecb,
-	0x1ecd, 0x1ecd,
-	0x1ecf, 0x1ecf,
-	0x1ed1, 0x1ed1,
-	0x1ed3, 0x1ed3,
-	0x1ed5, 0x1ed5,
-	0x1ed7, 0x1ed7,
-	0x1ed9, 0x1ed9,
-	0x1edb, 0x1edb,
-	0x1edd, 0x1edd,
-	0x1edf, 0x1edf,
-	0x1ee1, 0x1ee1,
-	0x1ee3, 0x1ee3,
-	0x1ee5, 0x1ee5,
-	0x1ee7, 0x1ee7,
-	0x1ee9, 0x1ee9,
-	0x1eeb, 0x1eeb,
-	0x1eed, 0x1eed,
-	0x1eef, 0x1eef,
-	0x1ef1, 0x1ef1,
-	0x1ef3, 0x1ef3,
-	0x1ef5, 0x1ef5,
-	0x1ef7, 0x1ef7,
-	0x1ef9, 0x1ef9,
-	0x1efb, 0x1efb,
-	0x1efd, 0x1efd,
-	0x1eff, 0x1f07,
-	0x1f10, 0x1f15,
-	0x1f20, 0x1f27,
-	0x1f30, 0x1f37,
-	0x1f40, 0x1f45,
-	0x1f50, 0x1f57,
-	0x1f60, 0x1f67,
-	0x1f70, 0x1f7d,
-	0x1f80, 0x1f87,
-	0x1f90, 0x1f97,
-	0x1fa0, 0x1fa7,
-	0x1fb0, 0x1fb4,
-	0x1fb6, 0x1fb7,
-	0x1fbe, 0x1fbe,
-	0x1fc2, 0x1fc4,
-	0x1fc6, 0x1fc7,
-	0x1fd0, 0x1fd3,
-	0x1fd6, 0x1fd7,
-	0x1fe0, 0x1fe7,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ff7,
-	0x214e, 0x214e,
-	0x2170, 0x217f,
-	0x2184, 0x2184,
-	0x24d0, 0x24e9,
-	0x2c30, 0x2c5e,
-	0x2c61, 0x2c61,
-	0x2c65, 0x2c66,
-	0x2c68, 0x2c68,
-	0x2c6a, 0x2c6a,
-	0x2c6c, 0x2c6c,
-	0x2c73, 0x2c73,
-	0x2c76, 0x2c76,
-	0x2c81, 0x2c81,
-	0x2c83, 0x2c83,
-	0x2c85, 0x2c85,
-	0x2c87, 0x2c87,
-	0x2c89, 0x2c89,
-	0x2c8b, 0x2c8b,
-	0x2c8d, 0x2c8d,
-	0x2c8f, 0x2c8f,
-	0x2c91, 0x2c91,
-	0x2c93, 0x2c93,
-	0x2c95, 0x2c95,
-	0x2c97, 0x2c97,
-	0x2c99, 0x2c99,
-	0x2c9b, 0x2c9b,
-	0x2c9d, 0x2c9d,
-	0x2c9f, 0x2c9f,
-	0x2ca1, 0x2ca1,
-	0x2ca3, 0x2ca3,
-	0x2ca5, 0x2ca5,
-	0x2ca7, 0x2ca7,
-	0x2ca9, 0x2ca9,
-	0x2cab, 0x2cab,
-	0x2cad, 0x2cad,
-	0x2caf, 0x2caf,
-	0x2cb1, 0x2cb1,
-	0x2cb3, 0x2cb3,
-	0x2cb5, 0x2cb5,
-	0x2cb7, 0x2cb7,
-	0x2cb9, 0x2cb9,
-	0x2cbb, 0x2cbb,
-	0x2cbd, 0x2cbd,
-	0x2cbf, 0x2cbf,
-	0x2cc1, 0x2cc1,
-	0x2cc3, 0x2cc3,
-	0x2cc5, 0x2cc5,
-	0x2cc7, 0x2cc7,
-	0x2cc9, 0x2cc9,
-	0x2ccb, 0x2ccb,
-	0x2ccd, 0x2ccd,
-	0x2ccf, 0x2ccf,
-	0x2cd1, 0x2cd1,
-	0x2cd3, 0x2cd3,
-	0x2cd5, 0x2cd5,
-	0x2cd7, 0x2cd7,
-	0x2cd9, 0x2cd9,
-	0x2cdb, 0x2cdb,
-	0x2cdd, 0x2cdd,
-	0x2cdf, 0x2cdf,
-	0x2ce1, 0x2ce1,
-	0x2ce3, 0x2ce3,
-	0x2cec, 0x2cec,
-	0x2cee, 0x2cee,
-	0x2d00, 0x2d25,
-	0xa641, 0xa641,
-	0xa643, 0xa643,
-	0xa645, 0xa645,
-	0xa647, 0xa647,
-	0xa649, 0xa649,
-	0xa64b, 0xa64b,
-	0xa64d, 0xa64d,
-	0xa64f, 0xa64f,
-	0xa651, 0xa651,
-	0xa653, 0xa653,
-	0xa655, 0xa655,
-	0xa657, 0xa657,
-	0xa659, 0xa659,
-	0xa65b, 0xa65b,
-	0xa65d, 0xa65d,
-	0xa65f, 0xa65f,
-	0xa663, 0xa663,
-	0xa665, 0xa665,
-	0xa667, 0xa667,
-	0xa669, 0xa669,
-	0xa66b, 0xa66b,
-	0xa66d, 0xa66d,
-	0xa681, 0xa681,
-	0xa683, 0xa683,
-	0xa685, 0xa685,
-	0xa687, 0xa687,
-	0xa689, 0xa689,
-	0xa68b, 0xa68b,
-	0xa68d, 0xa68d,
-	0xa68f, 0xa68f,
-	0xa691, 0xa691,
-	0xa693, 0xa693,
-	0xa695, 0xa695,
-	0xa697, 0xa697,
-	0xa723, 0xa723,
-	0xa725, 0xa725,
-	0xa727, 0xa727,
-	0xa729, 0xa729,
-	0xa72b, 0xa72b,
-	0xa72d, 0xa72d,
-	0xa72f, 0xa72f,
-	0xa733, 0xa733,
-	0xa735, 0xa735,
-	0xa737, 0xa737,
-	0xa739, 0xa739,
-	0xa73b, 0xa73b,
-	0xa73d, 0xa73d,
-	0xa73f, 0xa73f,
-	0xa741, 0xa741,
-	0xa743, 0xa743,
-	0xa745, 0xa745,
-	0xa747, 0xa747,
-	0xa749, 0xa749,
-	0xa74b, 0xa74b,
-	0xa74d, 0xa74d,
-	0xa74f, 0xa74f,
-	0xa751, 0xa751,
-	0xa753, 0xa753,
-	0xa755, 0xa755,
-	0xa757, 0xa757,
-	0xa759, 0xa759,
-	0xa75b, 0xa75b,
-	0xa75d, 0xa75d,
-	0xa75f, 0xa75f,
-	0xa761, 0xa761,
-	0xa763, 0xa763,
-	0xa765, 0xa765,
-	0xa767, 0xa767,
-	0xa769, 0xa769,
-	0xa76b, 0xa76b,
-	0xa76d, 0xa76d,
-	0xa76f, 0xa76f,
-	0xa77a, 0xa77a,
-	0xa77c, 0xa77c,
-	0xa77f, 0xa77f,
-	0xa781, 0xa781,
-	0xa783, 0xa783,
-	0xa785, 0xa785,
-	0xa787, 0xa787,
-	0xa78c, 0xa78c,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xff41, 0xff5a,
-	0x10428, 0x1044f,
+        574,
+        0x0061, 0x007a,
+        0x00b5, 0x00b5,
+        0x00df, 0x00f6,
+        0x00f8, 0x00ff,
+        0x0101, 0x0101,
+        0x0103, 0x0103,
+        0x0105, 0x0105,
+        0x0107, 0x0107,
+        0x0109, 0x0109,
+        0x010b, 0x010b,
+        0x010d, 0x010d,
+        0x010f, 0x010f,
+        0x0111, 0x0111,
+        0x0113, 0x0113,
+        0x0115, 0x0115,
+        0x0117, 0x0117,
+        0x0119, 0x0119,
+        0x011b, 0x011b,
+        0x011d, 0x011d,
+        0x011f, 0x011f,
+        0x0121, 0x0121,
+        0x0123, 0x0123,
+        0x0125, 0x0125,
+        0x0127, 0x0127,
+        0x0129, 0x0129,
+        0x012b, 0x012b,
+        0x012d, 0x012d,
+        0x012f, 0x012f,
+        0x0131, 0x0131,
+        0x0133, 0x0133,
+        0x0135, 0x0135,
+        0x0137, 0x0137,
+        0x013a, 0x013a,
+        0x013c, 0x013c,
+        0x013e, 0x013e,
+        0x0140, 0x0140,
+        0x0142, 0x0142,
+        0x0144, 0x0144,
+        0x0146, 0x0146,
+        0x0148, 0x0149,
+        0x014b, 0x014b,
+        0x014d, 0x014d,
+        0x014f, 0x014f,
+        0x0151, 0x0151,
+        0x0153, 0x0153,
+        0x0155, 0x0155,
+        0x0157, 0x0157,
+        0x0159, 0x0159,
+        0x015b, 0x015b,
+        0x015d, 0x015d,
+        0x015f, 0x015f,
+        0x0161, 0x0161,
+        0x0163, 0x0163,
+        0x0165, 0x0165,
+        0x0167, 0x0167,
+        0x0169, 0x0169,
+        0x016b, 0x016b,
+        0x016d, 0x016d,
+        0x016f, 0x016f,
+        0x0171, 0x0171,
+        0x0173, 0x0173,
+        0x0175, 0x0175,
+        0x0177, 0x0177,
+        0x017a, 0x017a,
+        0x017c, 0x017c,
+        0x017e, 0x0180,
+        0x0183, 0x0183,
+        0x0185, 0x0185,
+        0x0188, 0x0188,
+        0x018c, 0x018c,
+        0x0192, 0x0192,
+        0x0195, 0x0195,
+        0x0199, 0x019a,
+        0x019e, 0x019e,
+        0x01a1, 0x01a1,
+        0x01a3, 0x01a3,
+        0x01a5, 0x01a5,
+        0x01a8, 0x01a8,
+        0x01ad, 0x01ad,
+        0x01b0, 0x01b0,
+        0x01b4, 0x01b4,
+        0x01b6, 0x01b6,
+        0x01b9, 0x01b9,
+        0x01bd, 0x01bd,
+        0x01bf, 0x01bf,
+        0x01c4, 0x01c4,
+        0x01c6, 0x01c7,
+        0x01c9, 0x01ca,
+        0x01cc, 0x01cc,
+        0x01ce, 0x01ce,
+        0x01d0, 0x01d0,
+        0x01d2, 0x01d2,
+        0x01d4, 0x01d4,
+        0x01d6, 0x01d6,
+        0x01d8, 0x01d8,
+        0x01da, 0x01da,
+        0x01dc, 0x01dd,
+        0x01df, 0x01df,
+        0x01e1, 0x01e1,
+        0x01e3, 0x01e3,
+        0x01e5, 0x01e5,
+        0x01e7, 0x01e7,
+        0x01e9, 0x01e9,
+        0x01eb, 0x01eb,
+        0x01ed, 0x01ed,
+        0x01ef, 0x01f1,
+        0x01f3, 0x01f3,
+        0x01f5, 0x01f5,
+        0x01f9, 0x01f9,
+        0x01fb, 0x01fb,
+        0x01fd, 0x01fd,
+        0x01ff, 0x01ff,
+        0x0201, 0x0201,
+        0x0203, 0x0203,
+        0x0205, 0x0205,
+        0x0207, 0x0207,
+        0x0209, 0x0209,
+        0x020b, 0x020b,
+        0x020d, 0x020d,
+        0x020f, 0x020f,
+        0x0211, 0x0211,
+        0x0213, 0x0213,
+        0x0215, 0x0215,
+        0x0217, 0x0217,
+        0x0219, 0x0219,
+        0x021b, 0x021b,
+        0x021d, 0x021d,
+        0x021f, 0x021f,
+        0x0223, 0x0223,
+        0x0225, 0x0225,
+        0x0227, 0x0227,
+        0x0229, 0x0229,
+        0x022b, 0x022b,
+        0x022d, 0x022d,
+        0x022f, 0x022f,
+        0x0231, 0x0231,
+        0x0233, 0x0233,
+        0x023c, 0x023c,
+        0x023f, 0x0240,
+        0x0242, 0x0242,
+        0x0247, 0x0247,
+        0x0249, 0x0249,
+        0x024b, 0x024b,
+        0x024d, 0x024d,
+        0x024f, 0x0254,
+        0x0256, 0x0257,
+        0x0259, 0x0259,
+        0x025b, 0x025b,
+        0x0260, 0x0260,
+        0x0263, 0x0263,
+        0x0268, 0x0269,
+        0x026b, 0x026b,
+        0x026f, 0x026f,
+        0x0271, 0x0272,
+        0x0275, 0x0275,
+        0x027d, 0x027d,
+        0x0280, 0x0280,
+        0x0283, 0x0283,
+        0x0288, 0x028c,
+        0x0292, 0x0292,
+        0x0345, 0x0345,
+        0x0371, 0x0371,
+        0x0373, 0x0373,
+        0x0377, 0x0377,
+        0x037b, 0x037d,
+        0x0390, 0x0390,
+        0x03ac, 0x03ce,
+        0x03d0, 0x03d1,
+        0x03d5, 0x03d7,
+        0x03d9, 0x03d9,
+        0x03db, 0x03db,
+        0x03dd, 0x03dd,
+        0x03df, 0x03df,
+        0x03e1, 0x03e1,
+        0x03e3, 0x03e3,
+        0x03e5, 0x03e5,
+        0x03e7, 0x03e7,
+        0x03e9, 0x03e9,
+        0x03eb, 0x03eb,
+        0x03ed, 0x03ed,
+        0x03ef, 0x03f2,
+        0x03f5, 0x03f5,
+        0x03f8, 0x03f8,
+        0x03fb, 0x03fb,
+        0x0430, 0x045f,
+        0x0461, 0x0461,
+        0x0463, 0x0463,
+        0x0465, 0x0465,
+        0x0467, 0x0467,
+        0x0469, 0x0469,
+        0x046b, 0x046b,
+        0x046d, 0x046d,
+        0x046f, 0x046f,
+        0x0471, 0x0471,
+        0x0473, 0x0473,
+        0x0475, 0x0475,
+        0x0477, 0x0477,
+        0x0479, 0x0479,
+        0x047b, 0x047b,
+        0x047d, 0x047d,
+        0x047f, 0x047f,
+        0x0481, 0x0481,
+        0x048b, 0x048b,
+        0x048d, 0x048d,
+        0x048f, 0x048f,
+        0x0491, 0x0491,
+        0x0493, 0x0493,
+        0x0495, 0x0495,
+        0x0497, 0x0497,
+        0x0499, 0x0499,
+        0x049b, 0x049b,
+        0x049d, 0x049d,
+        0x049f, 0x049f,
+        0x04a1, 0x04a1,
+        0x04a3, 0x04a3,
+        0x04a5, 0x04a5,
+        0x04a7, 0x04a7,
+        0x04a9, 0x04a9,
+        0x04ab, 0x04ab,
+        0x04ad, 0x04ad,
+        0x04af, 0x04af,
+        0x04b1, 0x04b1,
+        0x04b3, 0x04b3,
+        0x04b5, 0x04b5,
+        0x04b7, 0x04b7,
+        0x04b9, 0x04b9,
+        0x04bb, 0x04bb,
+        0x04bd, 0x04bd,
+        0x04bf, 0x04bf,
+        0x04c2, 0x04c2,
+        0x04c4, 0x04c4,
+        0x04c6, 0x04c6,
+        0x04c8, 0x04c8,
+        0x04ca, 0x04ca,
+        0x04cc, 0x04cc,
+        0x04ce, 0x04cf,
+        0x04d1, 0x04d1,
+        0x04d3, 0x04d3,
+        0x04d5, 0x04d5,
+        0x04d7, 0x04d7,
+        0x04d9, 0x04d9,
+        0x04db, 0x04db,
+        0x04dd, 0x04dd,
+        0x04df, 0x04df,
+        0x04e1, 0x04e1,
+        0x04e3, 0x04e3,
+        0x04e5, 0x04e5,
+        0x04e7, 0x04e7,
+        0x04e9, 0x04e9,
+        0x04eb, 0x04eb,
+        0x04ed, 0x04ed,
+        0x04ef, 0x04ef,
+        0x04f1, 0x04f1,
+        0x04f3, 0x04f3,
+        0x04f5, 0x04f5,
+        0x04f7, 0x04f7,
+        0x04f9, 0x04f9,
+        0x04fb, 0x04fb,
+        0x04fd, 0x04fd,
+        0x04ff, 0x04ff,
+        0x0501, 0x0501,
+        0x0503, 0x0503,
+        0x0505, 0x0505,
+        0x0507, 0x0507,
+        0x0509, 0x0509,
+        0x050b, 0x050b,
+        0x050d, 0x050d,
+        0x050f, 0x050f,
+        0x0511, 0x0511,
+        0x0513, 0x0513,
+        0x0515, 0x0515,
+        0x0517, 0x0517,
+        0x0519, 0x0519,
+        0x051b, 0x051b,
+        0x051d, 0x051d,
+        0x051f, 0x051f,
+        0x0521, 0x0521,
+        0x0523, 0x0523,
+        0x0525, 0x0525,
+        0x0561, 0x0587,
+        0x1d79, 0x1d79,
+        0x1d7d, 0x1d7d,
+        0x1e01, 0x1e01,
+        0x1e03, 0x1e03,
+        0x1e05, 0x1e05,
+        0x1e07, 0x1e07,
+        0x1e09, 0x1e09,
+        0x1e0b, 0x1e0b,
+        0x1e0d, 0x1e0d,
+        0x1e0f, 0x1e0f,
+        0x1e11, 0x1e11,
+        0x1e13, 0x1e13,
+        0x1e15, 0x1e15,
+        0x1e17, 0x1e17,
+        0x1e19, 0x1e19,
+        0x1e1b, 0x1e1b,
+        0x1e1d, 0x1e1d,
+        0x1e1f, 0x1e1f,
+        0x1e21, 0x1e21,
+        0x1e23, 0x1e23,
+        0x1e25, 0x1e25,
+        0x1e27, 0x1e27,
+        0x1e29, 0x1e29,
+        0x1e2b, 0x1e2b,
+        0x1e2d, 0x1e2d,
+        0x1e2f, 0x1e2f,
+        0x1e31, 0x1e31,
+        0x1e33, 0x1e33,
+        0x1e35, 0x1e35,
+        0x1e37, 0x1e37,
+        0x1e39, 0x1e39,
+        0x1e3b, 0x1e3b,
+        0x1e3d, 0x1e3d,
+        0x1e3f, 0x1e3f,
+        0x1e41, 0x1e41,
+        0x1e43, 0x1e43,
+        0x1e45, 0x1e45,
+        0x1e47, 0x1e47,
+        0x1e49, 0x1e49,
+        0x1e4b, 0x1e4b,
+        0x1e4d, 0x1e4d,
+        0x1e4f, 0x1e4f,
+        0x1e51, 0x1e51,
+        0x1e53, 0x1e53,
+        0x1e55, 0x1e55,
+        0x1e57, 0x1e57,
+        0x1e59, 0x1e59,
+        0x1e5b, 0x1e5b,
+        0x1e5d, 0x1e5d,
+        0x1e5f, 0x1e5f,
+        0x1e61, 0x1e61,
+        0x1e63, 0x1e63,
+        0x1e65, 0x1e65,
+        0x1e67, 0x1e67,
+        0x1e69, 0x1e69,
+        0x1e6b, 0x1e6b,
+        0x1e6d, 0x1e6d,
+        0x1e6f, 0x1e6f,
+        0x1e71, 0x1e71,
+        0x1e73, 0x1e73,
+        0x1e75, 0x1e75,
+        0x1e77, 0x1e77,
+        0x1e79, 0x1e79,
+        0x1e7b, 0x1e7b,
+        0x1e7d, 0x1e7d,
+        0x1e7f, 0x1e7f,
+        0x1e81, 0x1e81,
+        0x1e83, 0x1e83,
+        0x1e85, 0x1e85,
+        0x1e87, 0x1e87,
+        0x1e89, 0x1e89,
+        0x1e8b, 0x1e8b,
+        0x1e8d, 0x1e8d,
+        0x1e8f, 0x1e8f,
+        0x1e91, 0x1e91,
+        0x1e93, 0x1e93,
+        0x1e95, 0x1e9b,
+        0x1ea1, 0x1ea1,
+        0x1ea3, 0x1ea3,
+        0x1ea5, 0x1ea5,
+        0x1ea7, 0x1ea7,
+        0x1ea9, 0x1ea9,
+        0x1eab, 0x1eab,
+        0x1ead, 0x1ead,
+        0x1eaf, 0x1eaf,
+        0x1eb1, 0x1eb1,
+        0x1eb3, 0x1eb3,
+        0x1eb5, 0x1eb5,
+        0x1eb7, 0x1eb7,
+        0x1eb9, 0x1eb9,
+        0x1ebb, 0x1ebb,
+        0x1ebd, 0x1ebd,
+        0x1ebf, 0x1ebf,
+        0x1ec1, 0x1ec1,
+        0x1ec3, 0x1ec3,
+        0x1ec5, 0x1ec5,
+        0x1ec7, 0x1ec7,
+        0x1ec9, 0x1ec9,
+        0x1ecb, 0x1ecb,
+        0x1ecd, 0x1ecd,
+        0x1ecf, 0x1ecf,
+        0x1ed1, 0x1ed1,
+        0x1ed3, 0x1ed3,
+        0x1ed5, 0x1ed5,
+        0x1ed7, 0x1ed7,
+        0x1ed9, 0x1ed9,
+        0x1edb, 0x1edb,
+        0x1edd, 0x1edd,
+        0x1edf, 0x1edf,
+        0x1ee1, 0x1ee1,
+        0x1ee3, 0x1ee3,
+        0x1ee5, 0x1ee5,
+        0x1ee7, 0x1ee7,
+        0x1ee9, 0x1ee9,
+        0x1eeb, 0x1eeb,
+        0x1eed, 0x1eed,
+        0x1eef, 0x1eef,
+        0x1ef1, 0x1ef1,
+        0x1ef3, 0x1ef3,
+        0x1ef5, 0x1ef5,
+        0x1ef7, 0x1ef7,
+        0x1ef9, 0x1ef9,
+        0x1efb, 0x1efb,
+        0x1efd, 0x1efd,
+        0x1eff, 0x1f07,
+        0x1f10, 0x1f15,
+        0x1f20, 0x1f27,
+        0x1f30, 0x1f37,
+        0x1f40, 0x1f45,
+        0x1f50, 0x1f57,
+        0x1f60, 0x1f67,
+        0x1f70, 0x1f7d,
+        0x1f80, 0x1f87,
+        0x1f90, 0x1f97,
+        0x1fa0, 0x1fa7,
+        0x1fb0, 0x1fb4,
+        0x1fb6, 0x1fb7,
+        0x1fbe, 0x1fbe,
+        0x1fc2, 0x1fc4,
+        0x1fc6, 0x1fc7,
+        0x1fd0, 0x1fd3,
+        0x1fd6, 0x1fd7,
+        0x1fe0, 0x1fe7,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ff7,
+        0x214e, 0x214e,
+        0x2170, 0x217f,
+        0x2184, 0x2184,
+        0x24d0, 0x24e9,
+        0x2c30, 0x2c5e,
+        0x2c61, 0x2c61,
+        0x2c65, 0x2c66,
+        0x2c68, 0x2c68,
+        0x2c6a, 0x2c6a,
+        0x2c6c, 0x2c6c,
+        0x2c73, 0x2c73,
+        0x2c76, 0x2c76,
+        0x2c81, 0x2c81,
+        0x2c83, 0x2c83,
+        0x2c85, 0x2c85,
+        0x2c87, 0x2c87,
+        0x2c89, 0x2c89,
+        0x2c8b, 0x2c8b,
+        0x2c8d, 0x2c8d,
+        0x2c8f, 0x2c8f,
+        0x2c91, 0x2c91,
+        0x2c93, 0x2c93,
+        0x2c95, 0x2c95,
+        0x2c97, 0x2c97,
+        0x2c99, 0x2c99,
+        0x2c9b, 0x2c9b,
+        0x2c9d, 0x2c9d,
+        0x2c9f, 0x2c9f,
+        0x2ca1, 0x2ca1,
+        0x2ca3, 0x2ca3,
+        0x2ca5, 0x2ca5,
+        0x2ca7, 0x2ca7,
+        0x2ca9, 0x2ca9,
+        0x2cab, 0x2cab,
+        0x2cad, 0x2cad,
+        0x2caf, 0x2caf,
+        0x2cb1, 0x2cb1,
+        0x2cb3, 0x2cb3,
+        0x2cb5, 0x2cb5,
+        0x2cb7, 0x2cb7,
+        0x2cb9, 0x2cb9,
+        0x2cbb, 0x2cbb,
+        0x2cbd, 0x2cbd,
+        0x2cbf, 0x2cbf,
+        0x2cc1, 0x2cc1,
+        0x2cc3, 0x2cc3,
+        0x2cc5, 0x2cc5,
+        0x2cc7, 0x2cc7,
+        0x2cc9, 0x2cc9,
+        0x2ccb, 0x2ccb,
+        0x2ccd, 0x2ccd,
+        0x2ccf, 0x2ccf,
+        0x2cd1, 0x2cd1,
+        0x2cd3, 0x2cd3,
+        0x2cd5, 0x2cd5,
+        0x2cd7, 0x2cd7,
+        0x2cd9, 0x2cd9,
+        0x2cdb, 0x2cdb,
+        0x2cdd, 0x2cdd,
+        0x2cdf, 0x2cdf,
+        0x2ce1, 0x2ce1,
+        0x2ce3, 0x2ce3,
+        0x2cec, 0x2cec,
+        0x2cee, 0x2cee,
+        0x2d00, 0x2d25,
+        0xa641, 0xa641,
+        0xa643, 0xa643,
+        0xa645, 0xa645,
+        0xa647, 0xa647,
+        0xa649, 0xa649,
+        0xa64b, 0xa64b,
+        0xa64d, 0xa64d,
+        0xa64f, 0xa64f,
+        0xa651, 0xa651,
+        0xa653, 0xa653,
+        0xa655, 0xa655,
+        0xa657, 0xa657,
+        0xa659, 0xa659,
+        0xa65b, 0xa65b,
+        0xa65d, 0xa65d,
+        0xa65f, 0xa65f,
+        0xa663, 0xa663,
+        0xa665, 0xa665,
+        0xa667, 0xa667,
+        0xa669, 0xa669,
+        0xa66b, 0xa66b,
+        0xa66d, 0xa66d,
+        0xa681, 0xa681,
+        0xa683, 0xa683,
+        0xa685, 0xa685,
+        0xa687, 0xa687,
+        0xa689, 0xa689,
+        0xa68b, 0xa68b,
+        0xa68d, 0xa68d,
+        0xa68f, 0xa68f,
+        0xa691, 0xa691,
+        0xa693, 0xa693,
+        0xa695, 0xa695,
+        0xa697, 0xa697,
+        0xa723, 0xa723,
+        0xa725, 0xa725,
+        0xa727, 0xa727,
+        0xa729, 0xa729,
+        0xa72b, 0xa72b,
+        0xa72d, 0xa72d,
+        0xa72f, 0xa72f,
+        0xa733, 0xa733,
+        0xa735, 0xa735,
+        0xa737, 0xa737,
+        0xa739, 0xa739,
+        0xa73b, 0xa73b,
+        0xa73d, 0xa73d,
+        0xa73f, 0xa73f,
+        0xa741, 0xa741,
+        0xa743, 0xa743,
+        0xa745, 0xa745,
+        0xa747, 0xa747,
+        0xa749, 0xa749,
+        0xa74b, 0xa74b,
+        0xa74d, 0xa74d,
+        0xa74f, 0xa74f,
+        0xa751, 0xa751,
+        0xa753, 0xa753,
+        0xa755, 0xa755,
+        0xa757, 0xa757,
+        0xa759, 0xa759,
+        0xa75b, 0xa75b,
+        0xa75d, 0xa75d,
+        0xa75f, 0xa75f,
+        0xa761, 0xa761,
+        0xa763, 0xa763,
+        0xa765, 0xa765,
+        0xa767, 0xa767,
+        0xa769, 0xa769,
+        0xa76b, 0xa76b,
+        0xa76d, 0xa76d,
+        0xa76f, 0xa76f,
+        0xa77a, 0xa77a,
+        0xa77c, 0xa77c,
+        0xa77f, 0xa77f,
+        0xa781, 0xa781,
+        0xa783, 0xa783,
+        0xa785, 0xa785,
+        0xa787, 0xa787,
+        0xa78c, 0xa78c,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xff41, 0xff5a,
+        0x10428, 0x1044f,
 }; /* CR_Changes_When_Titlecased */
 
 /* 'Changes_When_Casefolded': Derived Property */
 static const OnigCodePoint CR_Changes_When_Casefolded[] = {
-	568,
-	0x0041, 0x005a,
-	0x00b5, 0x00b5,
-	0x00c0, 0x00d6,
-	0x00d8, 0x00df,
-	0x0100, 0x0100,
-	0x0102, 0x0102,
-	0x0104, 0x0104,
-	0x0106, 0x0106,
-	0x0108, 0x0108,
-	0x010a, 0x010a,
-	0x010c, 0x010c,
-	0x010e, 0x010e,
-	0x0110, 0x0110,
-	0x0112, 0x0112,
-	0x0114, 0x0114,
-	0x0116, 0x0116,
-	0x0118, 0x0118,
-	0x011a, 0x011a,
-	0x011c, 0x011c,
-	0x011e, 0x011e,
-	0x0120, 0x0120,
-	0x0122, 0x0122,
-	0x0124, 0x0124,
-	0x0126, 0x0126,
-	0x0128, 0x0128,
-	0x012a, 0x012a,
-	0x012c, 0x012c,
-	0x012e, 0x012e,
-	0x0130, 0x0130,
-	0x0132, 0x0132,
-	0x0134, 0x0134,
-	0x0136, 0x0136,
-	0x0139, 0x0139,
-	0x013b, 0x013b,
-	0x013d, 0x013d,
-	0x013f, 0x013f,
-	0x0141, 0x0141,
-	0x0143, 0x0143,
-	0x0145, 0x0145,
-	0x0147, 0x0147,
-	0x0149, 0x014a,
-	0x014c, 0x014c,
-	0x014e, 0x014e,
-	0x0150, 0x0150,
-	0x0152, 0x0152,
-	0x0154, 0x0154,
-	0x0156, 0x0156,
-	0x0158, 0x0158,
-	0x015a, 0x015a,
-	0x015c, 0x015c,
-	0x015e, 0x015e,
-	0x0160, 0x0160,
-	0x0162, 0x0162,
-	0x0164, 0x0164,
-	0x0166, 0x0166,
-	0x0168, 0x0168,
-	0x016a, 0x016a,
-	0x016c, 0x016c,
-	0x016e, 0x016e,
-	0x0170, 0x0170,
-	0x0172, 0x0172,
-	0x0174, 0x0174,
-	0x0176, 0x0176,
-	0x0178, 0x0179,
-	0x017b, 0x017b,
-	0x017d, 0x017d,
-	0x017f, 0x017f,
-	0x0181, 0x0182,
-	0x0184, 0x0184,
-	0x0186, 0x0187,
-	0x0189, 0x018b,
-	0x018e, 0x0191,
-	0x0193, 0x0194,
-	0x0196, 0x0198,
-	0x019c, 0x019d,
-	0x019f, 0x01a0,
-	0x01a2, 0x01a2,
-	0x01a4, 0x01a4,
-	0x01a6, 0x01a7,
-	0x01a9, 0x01a9,
-	0x01ac, 0x01ac,
-	0x01ae, 0x01af,
-	0x01b1, 0x01b3,
-	0x01b5, 0x01b5,
-	0x01b7, 0x01b8,
-	0x01bc, 0x01bc,
-	0x01c4, 0x01c5,
-	0x01c7, 0x01c8,
-	0x01ca, 0x01cb,
-	0x01cd, 0x01cd,
-	0x01cf, 0x01cf,
-	0x01d1, 0x01d1,
-	0x01d3, 0x01d3,
-	0x01d5, 0x01d5,
-	0x01d7, 0x01d7,
-	0x01d9, 0x01d9,
-	0x01db, 0x01db,
-	0x01de, 0x01de,
-	0x01e0, 0x01e0,
-	0x01e2, 0x01e2,
-	0x01e4, 0x01e4,
-	0x01e6, 0x01e6,
-	0x01e8, 0x01e8,
-	0x01ea, 0x01ea,
-	0x01ec, 0x01ec,
-	0x01ee, 0x01ee,
-	0x01f1, 0x01f2,
-	0x01f4, 0x01f4,
-	0x01f6, 0x01f8,
-	0x01fa, 0x01fa,
-	0x01fc, 0x01fc,
-	0x01fe, 0x01fe,
-	0x0200, 0x0200,
-	0x0202, 0x0202,
-	0x0204, 0x0204,
-	0x0206, 0x0206,
-	0x0208, 0x0208,
-	0x020a, 0x020a,
-	0x020c, 0x020c,
-	0x020e, 0x020e,
-	0x0210, 0x0210,
-	0x0212, 0x0212,
-	0x0214, 0x0214,
-	0x0216, 0x0216,
-	0x0218, 0x0218,
-	0x021a, 0x021a,
-	0x021c, 0x021c,
-	0x021e, 0x021e,
-	0x0220, 0x0220,
-	0x0222, 0x0222,
-	0x0224, 0x0224,
-	0x0226, 0x0226,
-	0x0228, 0x0228,
-	0x022a, 0x022a,
-	0x022c, 0x022c,
-	0x022e, 0x022e,
-	0x0230, 0x0230,
-	0x0232, 0x0232,
-	0x023a, 0x023b,
-	0x023d, 0x023e,
-	0x0241, 0x0241,
-	0x0243, 0x0246,
-	0x0248, 0x0248,
-	0x024a, 0x024a,
-	0x024c, 0x024c,
-	0x024e, 0x024e,
-	0x0345, 0x0345,
-	0x0370, 0x0370,
-	0x0372, 0x0372,
-	0x0376, 0x0376,
-	0x0386, 0x0386,
-	0x0388, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x038f,
-	0x0391, 0x03a1,
-	0x03a3, 0x03ab,
-	0x03c2, 0x03c2,
-	0x03cf, 0x03d1,
-	0x03d5, 0x03d6,
-	0x03d8, 0x03d8,
-	0x03da, 0x03da,
-	0x03dc, 0x03dc,
-	0x03de, 0x03de,
-	0x03e0, 0x03e0,
-	0x03e2, 0x03e2,
-	0x03e4, 0x03e4,
-	0x03e6, 0x03e6,
-	0x03e8, 0x03e8,
-	0x03ea, 0x03ea,
-	0x03ec, 0x03ec,
-	0x03ee, 0x03ee,
-	0x03f0, 0x03f1,
-	0x03f4, 0x03f5,
-	0x03f7, 0x03f7,
-	0x03f9, 0x03fa,
-	0x03fd, 0x042f,
-	0x0460, 0x0460,
-	0x0462, 0x0462,
-	0x0464, 0x0464,
-	0x0466, 0x0466,
-	0x0468, 0x0468,
-	0x046a, 0x046a,
-	0x046c, 0x046c,
-	0x046e, 0x046e,
-	0x0470, 0x0470,
-	0x0472, 0x0472,
-	0x0474, 0x0474,
-	0x0476, 0x0476,
-	0x0478, 0x0478,
-	0x047a, 0x047a,
-	0x047c, 0x047c,
-	0x047e, 0x047e,
-	0x0480, 0x0480,
-	0x048a, 0x048a,
-	0x048c, 0x048c,
-	0x048e, 0x048e,
-	0x0490, 0x0490,
-	0x0492, 0x0492,
-	0x0494, 0x0494,
-	0x0496, 0x0496,
-	0x0498, 0x0498,
-	0x049a, 0x049a,
-	0x049c, 0x049c,
-	0x049e, 0x049e,
-	0x04a0, 0x04a0,
-	0x04a2, 0x04a2,
-	0x04a4, 0x04a4,
-	0x04a6, 0x04a6,
-	0x04a8, 0x04a8,
-	0x04aa, 0x04aa,
-	0x04ac, 0x04ac,
-	0x04ae, 0x04ae,
-	0x04b0, 0x04b0,
-	0x04b2, 0x04b2,
-	0x04b4, 0x04b4,
-	0x04b6, 0x04b6,
-	0x04b8, 0x04b8,
-	0x04ba, 0x04ba,
-	0x04bc, 0x04bc,
-	0x04be, 0x04be,
-	0x04c0, 0x04c1,
-	0x04c3, 0x04c3,
-	0x04c5, 0x04c5,
-	0x04c7, 0x04c7,
-	0x04c9, 0x04c9,
-	0x04cb, 0x04cb,
-	0x04cd, 0x04cd,
-	0x04d0, 0x04d0,
-	0x04d2, 0x04d2,
-	0x04d4, 0x04d4,
-	0x04d6, 0x04d6,
-	0x04d8, 0x04d8,
-	0x04da, 0x04da,
-	0x04dc, 0x04dc,
-	0x04de, 0x04de,
-	0x04e0, 0x04e0,
-	0x04e2, 0x04e2,
-	0x04e4, 0x04e4,
-	0x04e6, 0x04e6,
-	0x04e8, 0x04e8,
-	0x04ea, 0x04ea,
-	0x04ec, 0x04ec,
-	0x04ee, 0x04ee,
-	0x04f0, 0x04f0,
-	0x04f2, 0x04f2,
-	0x04f4, 0x04f4,
-	0x04f6, 0x04f6,
-	0x04f8, 0x04f8,
-	0x04fa, 0x04fa,
-	0x04fc, 0x04fc,
-	0x04fe, 0x04fe,
-	0x0500, 0x0500,
-	0x0502, 0x0502,
-	0x0504, 0x0504,
-	0x0506, 0x0506,
-	0x0508, 0x0508,
-	0x050a, 0x050a,
-	0x050c, 0x050c,
-	0x050e, 0x050e,
-	0x0510, 0x0510,
-	0x0512, 0x0512,
-	0x0514, 0x0514,
-	0x0516, 0x0516,
-	0x0518, 0x0518,
-	0x051a, 0x051a,
-	0x051c, 0x051c,
-	0x051e, 0x051e,
-	0x0520, 0x0520,
-	0x0522, 0x0522,
-	0x0524, 0x0524,
-	0x0531, 0x0556,
-	0x0587, 0x0587,
-	0x10a0, 0x10c5,
-	0x1e00, 0x1e00,
-	0x1e02, 0x1e02,
-	0x1e04, 0x1e04,
-	0x1e06, 0x1e06,
-	0x1e08, 0x1e08,
-	0x1e0a, 0x1e0a,
-	0x1e0c, 0x1e0c,
-	0x1e0e, 0x1e0e,
-	0x1e10, 0x1e10,
-	0x1e12, 0x1e12,
-	0x1e14, 0x1e14,
-	0x1e16, 0x1e16,
-	0x1e18, 0x1e18,
-	0x1e1a, 0x1e1a,
-	0x1e1c, 0x1e1c,
-	0x1e1e, 0x1e1e,
-	0x1e20, 0x1e20,
-	0x1e22, 0x1e22,
-	0x1e24, 0x1e24,
-	0x1e26, 0x1e26,
-	0x1e28, 0x1e28,
-	0x1e2a, 0x1e2a,
-	0x1e2c, 0x1e2c,
-	0x1e2e, 0x1e2e,
-	0x1e30, 0x1e30,
-	0x1e32, 0x1e32,
-	0x1e34, 0x1e34,
-	0x1e36, 0x1e36,
-	0x1e38, 0x1e38,
-	0x1e3a, 0x1e3a,
-	0x1e3c, 0x1e3c,
-	0x1e3e, 0x1e3e,
-	0x1e40, 0x1e40,
-	0x1e42, 0x1e42,
-	0x1e44, 0x1e44,
-	0x1e46, 0x1e46,
-	0x1e48, 0x1e48,
-	0x1e4a, 0x1e4a,
-	0x1e4c, 0x1e4c,
-	0x1e4e, 0x1e4e,
-	0x1e50, 0x1e50,
-	0x1e52, 0x1e52,
-	0x1e54, 0x1e54,
-	0x1e56, 0x1e56,
-	0x1e58, 0x1e58,
-	0x1e5a, 0x1e5a,
-	0x1e5c, 0x1e5c,
-	0x1e5e, 0x1e5e,
-	0x1e60, 0x1e60,
-	0x1e62, 0x1e62,
-	0x1e64, 0x1e64,
-	0x1e66, 0x1e66,
-	0x1e68, 0x1e68,
-	0x1e6a, 0x1e6a,
-	0x1e6c, 0x1e6c,
-	0x1e6e, 0x1e6e,
-	0x1e70, 0x1e70,
-	0x1e72, 0x1e72,
-	0x1e74, 0x1e74,
-	0x1e76, 0x1e76,
-	0x1e78, 0x1e78,
-	0x1e7a, 0x1e7a,
-	0x1e7c, 0x1e7c,
-	0x1e7e, 0x1e7e,
-	0x1e80, 0x1e80,
-	0x1e82, 0x1e82,
-	0x1e84, 0x1e84,
-	0x1e86, 0x1e86,
-	0x1e88, 0x1e88,
-	0x1e8a, 0x1e8a,
-	0x1e8c, 0x1e8c,
-	0x1e8e, 0x1e8e,
-	0x1e90, 0x1e90,
-	0x1e92, 0x1e92,
-	0x1e94, 0x1e94,
-	0x1e9a, 0x1e9b,
-	0x1e9e, 0x1e9e,
-	0x1ea0, 0x1ea0,
-	0x1ea2, 0x1ea2,
-	0x1ea4, 0x1ea4,
-	0x1ea6, 0x1ea6,
-	0x1ea8, 0x1ea8,
-	0x1eaa, 0x1eaa,
-	0x1eac, 0x1eac,
-	0x1eae, 0x1eae,
-	0x1eb0, 0x1eb0,
-	0x1eb2, 0x1eb2,
-	0x1eb4, 0x1eb4,
-	0x1eb6, 0x1eb6,
-	0x1eb8, 0x1eb8,
-	0x1eba, 0x1eba,
-	0x1ebc, 0x1ebc,
-	0x1ebe, 0x1ebe,
-	0x1ec0, 0x1ec0,
-	0x1ec2, 0x1ec2,
-	0x1ec4, 0x1ec4,
-	0x1ec6, 0x1ec6,
-	0x1ec8, 0x1ec8,
-	0x1eca, 0x1eca,
-	0x1ecc, 0x1ecc,
-	0x1ece, 0x1ece,
-	0x1ed0, 0x1ed0,
-	0x1ed2, 0x1ed2,
-	0x1ed4, 0x1ed4,
-	0x1ed6, 0x1ed6,
-	0x1ed8, 0x1ed8,
-	0x1eda, 0x1eda,
-	0x1edc, 0x1edc,
-	0x1ede, 0x1ede,
-	0x1ee0, 0x1ee0,
-	0x1ee2, 0x1ee2,
-	0x1ee4, 0x1ee4,
-	0x1ee6, 0x1ee6,
-	0x1ee8, 0x1ee8,
-	0x1eea, 0x1eea,
-	0x1eec, 0x1eec,
-	0x1eee, 0x1eee,
-	0x1ef0, 0x1ef0,
-	0x1ef2, 0x1ef2,
-	0x1ef4, 0x1ef4,
-	0x1ef6, 0x1ef6,
-	0x1ef8, 0x1ef8,
-	0x1efa, 0x1efa,
-	0x1efc, 0x1efc,
-	0x1efe, 0x1efe,
-	0x1f08, 0x1f0f,
-	0x1f18, 0x1f1d,
-	0x1f28, 0x1f2f,
-	0x1f38, 0x1f3f,
-	0x1f48, 0x1f4d,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f5f,
-	0x1f68, 0x1f6f,
-	0x1f80, 0x1faf,
-	0x1fb2, 0x1fb4,
-	0x1fb7, 0x1fbc,
-	0x1fc2, 0x1fc4,
-	0x1fc7, 0x1fcc,
-	0x1fd8, 0x1fdb,
-	0x1fe8, 0x1fec,
-	0x1ff2, 0x1ff4,
-	0x1ff7, 0x1ffc,
-	0x2126, 0x2126,
-	0x212a, 0x212b,
-	0x2132, 0x2132,
-	0x2160, 0x216f,
-	0x2183, 0x2183,
-	0x24b6, 0x24cf,
-	0x2c00, 0x2c2e,
-	0x2c60, 0x2c60,
-	0x2c62, 0x2c64,
-	0x2c67, 0x2c67,
-	0x2c69, 0x2c69,
-	0x2c6b, 0x2c6b,
-	0x2c6d, 0x2c70,
-	0x2c72, 0x2c72,
-	0x2c75, 0x2c75,
-	0x2c7e, 0x2c80,
-	0x2c82, 0x2c82,
-	0x2c84, 0x2c84,
-	0x2c86, 0x2c86,
-	0x2c88, 0x2c88,
-	0x2c8a, 0x2c8a,
-	0x2c8c, 0x2c8c,
-	0x2c8e, 0x2c8e,
-	0x2c90, 0x2c90,
-	0x2c92, 0x2c92,
-	0x2c94, 0x2c94,
-	0x2c96, 0x2c96,
-	0x2c98, 0x2c98,
-	0x2c9a, 0x2c9a,
-	0x2c9c, 0x2c9c,
-	0x2c9e, 0x2c9e,
-	0x2ca0, 0x2ca0,
-	0x2ca2, 0x2ca2,
-	0x2ca4, 0x2ca4,
-	0x2ca6, 0x2ca6,
-	0x2ca8, 0x2ca8,
-	0x2caa, 0x2caa,
-	0x2cac, 0x2cac,
-	0x2cae, 0x2cae,
-	0x2cb0, 0x2cb0,
-	0x2cb2, 0x2cb2,
-	0x2cb4, 0x2cb4,
-	0x2cb6, 0x2cb6,
-	0x2cb8, 0x2cb8,
-	0x2cba, 0x2cba,
-	0x2cbc, 0x2cbc,
-	0x2cbe, 0x2cbe,
-	0x2cc0, 0x2cc0,
-	0x2cc2, 0x2cc2,
-	0x2cc4, 0x2cc4,
-	0x2cc6, 0x2cc6,
-	0x2cc8, 0x2cc8,
-	0x2cca, 0x2cca,
-	0x2ccc, 0x2ccc,
-	0x2cce, 0x2cce,
-	0x2cd0, 0x2cd0,
-	0x2cd2, 0x2cd2,
-	0x2cd4, 0x2cd4,
-	0x2cd6, 0x2cd6,
-	0x2cd8, 0x2cd8,
-	0x2cda, 0x2cda,
-	0x2cdc, 0x2cdc,
-	0x2cde, 0x2cde,
-	0x2ce0, 0x2ce0,
-	0x2ce2, 0x2ce2,
-	0x2ceb, 0x2ceb,
-	0x2ced, 0x2ced,
-	0xa640, 0xa640,
-	0xa642, 0xa642,
-	0xa644, 0xa644,
-	0xa646, 0xa646,
-	0xa648, 0xa648,
-	0xa64a, 0xa64a,
-	0xa64c, 0xa64c,
-	0xa64e, 0xa64e,
-	0xa650, 0xa650,
-	0xa652, 0xa652,
-	0xa654, 0xa654,
-	0xa656, 0xa656,
-	0xa658, 0xa658,
-	0xa65a, 0xa65a,
-	0xa65c, 0xa65c,
-	0xa65e, 0xa65e,
-	0xa662, 0xa662,
-	0xa664, 0xa664,
-	0xa666, 0xa666,
-	0xa668, 0xa668,
-	0xa66a, 0xa66a,
-	0xa66c, 0xa66c,
-	0xa680, 0xa680,
-	0xa682, 0xa682,
-	0xa684, 0xa684,
-	0xa686, 0xa686,
-	0xa688, 0xa688,
-	0xa68a, 0xa68a,
-	0xa68c, 0xa68c,
-	0xa68e, 0xa68e,
-	0xa690, 0xa690,
-	0xa692, 0xa692,
-	0xa694, 0xa694,
-	0xa696, 0xa696,
-	0xa722, 0xa722,
-	0xa724, 0xa724,
-	0xa726, 0xa726,
-	0xa728, 0xa728,
-	0xa72a, 0xa72a,
-	0xa72c, 0xa72c,
-	0xa72e, 0xa72e,
-	0xa732, 0xa732,
-	0xa734, 0xa734,
-	0xa736, 0xa736,
-	0xa738, 0xa738,
-	0xa73a, 0xa73a,
-	0xa73c, 0xa73c,
-	0xa73e, 0xa73e,
-	0xa740, 0xa740,
-	0xa742, 0xa742,
-	0xa744, 0xa744,
-	0xa746, 0xa746,
-	0xa748, 0xa748,
-	0xa74a, 0xa74a,
-	0xa74c, 0xa74c,
-	0xa74e, 0xa74e,
-	0xa750, 0xa750,
-	0xa752, 0xa752,
-	0xa754, 0xa754,
-	0xa756, 0xa756,
-	0xa758, 0xa758,
-	0xa75a, 0xa75a,
-	0xa75c, 0xa75c,
-	0xa75e, 0xa75e,
-	0xa760, 0xa760,
-	0xa762, 0xa762,
-	0xa764, 0xa764,
-	0xa766, 0xa766,
-	0xa768, 0xa768,
-	0xa76a, 0xa76a,
-	0xa76c, 0xa76c,
-	0xa76e, 0xa76e,
-	0xa779, 0xa779,
-	0xa77b, 0xa77b,
-	0xa77d, 0xa77e,
-	0xa780, 0xa780,
-	0xa782, 0xa782,
-	0xa784, 0xa784,
-	0xa786, 0xa786,
-	0xa78b, 0xa78b,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xff21, 0xff3a,
-	0x10400, 0x10427,
+        568,
+        0x0041, 0x005a,
+        0x00b5, 0x00b5,
+        0x00c0, 0x00d6,
+        0x00d8, 0x00df,
+        0x0100, 0x0100,
+        0x0102, 0x0102,
+        0x0104, 0x0104,
+        0x0106, 0x0106,
+        0x0108, 0x0108,
+        0x010a, 0x010a,
+        0x010c, 0x010c,
+        0x010e, 0x010e,
+        0x0110, 0x0110,
+        0x0112, 0x0112,
+        0x0114, 0x0114,
+        0x0116, 0x0116,
+        0x0118, 0x0118,
+        0x011a, 0x011a,
+        0x011c, 0x011c,
+        0x011e, 0x011e,
+        0x0120, 0x0120,
+        0x0122, 0x0122,
+        0x0124, 0x0124,
+        0x0126, 0x0126,
+        0x0128, 0x0128,
+        0x012a, 0x012a,
+        0x012c, 0x012c,
+        0x012e, 0x012e,
+        0x0130, 0x0130,
+        0x0132, 0x0132,
+        0x0134, 0x0134,
+        0x0136, 0x0136,
+        0x0139, 0x0139,
+        0x013b, 0x013b,
+        0x013d, 0x013d,
+        0x013f, 0x013f,
+        0x0141, 0x0141,
+        0x0143, 0x0143,
+        0x0145, 0x0145,
+        0x0147, 0x0147,
+        0x0149, 0x014a,
+        0x014c, 0x014c,
+        0x014e, 0x014e,
+        0x0150, 0x0150,
+        0x0152, 0x0152,
+        0x0154, 0x0154,
+        0x0156, 0x0156,
+        0x0158, 0x0158,
+        0x015a, 0x015a,
+        0x015c, 0x015c,
+        0x015e, 0x015e,
+        0x0160, 0x0160,
+        0x0162, 0x0162,
+        0x0164, 0x0164,
+        0x0166, 0x0166,
+        0x0168, 0x0168,
+        0x016a, 0x016a,
+        0x016c, 0x016c,
+        0x016e, 0x016e,
+        0x0170, 0x0170,
+        0x0172, 0x0172,
+        0x0174, 0x0174,
+        0x0176, 0x0176,
+        0x0178, 0x0179,
+        0x017b, 0x017b,
+        0x017d, 0x017d,
+        0x017f, 0x017f,
+        0x0181, 0x0182,
+        0x0184, 0x0184,
+        0x0186, 0x0187,
+        0x0189, 0x018b,
+        0x018e, 0x0191,
+        0x0193, 0x0194,
+        0x0196, 0x0198,
+        0x019c, 0x019d,
+        0x019f, 0x01a0,
+        0x01a2, 0x01a2,
+        0x01a4, 0x01a4,
+        0x01a6, 0x01a7,
+        0x01a9, 0x01a9,
+        0x01ac, 0x01ac,
+        0x01ae, 0x01af,
+        0x01b1, 0x01b3,
+        0x01b5, 0x01b5,
+        0x01b7, 0x01b8,
+        0x01bc, 0x01bc,
+        0x01c4, 0x01c5,
+        0x01c7, 0x01c8,
+        0x01ca, 0x01cb,
+        0x01cd, 0x01cd,
+        0x01cf, 0x01cf,
+        0x01d1, 0x01d1,
+        0x01d3, 0x01d3,
+        0x01d5, 0x01d5,
+        0x01d7, 0x01d7,
+        0x01d9, 0x01d9,
+        0x01db, 0x01db,
+        0x01de, 0x01de,
+        0x01e0, 0x01e0,
+        0x01e2, 0x01e2,
+        0x01e4, 0x01e4,
+        0x01e6, 0x01e6,
+        0x01e8, 0x01e8,
+        0x01ea, 0x01ea,
+        0x01ec, 0x01ec,
+        0x01ee, 0x01ee,
+        0x01f1, 0x01f2,
+        0x01f4, 0x01f4,
+        0x01f6, 0x01f8,
+        0x01fa, 0x01fa,
+        0x01fc, 0x01fc,
+        0x01fe, 0x01fe,
+        0x0200, 0x0200,
+        0x0202, 0x0202,
+        0x0204, 0x0204,
+        0x0206, 0x0206,
+        0x0208, 0x0208,
+        0x020a, 0x020a,
+        0x020c, 0x020c,
+        0x020e, 0x020e,
+        0x0210, 0x0210,
+        0x0212, 0x0212,
+        0x0214, 0x0214,
+        0x0216, 0x0216,
+        0x0218, 0x0218,
+        0x021a, 0x021a,
+        0x021c, 0x021c,
+        0x021e, 0x021e,
+        0x0220, 0x0220,
+        0x0222, 0x0222,
+        0x0224, 0x0224,
+        0x0226, 0x0226,
+        0x0228, 0x0228,
+        0x022a, 0x022a,
+        0x022c, 0x022c,
+        0x022e, 0x022e,
+        0x0230, 0x0230,
+        0x0232, 0x0232,
+        0x023a, 0x023b,
+        0x023d, 0x023e,
+        0x0241, 0x0241,
+        0x0243, 0x0246,
+        0x0248, 0x0248,
+        0x024a, 0x024a,
+        0x024c, 0x024c,
+        0x024e, 0x024e,
+        0x0345, 0x0345,
+        0x0370, 0x0370,
+        0x0372, 0x0372,
+        0x0376, 0x0376,
+        0x0386, 0x0386,
+        0x0388, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x038f,
+        0x0391, 0x03a1,
+        0x03a3, 0x03ab,
+        0x03c2, 0x03c2,
+        0x03cf, 0x03d1,
+        0x03d5, 0x03d6,
+        0x03d8, 0x03d8,
+        0x03da, 0x03da,
+        0x03dc, 0x03dc,
+        0x03de, 0x03de,
+        0x03e0, 0x03e0,
+        0x03e2, 0x03e2,
+        0x03e4, 0x03e4,
+        0x03e6, 0x03e6,
+        0x03e8, 0x03e8,
+        0x03ea, 0x03ea,
+        0x03ec, 0x03ec,
+        0x03ee, 0x03ee,
+        0x03f0, 0x03f1,
+        0x03f4, 0x03f5,
+        0x03f7, 0x03f7,
+        0x03f9, 0x03fa,
+        0x03fd, 0x042f,
+        0x0460, 0x0460,
+        0x0462, 0x0462,
+        0x0464, 0x0464,
+        0x0466, 0x0466,
+        0x0468, 0x0468,
+        0x046a, 0x046a,
+        0x046c, 0x046c,
+        0x046e, 0x046e,
+        0x0470, 0x0470,
+        0x0472, 0x0472,
+        0x0474, 0x0474,
+        0x0476, 0x0476,
+        0x0478, 0x0478,
+        0x047a, 0x047a,
+        0x047c, 0x047c,
+        0x047e, 0x047e,
+        0x0480, 0x0480,
+        0x048a, 0x048a,
+        0x048c, 0x048c,
+        0x048e, 0x048e,
+        0x0490, 0x0490,
+        0x0492, 0x0492,
+        0x0494, 0x0494,
+        0x0496, 0x0496,
+        0x0498, 0x0498,
+        0x049a, 0x049a,
+        0x049c, 0x049c,
+        0x049e, 0x049e,
+        0x04a0, 0x04a0,
+        0x04a2, 0x04a2,
+        0x04a4, 0x04a4,
+        0x04a6, 0x04a6,
+        0x04a8, 0x04a8,
+        0x04aa, 0x04aa,
+        0x04ac, 0x04ac,
+        0x04ae, 0x04ae,
+        0x04b0, 0x04b0,
+        0x04b2, 0x04b2,
+        0x04b4, 0x04b4,
+        0x04b6, 0x04b6,
+        0x04b8, 0x04b8,
+        0x04ba, 0x04ba,
+        0x04bc, 0x04bc,
+        0x04be, 0x04be,
+        0x04c0, 0x04c1,
+        0x04c3, 0x04c3,
+        0x04c5, 0x04c5,
+        0x04c7, 0x04c7,
+        0x04c9, 0x04c9,
+        0x04cb, 0x04cb,
+        0x04cd, 0x04cd,
+        0x04d0, 0x04d0,
+        0x04d2, 0x04d2,
+        0x04d4, 0x04d4,
+        0x04d6, 0x04d6,
+        0x04d8, 0x04d8,
+        0x04da, 0x04da,
+        0x04dc, 0x04dc,
+        0x04de, 0x04de,
+        0x04e0, 0x04e0,
+        0x04e2, 0x04e2,
+        0x04e4, 0x04e4,
+        0x04e6, 0x04e6,
+        0x04e8, 0x04e8,
+        0x04ea, 0x04ea,
+        0x04ec, 0x04ec,
+        0x04ee, 0x04ee,
+        0x04f0, 0x04f0,
+        0x04f2, 0x04f2,
+        0x04f4, 0x04f4,
+        0x04f6, 0x04f6,
+        0x04f8, 0x04f8,
+        0x04fa, 0x04fa,
+        0x04fc, 0x04fc,
+        0x04fe, 0x04fe,
+        0x0500, 0x0500,
+        0x0502, 0x0502,
+        0x0504, 0x0504,
+        0x0506, 0x0506,
+        0x0508, 0x0508,
+        0x050a, 0x050a,
+        0x050c, 0x050c,
+        0x050e, 0x050e,
+        0x0510, 0x0510,
+        0x0512, 0x0512,
+        0x0514, 0x0514,
+        0x0516, 0x0516,
+        0x0518, 0x0518,
+        0x051a, 0x051a,
+        0x051c, 0x051c,
+        0x051e, 0x051e,
+        0x0520, 0x0520,
+        0x0522, 0x0522,
+        0x0524, 0x0524,
+        0x0531, 0x0556,
+        0x0587, 0x0587,
+        0x10a0, 0x10c5,
+        0x1e00, 0x1e00,
+        0x1e02, 0x1e02,
+        0x1e04, 0x1e04,
+        0x1e06, 0x1e06,
+        0x1e08, 0x1e08,
+        0x1e0a, 0x1e0a,
+        0x1e0c, 0x1e0c,
+        0x1e0e, 0x1e0e,
+        0x1e10, 0x1e10,
+        0x1e12, 0x1e12,
+        0x1e14, 0x1e14,
+        0x1e16, 0x1e16,
+        0x1e18, 0x1e18,
+        0x1e1a, 0x1e1a,
+        0x1e1c, 0x1e1c,
+        0x1e1e, 0x1e1e,
+        0x1e20, 0x1e20,
+        0x1e22, 0x1e22,
+        0x1e24, 0x1e24,
+        0x1e26, 0x1e26,
+        0x1e28, 0x1e28,
+        0x1e2a, 0x1e2a,
+        0x1e2c, 0x1e2c,
+        0x1e2e, 0x1e2e,
+        0x1e30, 0x1e30,
+        0x1e32, 0x1e32,
+        0x1e34, 0x1e34,
+        0x1e36, 0x1e36,
+        0x1e38, 0x1e38,
+        0x1e3a, 0x1e3a,
+        0x1e3c, 0x1e3c,
+        0x1e3e, 0x1e3e,
+        0x1e40, 0x1e40,
+        0x1e42, 0x1e42,
+        0x1e44, 0x1e44,
+        0x1e46, 0x1e46,
+        0x1e48, 0x1e48,
+        0x1e4a, 0x1e4a,
+        0x1e4c, 0x1e4c,
+        0x1e4e, 0x1e4e,
+        0x1e50, 0x1e50,
+        0x1e52, 0x1e52,
+        0x1e54, 0x1e54,
+        0x1e56, 0x1e56,
+        0x1e58, 0x1e58,
+        0x1e5a, 0x1e5a,
+        0x1e5c, 0x1e5c,
+        0x1e5e, 0x1e5e,
+        0x1e60, 0x1e60,
+        0x1e62, 0x1e62,
+        0x1e64, 0x1e64,
+        0x1e66, 0x1e66,
+        0x1e68, 0x1e68,
+        0x1e6a, 0x1e6a,
+        0x1e6c, 0x1e6c,
+        0x1e6e, 0x1e6e,
+        0x1e70, 0x1e70,
+        0x1e72, 0x1e72,
+        0x1e74, 0x1e74,
+        0x1e76, 0x1e76,
+        0x1e78, 0x1e78,
+        0x1e7a, 0x1e7a,
+        0x1e7c, 0x1e7c,
+        0x1e7e, 0x1e7e,
+        0x1e80, 0x1e80,
+        0x1e82, 0x1e82,
+        0x1e84, 0x1e84,
+        0x1e86, 0x1e86,
+        0x1e88, 0x1e88,
+        0x1e8a, 0x1e8a,
+        0x1e8c, 0x1e8c,
+        0x1e8e, 0x1e8e,
+        0x1e90, 0x1e90,
+        0x1e92, 0x1e92,
+        0x1e94, 0x1e94,
+        0x1e9a, 0x1e9b,
+        0x1e9e, 0x1e9e,
+        0x1ea0, 0x1ea0,
+        0x1ea2, 0x1ea2,
+        0x1ea4, 0x1ea4,
+        0x1ea6, 0x1ea6,
+        0x1ea8, 0x1ea8,
+        0x1eaa, 0x1eaa,
+        0x1eac, 0x1eac,
+        0x1eae, 0x1eae,
+        0x1eb0, 0x1eb0,
+        0x1eb2, 0x1eb2,
+        0x1eb4, 0x1eb4,
+        0x1eb6, 0x1eb6,
+        0x1eb8, 0x1eb8,
+        0x1eba, 0x1eba,
+        0x1ebc, 0x1ebc,
+        0x1ebe, 0x1ebe,
+        0x1ec0, 0x1ec0,
+        0x1ec2, 0x1ec2,
+        0x1ec4, 0x1ec4,
+        0x1ec6, 0x1ec6,
+        0x1ec8, 0x1ec8,
+        0x1eca, 0x1eca,
+        0x1ecc, 0x1ecc,
+        0x1ece, 0x1ece,
+        0x1ed0, 0x1ed0,
+        0x1ed2, 0x1ed2,
+        0x1ed4, 0x1ed4,
+        0x1ed6, 0x1ed6,
+        0x1ed8, 0x1ed8,
+        0x1eda, 0x1eda,
+        0x1edc, 0x1edc,
+        0x1ede, 0x1ede,
+        0x1ee0, 0x1ee0,
+        0x1ee2, 0x1ee2,
+        0x1ee4, 0x1ee4,
+        0x1ee6, 0x1ee6,
+        0x1ee8, 0x1ee8,
+        0x1eea, 0x1eea,
+        0x1eec, 0x1eec,
+        0x1eee, 0x1eee,
+        0x1ef0, 0x1ef0,
+        0x1ef2, 0x1ef2,
+        0x1ef4, 0x1ef4,
+        0x1ef6, 0x1ef6,
+        0x1ef8, 0x1ef8,
+        0x1efa, 0x1efa,
+        0x1efc, 0x1efc,
+        0x1efe, 0x1efe,
+        0x1f08, 0x1f0f,
+        0x1f18, 0x1f1d,
+        0x1f28, 0x1f2f,
+        0x1f38, 0x1f3f,
+        0x1f48, 0x1f4d,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f5f,
+        0x1f68, 0x1f6f,
+        0x1f80, 0x1faf,
+        0x1fb2, 0x1fb4,
+        0x1fb7, 0x1fbc,
+        0x1fc2, 0x1fc4,
+        0x1fc7, 0x1fcc,
+        0x1fd8, 0x1fdb,
+        0x1fe8, 0x1fec,
+        0x1ff2, 0x1ff4,
+        0x1ff7, 0x1ffc,
+        0x2126, 0x2126,
+        0x212a, 0x212b,
+        0x2132, 0x2132,
+        0x2160, 0x216f,
+        0x2183, 0x2183,
+        0x24b6, 0x24cf,
+        0x2c00, 0x2c2e,
+        0x2c60, 0x2c60,
+        0x2c62, 0x2c64,
+        0x2c67, 0x2c67,
+        0x2c69, 0x2c69,
+        0x2c6b, 0x2c6b,
+        0x2c6d, 0x2c70,
+        0x2c72, 0x2c72,
+        0x2c75, 0x2c75,
+        0x2c7e, 0x2c80,
+        0x2c82, 0x2c82,
+        0x2c84, 0x2c84,
+        0x2c86, 0x2c86,
+        0x2c88, 0x2c88,
+        0x2c8a, 0x2c8a,
+        0x2c8c, 0x2c8c,
+        0x2c8e, 0x2c8e,
+        0x2c90, 0x2c90,
+        0x2c92, 0x2c92,
+        0x2c94, 0x2c94,
+        0x2c96, 0x2c96,
+        0x2c98, 0x2c98,
+        0x2c9a, 0x2c9a,
+        0x2c9c, 0x2c9c,
+        0x2c9e, 0x2c9e,
+        0x2ca0, 0x2ca0,
+        0x2ca2, 0x2ca2,
+        0x2ca4, 0x2ca4,
+        0x2ca6, 0x2ca6,
+        0x2ca8, 0x2ca8,
+        0x2caa, 0x2caa,
+        0x2cac, 0x2cac,
+        0x2cae, 0x2cae,
+        0x2cb0, 0x2cb0,
+        0x2cb2, 0x2cb2,
+        0x2cb4, 0x2cb4,
+        0x2cb6, 0x2cb6,
+        0x2cb8, 0x2cb8,
+        0x2cba, 0x2cba,
+        0x2cbc, 0x2cbc,
+        0x2cbe, 0x2cbe,
+        0x2cc0, 0x2cc0,
+        0x2cc2, 0x2cc2,
+        0x2cc4, 0x2cc4,
+        0x2cc6, 0x2cc6,
+        0x2cc8, 0x2cc8,
+        0x2cca, 0x2cca,
+        0x2ccc, 0x2ccc,
+        0x2cce, 0x2cce,
+        0x2cd0, 0x2cd0,
+        0x2cd2, 0x2cd2,
+        0x2cd4, 0x2cd4,
+        0x2cd6, 0x2cd6,
+        0x2cd8, 0x2cd8,
+        0x2cda, 0x2cda,
+        0x2cdc, 0x2cdc,
+        0x2cde, 0x2cde,
+        0x2ce0, 0x2ce0,
+        0x2ce2, 0x2ce2,
+        0x2ceb, 0x2ceb,
+        0x2ced, 0x2ced,
+        0xa640, 0xa640,
+        0xa642, 0xa642,
+        0xa644, 0xa644,
+        0xa646, 0xa646,
+        0xa648, 0xa648,
+        0xa64a, 0xa64a,
+        0xa64c, 0xa64c,
+        0xa64e, 0xa64e,
+        0xa650, 0xa650,
+        0xa652, 0xa652,
+        0xa654, 0xa654,
+        0xa656, 0xa656,
+        0xa658, 0xa658,
+        0xa65a, 0xa65a,
+        0xa65c, 0xa65c,
+        0xa65e, 0xa65e,
+        0xa662, 0xa662,
+        0xa664, 0xa664,
+        0xa666, 0xa666,
+        0xa668, 0xa668,
+        0xa66a, 0xa66a,
+        0xa66c, 0xa66c,
+        0xa680, 0xa680,
+        0xa682, 0xa682,
+        0xa684, 0xa684,
+        0xa686, 0xa686,
+        0xa688, 0xa688,
+        0xa68a, 0xa68a,
+        0xa68c, 0xa68c,
+        0xa68e, 0xa68e,
+        0xa690, 0xa690,
+        0xa692, 0xa692,
+        0xa694, 0xa694,
+        0xa696, 0xa696,
+        0xa722, 0xa722,
+        0xa724, 0xa724,
+        0xa726, 0xa726,
+        0xa728, 0xa728,
+        0xa72a, 0xa72a,
+        0xa72c, 0xa72c,
+        0xa72e, 0xa72e,
+        0xa732, 0xa732,
+        0xa734, 0xa734,
+        0xa736, 0xa736,
+        0xa738, 0xa738,
+        0xa73a, 0xa73a,
+        0xa73c, 0xa73c,
+        0xa73e, 0xa73e,
+        0xa740, 0xa740,
+        0xa742, 0xa742,
+        0xa744, 0xa744,
+        0xa746, 0xa746,
+        0xa748, 0xa748,
+        0xa74a, 0xa74a,
+        0xa74c, 0xa74c,
+        0xa74e, 0xa74e,
+        0xa750, 0xa750,
+        0xa752, 0xa752,
+        0xa754, 0xa754,
+        0xa756, 0xa756,
+        0xa758, 0xa758,
+        0xa75a, 0xa75a,
+        0xa75c, 0xa75c,
+        0xa75e, 0xa75e,
+        0xa760, 0xa760,
+        0xa762, 0xa762,
+        0xa764, 0xa764,
+        0xa766, 0xa766,
+        0xa768, 0xa768,
+        0xa76a, 0xa76a,
+        0xa76c, 0xa76c,
+        0xa76e, 0xa76e,
+        0xa779, 0xa779,
+        0xa77b, 0xa77b,
+        0xa77d, 0xa77e,
+        0xa780, 0xa780,
+        0xa782, 0xa782,
+        0xa784, 0xa784,
+        0xa786, 0xa786,
+        0xa78b, 0xa78b,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xff21, 0xff3a,
+        0x10400, 0x10427,
 }; /* CR_Changes_When_Casefolded */
 
 /* 'Changes_When_Casemapped': Derived Property */
 static const OnigCodePoint CR_Changes_When_Casemapped[] = {
-	97,
-	0x0041, 0x005a,
-	0x0061, 0x007a,
-	0x00b5, 0x00b5,
-	0x00c0, 0x00d6,
-	0x00d8, 0x00f6,
-	0x00f8, 0x0137,
-	0x0139, 0x018c,
-	0x018e, 0x019a,
-	0x019c, 0x01a9,
-	0x01ac, 0x01b9,
-	0x01bc, 0x01bd,
-	0x01bf, 0x01bf,
-	0x01c4, 0x0220,
-	0x0222, 0x0233,
-	0x023a, 0x0254,
-	0x0256, 0x0257,
-	0x0259, 0x0259,
-	0x025b, 0x025b,
-	0x0260, 0x0260,
-	0x0263, 0x0263,
-	0x0268, 0x0269,
-	0x026b, 0x026b,
-	0x026f, 0x026f,
-	0x0271, 0x0272,
-	0x0275, 0x0275,
-	0x027d, 0x027d,
-	0x0280, 0x0280,
-	0x0283, 0x0283,
-	0x0288, 0x028c,
-	0x0292, 0x0292,
-	0x0345, 0x0345,
-	0x0370, 0x0373,
-	0x0376, 0x0377,
-	0x037b, 0x037d,
-	0x0386, 0x0386,
-	0x0388, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x03a1,
-	0x03a3, 0x03d1,
-	0x03d5, 0x03f2,
-	0x03f4, 0x03f5,
-	0x03f7, 0x03fb,
-	0x03fd, 0x0481,
-	0x048a, 0x0525,
-	0x0531, 0x0556,
-	0x0561, 0x0587,
-	0x10a0, 0x10c5,
-	0x1d79, 0x1d79,
-	0x1d7d, 0x1d7d,
-	0x1e00, 0x1e9b,
-	0x1e9e, 0x1e9e,
-	0x1ea0, 0x1f15,
-	0x1f18, 0x1f1d,
-	0x1f20, 0x1f45,
-	0x1f48, 0x1f4d,
-	0x1f50, 0x1f57,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f7d,
-	0x1f80, 0x1fb4,
-	0x1fb6, 0x1fbc,
-	0x1fbe, 0x1fbe,
-	0x1fc2, 0x1fc4,
-	0x1fc6, 0x1fcc,
-	0x1fd0, 0x1fd3,
-	0x1fd6, 0x1fdb,
-	0x1fe0, 0x1fec,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ffc,
-	0x2126, 0x2126,
-	0x212a, 0x212b,
-	0x2132, 0x2132,
-	0x214e, 0x214e,
-	0x2160, 0x217f,
-	0x2183, 0x2184,
-	0x24b6, 0x24e9,
-	0x2c00, 0x2c2e,
-	0x2c30, 0x2c5e,
-	0x2c60, 0x2c70,
-	0x2c72, 0x2c73,
-	0x2c75, 0x2c76,
-	0x2c7e, 0x2ce3,
-	0x2ceb, 0x2cee,
-	0x2d00, 0x2d25,
-	0xa640, 0xa65f,
-	0xa662, 0xa66d,
-	0xa680, 0xa697,
-	0xa722, 0xa72f,
-	0xa732, 0xa76f,
-	0xa779, 0xa787,
-	0xa78b, 0xa78c,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xff21, 0xff3a,
-	0xff41, 0xff5a,
-	0x10400, 0x1044f,
+        97,
+        0x0041, 0x005a,
+        0x0061, 0x007a,
+        0x00b5, 0x00b5,
+        0x00c0, 0x00d6,
+        0x00d8, 0x00f6,
+        0x00f8, 0x0137,
+        0x0139, 0x018c,
+        0x018e, 0x019a,
+        0x019c, 0x01a9,
+        0x01ac, 0x01b9,
+        0x01bc, 0x01bd,
+        0x01bf, 0x01bf,
+        0x01c4, 0x0220,
+        0x0222, 0x0233,
+        0x023a, 0x0254,
+        0x0256, 0x0257,
+        0x0259, 0x0259,
+        0x025b, 0x025b,
+        0x0260, 0x0260,
+        0x0263, 0x0263,
+        0x0268, 0x0269,
+        0x026b, 0x026b,
+        0x026f, 0x026f,
+        0x0271, 0x0272,
+        0x0275, 0x0275,
+        0x027d, 0x027d,
+        0x0280, 0x0280,
+        0x0283, 0x0283,
+        0x0288, 0x028c,
+        0x0292, 0x0292,
+        0x0345, 0x0345,
+        0x0370, 0x0373,
+        0x0376, 0x0377,
+        0x037b, 0x037d,
+        0x0386, 0x0386,
+        0x0388, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x03a1,
+        0x03a3, 0x03d1,
+        0x03d5, 0x03f2,
+        0x03f4, 0x03f5,
+        0x03f7, 0x03fb,
+        0x03fd, 0x0481,
+        0x048a, 0x0525,
+        0x0531, 0x0556,
+        0x0561, 0x0587,
+        0x10a0, 0x10c5,
+        0x1d79, 0x1d79,
+        0x1d7d, 0x1d7d,
+        0x1e00, 0x1e9b,
+        0x1e9e, 0x1e9e,
+        0x1ea0, 0x1f15,
+        0x1f18, 0x1f1d,
+        0x1f20, 0x1f45,
+        0x1f48, 0x1f4d,
+        0x1f50, 0x1f57,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f7d,
+        0x1f80, 0x1fb4,
+        0x1fb6, 0x1fbc,
+        0x1fbe, 0x1fbe,
+        0x1fc2, 0x1fc4,
+        0x1fc6, 0x1fcc,
+        0x1fd0, 0x1fd3,
+        0x1fd6, 0x1fdb,
+        0x1fe0, 0x1fec,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ffc,
+        0x2126, 0x2126,
+        0x212a, 0x212b,
+        0x2132, 0x2132,
+        0x214e, 0x214e,
+        0x2160, 0x217f,
+        0x2183, 0x2184,
+        0x24b6, 0x24e9,
+        0x2c00, 0x2c2e,
+        0x2c30, 0x2c5e,
+        0x2c60, 0x2c70,
+        0x2c72, 0x2c73,
+        0x2c75, 0x2c76,
+        0x2c7e, 0x2ce3,
+        0x2ceb, 0x2cee,
+        0x2d00, 0x2d25,
+        0xa640, 0xa65f,
+        0xa662, 0xa66d,
+        0xa680, 0xa697,
+        0xa722, 0xa72f,
+        0xa732, 0xa76f,
+        0xa779, 0xa787,
+        0xa78b, 0xa78c,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xff21, 0xff3a,
+        0xff41, 0xff5a,
+        0x10400, 0x1044f,
 }; /* CR_Changes_When_Casemapped */
 
 /* 'ID_Start': Derived Property */
 static const OnigCodePoint CR_ID_Start[] = {
-	424,
-	0x0041, 0x005a,
-	0x0061, 0x007a,
-	0x00aa, 0x00aa,
-	0x00b5, 0x00b5,
-	0x00ba, 0x00ba,
-	0x00c0, 0x00d6,
-	0x00d8, 0x00f6,
-	0x00f8, 0x02c1,
-	0x02c6, 0x02d1,
-	0x02e0, 0x02e4,
-	0x02ec, 0x02ec,
-	0x02ee, 0x02ee,
-	0x0370, 0x0374,
-	0x0376, 0x0377,
-	0x037a, 0x037d,
-	0x0386, 0x0386,
-	0x0388, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x03a1,
-	0x03a3, 0x03f5,
-	0x03f7, 0x0481,
-	0x048a, 0x0525,
-	0x0531, 0x0556,
-	0x0559, 0x0559,
-	0x0561, 0x0587,
-	0x05d0, 0x05ea,
-	0x05f0, 0x05f2,
-	0x0621, 0x064a,
-	0x066e, 0x066f,
-	0x0671, 0x06d3,
-	0x06d5, 0x06d5,
-	0x06e5, 0x06e6,
-	0x06ee, 0x06ef,
-	0x06fa, 0x06fc,
-	0x06ff, 0x06ff,
-	0x0710, 0x0710,
-	0x0712, 0x072f,
-	0x074d, 0x07a5,
-	0x07b1, 0x07b1,
-	0x07ca, 0x07ea,
-	0x07f4, 0x07f5,
-	0x07fa, 0x07fa,
-	0x0800, 0x0815,
-	0x081a, 0x081a,
-	0x0824, 0x0824,
-	0x0828, 0x0828,
-	0x0904, 0x0939,
-	0x093d, 0x093d,
-	0x0950, 0x0950,
-	0x0958, 0x0961,
-	0x0971, 0x0972,
-	0x0979, 0x097f,
-	0x0985, 0x098c,
-	0x098f, 0x0990,
-	0x0993, 0x09a8,
-	0x09aa, 0x09b0,
-	0x09b2, 0x09b2,
-	0x09b6, 0x09b9,
-	0x09bd, 0x09bd,
-	0x09ce, 0x09ce,
-	0x09dc, 0x09dd,
-	0x09df, 0x09e1,
-	0x09f0, 0x09f1,
-	0x0a05, 0x0a0a,
-	0x0a0f, 0x0a10,
-	0x0a13, 0x0a28,
-	0x0a2a, 0x0a30,
-	0x0a32, 0x0a33,
-	0x0a35, 0x0a36,
-	0x0a38, 0x0a39,
-	0x0a59, 0x0a5c,
-	0x0a5e, 0x0a5e,
-	0x0a72, 0x0a74,
-	0x0a85, 0x0a8d,
-	0x0a8f, 0x0a91,
-	0x0a93, 0x0aa8,
-	0x0aaa, 0x0ab0,
-	0x0ab2, 0x0ab3,
-	0x0ab5, 0x0ab9,
-	0x0abd, 0x0abd,
-	0x0ad0, 0x0ad0,
-	0x0ae0, 0x0ae1,
-	0x0b05, 0x0b0c,
-	0x0b0f, 0x0b10,
-	0x0b13, 0x0b28,
-	0x0b2a, 0x0b30,
-	0x0b32, 0x0b33,
-	0x0b35, 0x0b39,
-	0x0b3d, 0x0b3d,
-	0x0b5c, 0x0b5d,
-	0x0b5f, 0x0b61,
-	0x0b71, 0x0b71,
-	0x0b83, 0x0b83,
-	0x0b85, 0x0b8a,
-	0x0b8e, 0x0b90,
-	0x0b92, 0x0b95,
-	0x0b99, 0x0b9a,
-	0x0b9c, 0x0b9c,
-	0x0b9e, 0x0b9f,
-	0x0ba3, 0x0ba4,
-	0x0ba8, 0x0baa,
-	0x0bae, 0x0bb9,
-	0x0bd0, 0x0bd0,
-	0x0c05, 0x0c0c,
-	0x0c0e, 0x0c10,
-	0x0c12, 0x0c28,
-	0x0c2a, 0x0c33,
-	0x0c35, 0x0c39,
-	0x0c3d, 0x0c3d,
-	0x0c58, 0x0c59,
-	0x0c60, 0x0c61,
-	0x0c85, 0x0c8c,
-	0x0c8e, 0x0c90,
-	0x0c92, 0x0ca8,
-	0x0caa, 0x0cb3,
-	0x0cb5, 0x0cb9,
-	0x0cbd, 0x0cbd,
-	0x0cde, 0x0cde,
-	0x0ce0, 0x0ce1,
-	0x0d05, 0x0d0c,
-	0x0d0e, 0x0d10,
-	0x0d12, 0x0d28,
-	0x0d2a, 0x0d39,
-	0x0d3d, 0x0d3d,
-	0x0d60, 0x0d61,
-	0x0d7a, 0x0d7f,
-	0x0d85, 0x0d96,
-	0x0d9a, 0x0db1,
-	0x0db3, 0x0dbb,
-	0x0dbd, 0x0dbd,
-	0x0dc0, 0x0dc6,
-	0x0e01, 0x0e30,
-	0x0e32, 0x0e33,
-	0x0e40, 0x0e46,
-	0x0e81, 0x0e82,
-	0x0e84, 0x0e84,
-	0x0e87, 0x0e88,
-	0x0e8a, 0x0e8a,
-	0x0e8d, 0x0e8d,
-	0x0e94, 0x0e97,
-	0x0e99, 0x0e9f,
-	0x0ea1, 0x0ea3,
-	0x0ea5, 0x0ea5,
-	0x0ea7, 0x0ea7,
-	0x0eaa, 0x0eab,
-	0x0ead, 0x0eb0,
-	0x0eb2, 0x0eb3,
-	0x0ebd, 0x0ebd,
-	0x0ec0, 0x0ec4,
-	0x0ec6, 0x0ec6,
-	0x0edc, 0x0edd,
-	0x0f00, 0x0f00,
-	0x0f40, 0x0f47,
-	0x0f49, 0x0f6c,
-	0x0f88, 0x0f8b,
-	0x1000, 0x102a,
-	0x103f, 0x103f,
-	0x1050, 0x1055,
-	0x105a, 0x105d,
-	0x1061, 0x1061,
-	0x1065, 0x1066,
-	0x106e, 0x1070,
-	0x1075, 0x1081,
-	0x108e, 0x108e,
-	0x10a0, 0x10c5,
-	0x10d0, 0x10fa,
-	0x10fc, 0x10fc,
-	0x1100, 0x1248,
-	0x124a, 0x124d,
-	0x1250, 0x1256,
-	0x1258, 0x1258,
-	0x125a, 0x125d,
-	0x1260, 0x1288,
-	0x128a, 0x128d,
-	0x1290, 0x12b0,
-	0x12b2, 0x12b5,
-	0x12b8, 0x12be,
-	0x12c0, 0x12c0,
-	0x12c2, 0x12c5,
-	0x12c8, 0x12d6,
-	0x12d8, 0x1310,
-	0x1312, 0x1315,
-	0x1318, 0x135a,
-	0x1380, 0x138f,
-	0x13a0, 0x13f4,
-	0x1401, 0x166c,
-	0x166f, 0x167f,
-	0x1681, 0x169a,
-	0x16a0, 0x16ea,
-	0x16ee, 0x16f0,
-	0x1700, 0x170c,
-	0x170e, 0x1711,
-	0x1720, 0x1731,
-	0x1740, 0x1751,
-	0x1760, 0x176c,
-	0x176e, 0x1770,
-	0x1780, 0x17b3,
-	0x17d7, 0x17d7,
-	0x17dc, 0x17dc,
-	0x1820, 0x1877,
-	0x1880, 0x18a8,
-	0x18aa, 0x18aa,
-	0x18b0, 0x18f5,
-	0x1900, 0x191c,
-	0x1950, 0x196d,
-	0x1970, 0x1974,
-	0x1980, 0x19ab,
-	0x19c1, 0x19c7,
-	0x1a00, 0x1a16,
-	0x1a20, 0x1a54,
-	0x1aa7, 0x1aa7,
-	0x1b05, 0x1b33,
-	0x1b45, 0x1b4b,
-	0x1b83, 0x1ba0,
-	0x1bae, 0x1baf,
-	0x1c00, 0x1c23,
-	0x1c4d, 0x1c4f,
-	0x1c5a, 0x1c7d,
-	0x1ce9, 0x1cec,
-	0x1cee, 0x1cf1,
-	0x1d00, 0x1dbf,
-	0x1e00, 0x1f15,
-	0x1f18, 0x1f1d,
-	0x1f20, 0x1f45,
-	0x1f48, 0x1f4d,
-	0x1f50, 0x1f57,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f7d,
-	0x1f80, 0x1fb4,
-	0x1fb6, 0x1fbc,
-	0x1fbe, 0x1fbe,
-	0x1fc2, 0x1fc4,
-	0x1fc6, 0x1fcc,
-	0x1fd0, 0x1fd3,
-	0x1fd6, 0x1fdb,
-	0x1fe0, 0x1fec,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ffc,
-	0x2071, 0x2071,
-	0x207f, 0x207f,
-	0x2090, 0x2094,
-	0x2102, 0x2102,
-	0x2107, 0x2107,
-	0x210a, 0x2113,
-	0x2115, 0x2115,
-	0x2118, 0x211d,
-	0x2124, 0x2124,
-	0x2126, 0x2126,
-	0x2128, 0x2128,
-	0x212a, 0x2139,
-	0x213c, 0x213f,
-	0x2145, 0x2149,
-	0x214e, 0x214e,
-	0x2160, 0x2188,
-	0x2c00, 0x2c2e,
-	0x2c30, 0x2c5e,
-	0x2c60, 0x2ce4,
-	0x2ceb, 0x2cee,
-	0x2d00, 0x2d25,
-	0x2d30, 0x2d65,
-	0x2d6f, 0x2d6f,
-	0x2d80, 0x2d96,
-	0x2da0, 0x2da6,
-	0x2da8, 0x2dae,
-	0x2db0, 0x2db6,
-	0x2db8, 0x2dbe,
-	0x2dc0, 0x2dc6,
-	0x2dc8, 0x2dce,
-	0x2dd0, 0x2dd6,
-	0x2dd8, 0x2dde,
-	0x3005, 0x3007,
-	0x3021, 0x3029,
-	0x3031, 0x3035,
-	0x3038, 0x303c,
-	0x3041, 0x3096,
-	0x309b, 0x309f,
-	0x30a1, 0x30fa,
-	0x30fc, 0x30ff,
-	0x3105, 0x312d,
-	0x3131, 0x318e,
-	0x31a0, 0x31b7,
-	0x31f0, 0x31ff,
-	0x3400, 0x4db5,
-	0x4e00, 0x9fcb,
-	0xa000, 0xa48c,
-	0xa4d0, 0xa4fd,
-	0xa500, 0xa60c,
-	0xa610, 0xa61f,
-	0xa62a, 0xa62b,
-	0xa640, 0xa65f,
-	0xa662, 0xa66e,
-	0xa67f, 0xa697,
-	0xa6a0, 0xa6ef,
-	0xa717, 0xa71f,
-	0xa722, 0xa788,
-	0xa78b, 0xa78c,
-	0xa7fb, 0xa801,
-	0xa803, 0xa805,
-	0xa807, 0xa80a,
-	0xa80c, 0xa822,
-	0xa840, 0xa873,
-	0xa882, 0xa8b3,
-	0xa8f2, 0xa8f7,
-	0xa8fb, 0xa8fb,
-	0xa90a, 0xa925,
-	0xa930, 0xa946,
-	0xa960, 0xa97c,
-	0xa984, 0xa9b2,
-	0xa9cf, 0xa9cf,
-	0xaa00, 0xaa28,
-	0xaa40, 0xaa42,
-	0xaa44, 0xaa4b,
-	0xaa60, 0xaa76,
-	0xaa7a, 0xaa7a,
-	0xaa80, 0xaaaf,
-	0xaab1, 0xaab1,
-	0xaab5, 0xaab6,
-	0xaab9, 0xaabd,
-	0xaac0, 0xaac0,
-	0xaac2, 0xaac2,
-	0xaadb, 0xaadd,
-	0xabc0, 0xabe2,
-	0xac00, 0xd7a3,
-	0xd7b0, 0xd7c6,
-	0xd7cb, 0xd7fb,
-	0xf900, 0xfa2d,
-	0xfa30, 0xfa6d,
-	0xfa70, 0xfad9,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xfb1d, 0xfb1d,
-	0xfb1f, 0xfb28,
-	0xfb2a, 0xfb36,
-	0xfb38, 0xfb3c,
-	0xfb3e, 0xfb3e,
-	0xfb40, 0xfb41,
-	0xfb43, 0xfb44,
-	0xfb46, 0xfbb1,
-	0xfbd3, 0xfd3d,
-	0xfd50, 0xfd8f,
-	0xfd92, 0xfdc7,
-	0xfdf0, 0xfdfb,
-	0xfe70, 0xfe74,
-	0xfe76, 0xfefc,
-	0xff21, 0xff3a,
-	0xff41, 0xff5a,
-	0xff66, 0xffbe,
-	0xffc2, 0xffc7,
-	0xffca, 0xffcf,
-	0xffd2, 0xffd7,
-	0xffda, 0xffdc,
-	0x10000, 0x1000b,
-	0x1000d, 0x10026,
-	0x10028, 0x1003a,
-	0x1003c, 0x1003d,
-	0x1003f, 0x1004d,
-	0x10050, 0x1005d,
-	0x10080, 0x100fa,
-	0x10140, 0x10174,
-	0x10280, 0x1029c,
-	0x102a0, 0x102d0,
-	0x10300, 0x1031e,
-	0x10330, 0x1034a,
-	0x10380, 0x1039d,
-	0x103a0, 0x103c3,
-	0x103c8, 0x103cf,
-	0x103d1, 0x103d5,
-	0x10400, 0x1049d,
-	0x10800, 0x10805,
-	0x10808, 0x10808,
-	0x1080a, 0x10835,
-	0x10837, 0x10838,
-	0x1083c, 0x1083c,
-	0x1083f, 0x10855,
-	0x10900, 0x10915,
-	0x10920, 0x10939,
-	0x10a00, 0x10a00,
-	0x10a10, 0x10a13,
-	0x10a15, 0x10a17,
-	0x10a19, 0x10a33,
-	0x10a60, 0x10a7c,
-	0x10b00, 0x10b35,
-	0x10b40, 0x10b55,
-	0x10b60, 0x10b72,
-	0x10c00, 0x10c48,
-	0x11083, 0x110af,
-	0x12000, 0x1236e,
-	0x12400, 0x12462,
-	0x13000, 0x1342e,
-	0x1d400, 0x1d454,
-	0x1d456, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d51e, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d552, 0x1d6a5,
-	0x1d6a8, 0x1d6c0,
-	0x1d6c2, 0x1d6da,
-	0x1d6dc, 0x1d6fa,
-	0x1d6fc, 0x1d714,
-	0x1d716, 0x1d734,
-	0x1d736, 0x1d74e,
-	0x1d750, 0x1d76e,
-	0x1d770, 0x1d788,
-	0x1d78a, 0x1d7a8,
-	0x1d7aa, 0x1d7c2,
-	0x1d7c4, 0x1d7cb,
-	0x20000, 0x2a6d6,
-	0x2a700, 0x2b734,
-	0x2f800, 0x2fa1d,
+        424,
+        0x0041, 0x005a,
+        0x0061, 0x007a,
+        0x00aa, 0x00aa,
+        0x00b5, 0x00b5,
+        0x00ba, 0x00ba,
+        0x00c0, 0x00d6,
+        0x00d8, 0x00f6,
+        0x00f8, 0x02c1,
+        0x02c6, 0x02d1,
+        0x02e0, 0x02e4,
+        0x02ec, 0x02ec,
+        0x02ee, 0x02ee,
+        0x0370, 0x0374,
+        0x0376, 0x0377,
+        0x037a, 0x037d,
+        0x0386, 0x0386,
+        0x0388, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x03a1,
+        0x03a3, 0x03f5,
+        0x03f7, 0x0481,
+        0x048a, 0x0525,
+        0x0531, 0x0556,
+        0x0559, 0x0559,
+        0x0561, 0x0587,
+        0x05d0, 0x05ea,
+        0x05f0, 0x05f2,
+        0x0621, 0x064a,
+        0x066e, 0x066f,
+        0x0671, 0x06d3,
+        0x06d5, 0x06d5,
+        0x06e5, 0x06e6,
+        0x06ee, 0x06ef,
+        0x06fa, 0x06fc,
+        0x06ff, 0x06ff,
+        0x0710, 0x0710,
+        0x0712, 0x072f,
+        0x074d, 0x07a5,
+        0x07b1, 0x07b1,
+        0x07ca, 0x07ea,
+        0x07f4, 0x07f5,
+        0x07fa, 0x07fa,
+        0x0800, 0x0815,
+        0x081a, 0x081a,
+        0x0824, 0x0824,
+        0x0828, 0x0828,
+        0x0904, 0x0939,
+        0x093d, 0x093d,
+        0x0950, 0x0950,
+        0x0958, 0x0961,
+        0x0971, 0x0972,
+        0x0979, 0x097f,
+        0x0985, 0x098c,
+        0x098f, 0x0990,
+        0x0993, 0x09a8,
+        0x09aa, 0x09b0,
+        0x09b2, 0x09b2,
+        0x09b6, 0x09b9,
+        0x09bd, 0x09bd,
+        0x09ce, 0x09ce,
+        0x09dc, 0x09dd,
+        0x09df, 0x09e1,
+        0x09f0, 0x09f1,
+        0x0a05, 0x0a0a,
+        0x0a0f, 0x0a10,
+        0x0a13, 0x0a28,
+        0x0a2a, 0x0a30,
+        0x0a32, 0x0a33,
+        0x0a35, 0x0a36,
+        0x0a38, 0x0a39,
+        0x0a59, 0x0a5c,
+        0x0a5e, 0x0a5e,
+        0x0a72, 0x0a74,
+        0x0a85, 0x0a8d,
+        0x0a8f, 0x0a91,
+        0x0a93, 0x0aa8,
+        0x0aaa, 0x0ab0,
+        0x0ab2, 0x0ab3,
+        0x0ab5, 0x0ab9,
+        0x0abd, 0x0abd,
+        0x0ad0, 0x0ad0,
+        0x0ae0, 0x0ae1,
+        0x0b05, 0x0b0c,
+        0x0b0f, 0x0b10,
+        0x0b13, 0x0b28,
+        0x0b2a, 0x0b30,
+        0x0b32, 0x0b33,
+        0x0b35, 0x0b39,
+        0x0b3d, 0x0b3d,
+        0x0b5c, 0x0b5d,
+        0x0b5f, 0x0b61,
+        0x0b71, 0x0b71,
+        0x0b83, 0x0b83,
+        0x0b85, 0x0b8a,
+        0x0b8e, 0x0b90,
+        0x0b92, 0x0b95,
+        0x0b99, 0x0b9a,
+        0x0b9c, 0x0b9c,
+        0x0b9e, 0x0b9f,
+        0x0ba3, 0x0ba4,
+        0x0ba8, 0x0baa,
+        0x0bae, 0x0bb9,
+        0x0bd0, 0x0bd0,
+        0x0c05, 0x0c0c,
+        0x0c0e, 0x0c10,
+        0x0c12, 0x0c28,
+        0x0c2a, 0x0c33,
+        0x0c35, 0x0c39,
+        0x0c3d, 0x0c3d,
+        0x0c58, 0x0c59,
+        0x0c60, 0x0c61,
+        0x0c85, 0x0c8c,
+        0x0c8e, 0x0c90,
+        0x0c92, 0x0ca8,
+        0x0caa, 0x0cb3,
+        0x0cb5, 0x0cb9,
+        0x0cbd, 0x0cbd,
+        0x0cde, 0x0cde,
+        0x0ce0, 0x0ce1,
+        0x0d05, 0x0d0c,
+        0x0d0e, 0x0d10,
+        0x0d12, 0x0d28,
+        0x0d2a, 0x0d39,
+        0x0d3d, 0x0d3d,
+        0x0d60, 0x0d61,
+        0x0d7a, 0x0d7f,
+        0x0d85, 0x0d96,
+        0x0d9a, 0x0db1,
+        0x0db3, 0x0dbb,
+        0x0dbd, 0x0dbd,
+        0x0dc0, 0x0dc6,
+        0x0e01, 0x0e30,
+        0x0e32, 0x0e33,
+        0x0e40, 0x0e46,
+        0x0e81, 0x0e82,
+        0x0e84, 0x0e84,
+        0x0e87, 0x0e88,
+        0x0e8a, 0x0e8a,
+        0x0e8d, 0x0e8d,
+        0x0e94, 0x0e97,
+        0x0e99, 0x0e9f,
+        0x0ea1, 0x0ea3,
+        0x0ea5, 0x0ea5,
+        0x0ea7, 0x0ea7,
+        0x0eaa, 0x0eab,
+        0x0ead, 0x0eb0,
+        0x0eb2, 0x0eb3,
+        0x0ebd, 0x0ebd,
+        0x0ec0, 0x0ec4,
+        0x0ec6, 0x0ec6,
+        0x0edc, 0x0edd,
+        0x0f00, 0x0f00,
+        0x0f40, 0x0f47,
+        0x0f49, 0x0f6c,
+        0x0f88, 0x0f8b,
+        0x1000, 0x102a,
+        0x103f, 0x103f,
+        0x1050, 0x1055,
+        0x105a, 0x105d,
+        0x1061, 0x1061,
+        0x1065, 0x1066,
+        0x106e, 0x1070,
+        0x1075, 0x1081,
+        0x108e, 0x108e,
+        0x10a0, 0x10c5,
+        0x10d0, 0x10fa,
+        0x10fc, 0x10fc,
+        0x1100, 0x1248,
+        0x124a, 0x124d,
+        0x1250, 0x1256,
+        0x1258, 0x1258,
+        0x125a, 0x125d,
+        0x1260, 0x1288,
+        0x128a, 0x128d,
+        0x1290, 0x12b0,
+        0x12b2, 0x12b5,
+        0x12b8, 0x12be,
+        0x12c0, 0x12c0,
+        0x12c2, 0x12c5,
+        0x12c8, 0x12d6,
+        0x12d8, 0x1310,
+        0x1312, 0x1315,
+        0x1318, 0x135a,
+        0x1380, 0x138f,
+        0x13a0, 0x13f4,
+        0x1401, 0x166c,
+        0x166f, 0x167f,
+        0x1681, 0x169a,
+        0x16a0, 0x16ea,
+        0x16ee, 0x16f0,
+        0x1700, 0x170c,
+        0x170e, 0x1711,
+        0x1720, 0x1731,
+        0x1740, 0x1751,
+        0x1760, 0x176c,
+        0x176e, 0x1770,
+        0x1780, 0x17b3,
+        0x17d7, 0x17d7,
+        0x17dc, 0x17dc,
+        0x1820, 0x1877,
+        0x1880, 0x18a8,
+        0x18aa, 0x18aa,
+        0x18b0, 0x18f5,
+        0x1900, 0x191c,
+        0x1950, 0x196d,
+        0x1970, 0x1974,
+        0x1980, 0x19ab,
+        0x19c1, 0x19c7,
+        0x1a00, 0x1a16,
+        0x1a20, 0x1a54,
+        0x1aa7, 0x1aa7,
+        0x1b05, 0x1b33,
+        0x1b45, 0x1b4b,
+        0x1b83, 0x1ba0,
+        0x1bae, 0x1baf,
+        0x1c00, 0x1c23,
+        0x1c4d, 0x1c4f,
+        0x1c5a, 0x1c7d,
+        0x1ce9, 0x1cec,
+        0x1cee, 0x1cf1,
+        0x1d00, 0x1dbf,
+        0x1e00, 0x1f15,
+        0x1f18, 0x1f1d,
+        0x1f20, 0x1f45,
+        0x1f48, 0x1f4d,
+        0x1f50, 0x1f57,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f7d,
+        0x1f80, 0x1fb4,
+        0x1fb6, 0x1fbc,
+        0x1fbe, 0x1fbe,
+        0x1fc2, 0x1fc4,
+        0x1fc6, 0x1fcc,
+        0x1fd0, 0x1fd3,
+        0x1fd6, 0x1fdb,
+        0x1fe0, 0x1fec,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ffc,
+        0x2071, 0x2071,
+        0x207f, 0x207f,
+        0x2090, 0x2094,
+        0x2102, 0x2102,
+        0x2107, 0x2107,
+        0x210a, 0x2113,
+        0x2115, 0x2115,
+        0x2118, 0x211d,
+        0x2124, 0x2124,
+        0x2126, 0x2126,
+        0x2128, 0x2128,
+        0x212a, 0x2139,
+        0x213c, 0x213f,
+        0x2145, 0x2149,
+        0x214e, 0x214e,
+        0x2160, 0x2188,
+        0x2c00, 0x2c2e,
+        0x2c30, 0x2c5e,
+        0x2c60, 0x2ce4,
+        0x2ceb, 0x2cee,
+        0x2d00, 0x2d25,
+        0x2d30, 0x2d65,
+        0x2d6f, 0x2d6f,
+        0x2d80, 0x2d96,
+        0x2da0, 0x2da6,
+        0x2da8, 0x2dae,
+        0x2db0, 0x2db6,
+        0x2db8, 0x2dbe,
+        0x2dc0, 0x2dc6,
+        0x2dc8, 0x2dce,
+        0x2dd0, 0x2dd6,
+        0x2dd8, 0x2dde,
+        0x3005, 0x3007,
+        0x3021, 0x3029,
+        0x3031, 0x3035,
+        0x3038, 0x303c,
+        0x3041, 0x3096,
+        0x309b, 0x309f,
+        0x30a1, 0x30fa,
+        0x30fc, 0x30ff,
+        0x3105, 0x312d,
+        0x3131, 0x318e,
+        0x31a0, 0x31b7,
+        0x31f0, 0x31ff,
+        0x3400, 0x4db5,
+        0x4e00, 0x9fcb,
+        0xa000, 0xa48c,
+        0xa4d0, 0xa4fd,
+        0xa500, 0xa60c,
+        0xa610, 0xa61f,
+        0xa62a, 0xa62b,
+        0xa640, 0xa65f,
+        0xa662, 0xa66e,
+        0xa67f, 0xa697,
+        0xa6a0, 0xa6ef,
+        0xa717, 0xa71f,
+        0xa722, 0xa788,
+        0xa78b, 0xa78c,
+        0xa7fb, 0xa801,
+        0xa803, 0xa805,
+        0xa807, 0xa80a,
+        0xa80c, 0xa822,
+        0xa840, 0xa873,
+        0xa882, 0xa8b3,
+        0xa8f2, 0xa8f7,
+        0xa8fb, 0xa8fb,
+        0xa90a, 0xa925,
+        0xa930, 0xa946,
+        0xa960, 0xa97c,
+        0xa984, 0xa9b2,
+        0xa9cf, 0xa9cf,
+        0xaa00, 0xaa28,
+        0xaa40, 0xaa42,
+        0xaa44, 0xaa4b,
+        0xaa60, 0xaa76,
+        0xaa7a, 0xaa7a,
+        0xaa80, 0xaaaf,
+        0xaab1, 0xaab1,
+        0xaab5, 0xaab6,
+        0xaab9, 0xaabd,
+        0xaac0, 0xaac0,
+        0xaac2, 0xaac2,
+        0xaadb, 0xaadd,
+        0xabc0, 0xabe2,
+        0xac00, 0xd7a3,
+        0xd7b0, 0xd7c6,
+        0xd7cb, 0xd7fb,
+        0xf900, 0xfa2d,
+        0xfa30, 0xfa6d,
+        0xfa70, 0xfad9,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xfb1d, 0xfb1d,
+        0xfb1f, 0xfb28,
+        0xfb2a, 0xfb36,
+        0xfb38, 0xfb3c,
+        0xfb3e, 0xfb3e,
+        0xfb40, 0xfb41,
+        0xfb43, 0xfb44,
+        0xfb46, 0xfbb1,
+        0xfbd3, 0xfd3d,
+        0xfd50, 0xfd8f,
+        0xfd92, 0xfdc7,
+        0xfdf0, 0xfdfb,
+        0xfe70, 0xfe74,
+        0xfe76, 0xfefc,
+        0xff21, 0xff3a,
+        0xff41, 0xff5a,
+        0xff66, 0xffbe,
+        0xffc2, 0xffc7,
+        0xffca, 0xffcf,
+        0xffd2, 0xffd7,
+        0xffda, 0xffdc,
+        0x10000, 0x1000b,
+        0x1000d, 0x10026,
+        0x10028, 0x1003a,
+        0x1003c, 0x1003d,
+        0x1003f, 0x1004d,
+        0x10050, 0x1005d,
+        0x10080, 0x100fa,
+        0x10140, 0x10174,
+        0x10280, 0x1029c,
+        0x102a0, 0x102d0,
+        0x10300, 0x1031e,
+        0x10330, 0x1034a,
+        0x10380, 0x1039d,
+        0x103a0, 0x103c3,
+        0x103c8, 0x103cf,
+        0x103d1, 0x103d5,
+        0x10400, 0x1049d,
+        0x10800, 0x10805,
+        0x10808, 0x10808,
+        0x1080a, 0x10835,
+        0x10837, 0x10838,
+        0x1083c, 0x1083c,
+        0x1083f, 0x10855,
+        0x10900, 0x10915,
+        0x10920, 0x10939,
+        0x10a00, 0x10a00,
+        0x10a10, 0x10a13,
+        0x10a15, 0x10a17,
+        0x10a19, 0x10a33,
+        0x10a60, 0x10a7c,
+        0x10b00, 0x10b35,
+        0x10b40, 0x10b55,
+        0x10b60, 0x10b72,
+        0x10c00, 0x10c48,
+        0x11083, 0x110af,
+        0x12000, 0x1236e,
+        0x12400, 0x12462,
+        0x13000, 0x1342e,
+        0x1d400, 0x1d454,
+        0x1d456, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d51e, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d552, 0x1d6a5,
+        0x1d6a8, 0x1d6c0,
+        0x1d6c2, 0x1d6da,
+        0x1d6dc, 0x1d6fa,
+        0x1d6fc, 0x1d714,
+        0x1d716, 0x1d734,
+        0x1d736, 0x1d74e,
+        0x1d750, 0x1d76e,
+        0x1d770, 0x1d788,
+        0x1d78a, 0x1d7a8,
+        0x1d7aa, 0x1d7c2,
+        0x1d7c4, 0x1d7cb,
+        0x20000, 0x2a6d6,
+        0x2a700, 0x2b734,
+        0x2f800, 0x2fa1d,
 }; /* CR_ID_Start */
 
 /* 'ID_Continue': Derived Property */
 static const OnigCodePoint CR_ID_Continue[] = {
-	506,
-	0x0030, 0x0039,
-	0x0041, 0x005a,
-	0x005f, 0x005f,
-	0x0061, 0x007a,
-	0x00aa, 0x00aa,
-	0x00b5, 0x00b5,
-	0x00b7, 0x00b7,
-	0x00ba, 0x00ba,
-	0x00c0, 0x00d6,
-	0x00d8, 0x00f6,
-	0x00f8, 0x02c1,
-	0x02c6, 0x02d1,
-	0x02e0, 0x02e4,
-	0x02ec, 0x02ec,
-	0x02ee, 0x02ee,
-	0x0300, 0x0374,
-	0x0376, 0x0377,
-	0x037a, 0x037d,
-	0x0386, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x03a1,
-	0x03a3, 0x03f5,
-	0x03f7, 0x0481,
-	0x0483, 0x0487,
-	0x048a, 0x0525,
-	0x0531, 0x0556,
-	0x0559, 0x0559,
-	0x0561, 0x0587,
-	0x0591, 0x05bd,
-	0x05bf, 0x05bf,
-	0x05c1, 0x05c2,
-	0x05c4, 0x05c5,
-	0x05c7, 0x05c7,
-	0x05d0, 0x05ea,
-	0x05f0, 0x05f2,
-	0x0610, 0x061a,
-	0x0621, 0x065e,
-	0x0660, 0x0669,
-	0x066e, 0x06d3,
-	0x06d5, 0x06dc,
-	0x06df, 0x06e8,
-	0x06ea, 0x06fc,
-	0x06ff, 0x06ff,
-	0x0710, 0x074a,
-	0x074d, 0x07b1,
-	0x07c0, 0x07f5,
-	0x07fa, 0x07fa,
-	0x0800, 0x082d,
-	0x0900, 0x0939,
-	0x093c, 0x094e,
-	0x0950, 0x0955,
-	0x0958, 0x0963,
-	0x0966, 0x096f,
-	0x0971, 0x0972,
-	0x0979, 0x097f,
-	0x0981, 0x0983,
-	0x0985, 0x098c,
-	0x098f, 0x0990,
-	0x0993, 0x09a8,
-	0x09aa, 0x09b0,
-	0x09b2, 0x09b2,
-	0x09b6, 0x09b9,
-	0x09bc, 0x09c4,
-	0x09c7, 0x09c8,
-	0x09cb, 0x09ce,
-	0x09d7, 0x09d7,
-	0x09dc, 0x09dd,
-	0x09df, 0x09e3,
-	0x09e6, 0x09f1,
-	0x0a01, 0x0a03,
-	0x0a05, 0x0a0a,
-	0x0a0f, 0x0a10,
-	0x0a13, 0x0a28,
-	0x0a2a, 0x0a30,
-	0x0a32, 0x0a33,
-	0x0a35, 0x0a36,
-	0x0a38, 0x0a39,
-	0x0a3c, 0x0a3c,
-	0x0a3e, 0x0a42,
-	0x0a47, 0x0a48,
-	0x0a4b, 0x0a4d,
-	0x0a51, 0x0a51,
-	0x0a59, 0x0a5c,
-	0x0a5e, 0x0a5e,
-	0x0a66, 0x0a75,
-	0x0a81, 0x0a83,
-	0x0a85, 0x0a8d,
-	0x0a8f, 0x0a91,
-	0x0a93, 0x0aa8,
-	0x0aaa, 0x0ab0,
-	0x0ab2, 0x0ab3,
-	0x0ab5, 0x0ab9,
-	0x0abc, 0x0ac5,
-	0x0ac7, 0x0ac9,
-	0x0acb, 0x0acd,
-	0x0ad0, 0x0ad0,
-	0x0ae0, 0x0ae3,
-	0x0ae6, 0x0aef,
-	0x0b01, 0x0b03,
-	0x0b05, 0x0b0c,
-	0x0b0f, 0x0b10,
-	0x0b13, 0x0b28,
-	0x0b2a, 0x0b30,
-	0x0b32, 0x0b33,
-	0x0b35, 0x0b39,
-	0x0b3c, 0x0b44,
-	0x0b47, 0x0b48,
-	0x0b4b, 0x0b4d,
-	0x0b56, 0x0b57,
-	0x0b5c, 0x0b5d,
-	0x0b5f, 0x0b63,
-	0x0b66, 0x0b6f,
-	0x0b71, 0x0b71,
-	0x0b82, 0x0b83,
-	0x0b85, 0x0b8a,
-	0x0b8e, 0x0b90,
-	0x0b92, 0x0b95,
-	0x0b99, 0x0b9a,
-	0x0b9c, 0x0b9c,
-	0x0b9e, 0x0b9f,
-	0x0ba3, 0x0ba4,
-	0x0ba8, 0x0baa,
-	0x0bae, 0x0bb9,
-	0x0bbe, 0x0bc2,
-	0x0bc6, 0x0bc8,
-	0x0bca, 0x0bcd,
-	0x0bd0, 0x0bd0,
-	0x0bd7, 0x0bd7,
-	0x0be6, 0x0bef,
-	0x0c01, 0x0c03,
-	0x0c05, 0x0c0c,
-	0x0c0e, 0x0c10,
-	0x0c12, 0x0c28,
-	0x0c2a, 0x0c33,
-	0x0c35, 0x0c39,
-	0x0c3d, 0x0c44,
-	0x0c46, 0x0c48,
-	0x0c4a, 0x0c4d,
-	0x0c55, 0x0c56,
-	0x0c58, 0x0c59,
-	0x0c60, 0x0c63,
-	0x0c66, 0x0c6f,
-	0x0c82, 0x0c83,
-	0x0c85, 0x0c8c,
-	0x0c8e, 0x0c90,
-	0x0c92, 0x0ca8,
-	0x0caa, 0x0cb3,
-	0x0cb5, 0x0cb9,
-	0x0cbc, 0x0cc4,
-	0x0cc6, 0x0cc8,
-	0x0cca, 0x0ccd,
-	0x0cd5, 0x0cd6,
-	0x0cde, 0x0cde,
-	0x0ce0, 0x0ce3,
-	0x0ce6, 0x0cef,
-	0x0d02, 0x0d03,
-	0x0d05, 0x0d0c,
-	0x0d0e, 0x0d10,
-	0x0d12, 0x0d28,
-	0x0d2a, 0x0d39,
-	0x0d3d, 0x0d44,
-	0x0d46, 0x0d48,
-	0x0d4a, 0x0d4d,
-	0x0d57, 0x0d57,
-	0x0d60, 0x0d63,
-	0x0d66, 0x0d6f,
-	0x0d7a, 0x0d7f,
-	0x0d82, 0x0d83,
-	0x0d85, 0x0d96,
-	0x0d9a, 0x0db1,
-	0x0db3, 0x0dbb,
-	0x0dbd, 0x0dbd,
-	0x0dc0, 0x0dc6,
-	0x0dca, 0x0dca,
-	0x0dcf, 0x0dd4,
-	0x0dd6, 0x0dd6,
-	0x0dd8, 0x0ddf,
-	0x0df2, 0x0df3,
-	0x0e01, 0x0e3a,
-	0x0e40, 0x0e4e,
-	0x0e50, 0x0e59,
-	0x0e81, 0x0e82,
-	0x0e84, 0x0e84,
-	0x0e87, 0x0e88,
-	0x0e8a, 0x0e8a,
-	0x0e8d, 0x0e8d,
-	0x0e94, 0x0e97,
-	0x0e99, 0x0e9f,
-	0x0ea1, 0x0ea3,
-	0x0ea5, 0x0ea5,
-	0x0ea7, 0x0ea7,
-	0x0eaa, 0x0eab,
-	0x0ead, 0x0eb9,
-	0x0ebb, 0x0ebd,
-	0x0ec0, 0x0ec4,
-	0x0ec6, 0x0ec6,
-	0x0ec8, 0x0ecd,
-	0x0ed0, 0x0ed9,
-	0x0edc, 0x0edd,
-	0x0f00, 0x0f00,
-	0x0f18, 0x0f19,
-	0x0f20, 0x0f29,
-	0x0f35, 0x0f35,
-	0x0f37, 0x0f37,
-	0x0f39, 0x0f39,
-	0x0f3e, 0x0f47,
-	0x0f49, 0x0f6c,
-	0x0f71, 0x0f84,
-	0x0f86, 0x0f8b,
-	0x0f90, 0x0f97,
-	0x0f99, 0x0fbc,
-	0x0fc6, 0x0fc6,
-	0x1000, 0x1049,
-	0x1050, 0x109d,
-	0x10a0, 0x10c5,
-	0x10d0, 0x10fa,
-	0x10fc, 0x10fc,
-	0x1100, 0x1248,
-	0x124a, 0x124d,
-	0x1250, 0x1256,
-	0x1258, 0x1258,
-	0x125a, 0x125d,
-	0x1260, 0x1288,
-	0x128a, 0x128d,
-	0x1290, 0x12b0,
-	0x12b2, 0x12b5,
-	0x12b8, 0x12be,
-	0x12c0, 0x12c0,
-	0x12c2, 0x12c5,
-	0x12c8, 0x12d6,
-	0x12d8, 0x1310,
-	0x1312, 0x1315,
-	0x1318, 0x135a,
-	0x135f, 0x135f,
-	0x1369, 0x1371,
-	0x1380, 0x138f,
-	0x13a0, 0x13f4,
-	0x1401, 0x166c,
-	0x166f, 0x167f,
-	0x1681, 0x169a,
-	0x16a0, 0x16ea,
-	0x16ee, 0x16f0,
-	0x1700, 0x170c,
-	0x170e, 0x1714,
-	0x1720, 0x1734,
-	0x1740, 0x1753,
-	0x1760, 0x176c,
-	0x176e, 0x1770,
-	0x1772, 0x1773,
-	0x1780, 0x17b3,
-	0x17b6, 0x17d3,
-	0x17d7, 0x17d7,
-	0x17dc, 0x17dd,
-	0x17e0, 0x17e9,
-	0x180b, 0x180d,
-	0x1810, 0x1819,
-	0x1820, 0x1877,
-	0x1880, 0x18aa,
-	0x18b0, 0x18f5,
-	0x1900, 0x191c,
-	0x1920, 0x192b,
-	0x1930, 0x193b,
-	0x1946, 0x196d,
-	0x1970, 0x1974,
-	0x1980, 0x19ab,
-	0x19b0, 0x19c9,
-	0x19d0, 0x19da,
-	0x1a00, 0x1a1b,
-	0x1a20, 0x1a5e,
-	0x1a60, 0x1a7c,
-	0x1a7f, 0x1a89,
-	0x1a90, 0x1a99,
-	0x1aa7, 0x1aa7,
-	0x1b00, 0x1b4b,
-	0x1b50, 0x1b59,
-	0x1b6b, 0x1b73,
-	0x1b80, 0x1baa,
-	0x1bae, 0x1bb9,
-	0x1c00, 0x1c37,
-	0x1c40, 0x1c49,
-	0x1c4d, 0x1c7d,
-	0x1cd0, 0x1cd2,
-	0x1cd4, 0x1cf2,
-	0x1d00, 0x1de6,
-	0x1dfd, 0x1f15,
-	0x1f18, 0x1f1d,
-	0x1f20, 0x1f45,
-	0x1f48, 0x1f4d,
-	0x1f50, 0x1f57,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f7d,
-	0x1f80, 0x1fb4,
-	0x1fb6, 0x1fbc,
-	0x1fbe, 0x1fbe,
-	0x1fc2, 0x1fc4,
-	0x1fc6, 0x1fcc,
-	0x1fd0, 0x1fd3,
-	0x1fd6, 0x1fdb,
-	0x1fe0, 0x1fec,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ffc,
-	0x203f, 0x2040,
-	0x2054, 0x2054,
-	0x2071, 0x2071,
-	0x207f, 0x207f,
-	0x2090, 0x2094,
-	0x20d0, 0x20dc,
-	0x20e1, 0x20e1,
-	0x20e5, 0x20f0,
-	0x2102, 0x2102,
-	0x2107, 0x2107,
-	0x210a, 0x2113,
-	0x2115, 0x2115,
-	0x2118, 0x211d,
-	0x2124, 0x2124,
-	0x2126, 0x2126,
-	0x2128, 0x2128,
-	0x212a, 0x2139,
-	0x213c, 0x213f,
-	0x2145, 0x2149,
-	0x214e, 0x214e,
-	0x2160, 0x2188,
-	0x2c00, 0x2c2e,
-	0x2c30, 0x2c5e,
-	0x2c60, 0x2ce4,
-	0x2ceb, 0x2cf1,
-	0x2d00, 0x2d25,
-	0x2d30, 0x2d65,
-	0x2d6f, 0x2d6f,
-	0x2d80, 0x2d96,
-	0x2da0, 0x2da6,
-	0x2da8, 0x2dae,
-	0x2db0, 0x2db6,
-	0x2db8, 0x2dbe,
-	0x2dc0, 0x2dc6,
-	0x2dc8, 0x2dce,
-	0x2dd0, 0x2dd6,
-	0x2dd8, 0x2dde,
-	0x2de0, 0x2dff,
-	0x3005, 0x3007,
-	0x3021, 0x302f,
-	0x3031, 0x3035,
-	0x3038, 0x303c,
-	0x3041, 0x3096,
-	0x3099, 0x309f,
-	0x30a1, 0x30fa,
-	0x30fc, 0x30ff,
-	0x3105, 0x312d,
-	0x3131, 0x318e,
-	0x31a0, 0x31b7,
-	0x31f0, 0x31ff,
-	0x3400, 0x4db5,
-	0x4e00, 0x9fcb,
-	0xa000, 0xa48c,
-	0xa4d0, 0xa4fd,
-	0xa500, 0xa60c,
-	0xa610, 0xa62b,
-	0xa640, 0xa65f,
-	0xa662, 0xa66f,
-	0xa67c, 0xa67d,
-	0xa67f, 0xa697,
-	0xa6a0, 0xa6f1,
-	0xa717, 0xa71f,
-	0xa722, 0xa788,
-	0xa78b, 0xa78c,
-	0xa7fb, 0xa827,
-	0xa840, 0xa873,
-	0xa880, 0xa8c4,
-	0xa8d0, 0xa8d9,
-	0xa8e0, 0xa8f7,
-	0xa8fb, 0xa8fb,
-	0xa900, 0xa92d,
-	0xa930, 0xa953,
-	0xa960, 0xa97c,
-	0xa980, 0xa9c0,
-	0xa9cf, 0xa9d9,
-	0xaa00, 0xaa36,
-	0xaa40, 0xaa4d,
-	0xaa50, 0xaa59,
-	0xaa60, 0xaa76,
-	0xaa7a, 0xaa7b,
-	0xaa80, 0xaac2,
-	0xaadb, 0xaadd,
-	0xabc0, 0xabea,
-	0xabec, 0xabed,
-	0xabf0, 0xabf9,
-	0xac00, 0xd7a3,
-	0xd7b0, 0xd7c6,
-	0xd7cb, 0xd7fb,
-	0xf900, 0xfa2d,
-	0xfa30, 0xfa6d,
-	0xfa70, 0xfad9,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xfb1d, 0xfb28,
-	0xfb2a, 0xfb36,
-	0xfb38, 0xfb3c,
-	0xfb3e, 0xfb3e,
-	0xfb40, 0xfb41,
-	0xfb43, 0xfb44,
-	0xfb46, 0xfbb1,
-	0xfbd3, 0xfd3d,
-	0xfd50, 0xfd8f,
-	0xfd92, 0xfdc7,
-	0xfdf0, 0xfdfb,
-	0xfe00, 0xfe0f,
-	0xfe20, 0xfe26,
-	0xfe33, 0xfe34,
-	0xfe4d, 0xfe4f,
-	0xfe70, 0xfe74,
-	0xfe76, 0xfefc,
-	0xff10, 0xff19,
-	0xff21, 0xff3a,
-	0xff3f, 0xff3f,
-	0xff41, 0xff5a,
-	0xff66, 0xffbe,
-	0xffc2, 0xffc7,
-	0xffca, 0xffcf,
-	0xffd2, 0xffd7,
-	0xffda, 0xffdc,
-	0x10000, 0x1000b,
-	0x1000d, 0x10026,
-	0x10028, 0x1003a,
-	0x1003c, 0x1003d,
-	0x1003f, 0x1004d,
-	0x10050, 0x1005d,
-	0x10080, 0x100fa,
-	0x10140, 0x10174,
-	0x101fd, 0x101fd,
-	0x10280, 0x1029c,
-	0x102a0, 0x102d0,
-	0x10300, 0x1031e,
-	0x10330, 0x1034a,
-	0x10380, 0x1039d,
-	0x103a0, 0x103c3,
-	0x103c8, 0x103cf,
-	0x103d1, 0x103d5,
-	0x10400, 0x1049d,
-	0x104a0, 0x104a9,
-	0x10800, 0x10805,
-	0x10808, 0x10808,
-	0x1080a, 0x10835,
-	0x10837, 0x10838,
-	0x1083c, 0x1083c,
-	0x1083f, 0x10855,
-	0x10900, 0x10915,
-	0x10920, 0x10939,
-	0x10a00, 0x10a03,
-	0x10a05, 0x10a06,
-	0x10a0c, 0x10a13,
-	0x10a15, 0x10a17,
-	0x10a19, 0x10a33,
-	0x10a38, 0x10a3a,
-	0x10a3f, 0x10a3f,
-	0x10a60, 0x10a7c,
-	0x10b00, 0x10b35,
-	0x10b40, 0x10b55,
-	0x10b60, 0x10b72,
-	0x10c00, 0x10c48,
-	0x11080, 0x110ba,
-	0x12000, 0x1236e,
-	0x12400, 0x12462,
-	0x13000, 0x1342e,
-	0x1d165, 0x1d169,
-	0x1d16d, 0x1d172,
-	0x1d17b, 0x1d182,
-	0x1d185, 0x1d18b,
-	0x1d1aa, 0x1d1ad,
-	0x1d242, 0x1d244,
-	0x1d400, 0x1d454,
-	0x1d456, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d51e, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d552, 0x1d6a5,
-	0x1d6a8, 0x1d6c0,
-	0x1d6c2, 0x1d6da,
-	0x1d6dc, 0x1d6fa,
-	0x1d6fc, 0x1d714,
-	0x1d716, 0x1d734,
-	0x1d736, 0x1d74e,
-	0x1d750, 0x1d76e,
-	0x1d770, 0x1d788,
-	0x1d78a, 0x1d7a8,
-	0x1d7aa, 0x1d7c2,
-	0x1d7c4, 0x1d7cb,
-	0x1d7ce, 0x1d7ff,
-	0x20000, 0x2a6d6,
-	0x2a700, 0x2b734,
-	0x2f800, 0x2fa1d,
-	0xe0100, 0xe01ef,
+        506,
+        0x0030, 0x0039,
+        0x0041, 0x005a,
+        0x005f, 0x005f,
+        0x0061, 0x007a,
+        0x00aa, 0x00aa,
+        0x00b5, 0x00b5,
+        0x00b7, 0x00b7,
+        0x00ba, 0x00ba,
+        0x00c0, 0x00d6,
+        0x00d8, 0x00f6,
+        0x00f8, 0x02c1,
+        0x02c6, 0x02d1,
+        0x02e0, 0x02e4,
+        0x02ec, 0x02ec,
+        0x02ee, 0x02ee,
+        0x0300, 0x0374,
+        0x0376, 0x0377,
+        0x037a, 0x037d,
+        0x0386, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x03a1,
+        0x03a3, 0x03f5,
+        0x03f7, 0x0481,
+        0x0483, 0x0487,
+        0x048a, 0x0525,
+        0x0531, 0x0556,
+        0x0559, 0x0559,
+        0x0561, 0x0587,
+        0x0591, 0x05bd,
+        0x05bf, 0x05bf,
+        0x05c1, 0x05c2,
+        0x05c4, 0x05c5,
+        0x05c7, 0x05c7,
+        0x05d0, 0x05ea,
+        0x05f0, 0x05f2,
+        0x0610, 0x061a,
+        0x0621, 0x065e,
+        0x0660, 0x0669,
+        0x066e, 0x06d3,
+        0x06d5, 0x06dc,
+        0x06df, 0x06e8,
+        0x06ea, 0x06fc,
+        0x06ff, 0x06ff,
+        0x0710, 0x074a,
+        0x074d, 0x07b1,
+        0x07c0, 0x07f5,
+        0x07fa, 0x07fa,
+        0x0800, 0x082d,
+        0x0900, 0x0939,
+        0x093c, 0x094e,
+        0x0950, 0x0955,
+        0x0958, 0x0963,
+        0x0966, 0x096f,
+        0x0971, 0x0972,
+        0x0979, 0x097f,
+        0x0981, 0x0983,
+        0x0985, 0x098c,
+        0x098f, 0x0990,
+        0x0993, 0x09a8,
+        0x09aa, 0x09b0,
+        0x09b2, 0x09b2,
+        0x09b6, 0x09b9,
+        0x09bc, 0x09c4,
+        0x09c7, 0x09c8,
+        0x09cb, 0x09ce,
+        0x09d7, 0x09d7,
+        0x09dc, 0x09dd,
+        0x09df, 0x09e3,
+        0x09e6, 0x09f1,
+        0x0a01, 0x0a03,
+        0x0a05, 0x0a0a,
+        0x0a0f, 0x0a10,
+        0x0a13, 0x0a28,
+        0x0a2a, 0x0a30,
+        0x0a32, 0x0a33,
+        0x0a35, 0x0a36,
+        0x0a38, 0x0a39,
+        0x0a3c, 0x0a3c,
+        0x0a3e, 0x0a42,
+        0x0a47, 0x0a48,
+        0x0a4b, 0x0a4d,
+        0x0a51, 0x0a51,
+        0x0a59, 0x0a5c,
+        0x0a5e, 0x0a5e,
+        0x0a66, 0x0a75,
+        0x0a81, 0x0a83,
+        0x0a85, 0x0a8d,
+        0x0a8f, 0x0a91,
+        0x0a93, 0x0aa8,
+        0x0aaa, 0x0ab0,
+        0x0ab2, 0x0ab3,
+        0x0ab5, 0x0ab9,
+        0x0abc, 0x0ac5,
+        0x0ac7, 0x0ac9,
+        0x0acb, 0x0acd,
+        0x0ad0, 0x0ad0,
+        0x0ae0, 0x0ae3,
+        0x0ae6, 0x0aef,
+        0x0b01, 0x0b03,
+        0x0b05, 0x0b0c,
+        0x0b0f, 0x0b10,
+        0x0b13, 0x0b28,
+        0x0b2a, 0x0b30,
+        0x0b32, 0x0b33,
+        0x0b35, 0x0b39,
+        0x0b3c, 0x0b44,
+        0x0b47, 0x0b48,
+        0x0b4b, 0x0b4d,
+        0x0b56, 0x0b57,
+        0x0b5c, 0x0b5d,
+        0x0b5f, 0x0b63,
+        0x0b66, 0x0b6f,
+        0x0b71, 0x0b71,
+        0x0b82, 0x0b83,
+        0x0b85, 0x0b8a,
+        0x0b8e, 0x0b90,
+        0x0b92, 0x0b95,
+        0x0b99, 0x0b9a,
+        0x0b9c, 0x0b9c,
+        0x0b9e, 0x0b9f,
+        0x0ba3, 0x0ba4,
+        0x0ba8, 0x0baa,
+        0x0bae, 0x0bb9,
+        0x0bbe, 0x0bc2,
+        0x0bc6, 0x0bc8,
+        0x0bca, 0x0bcd,
+        0x0bd0, 0x0bd0,
+        0x0bd7, 0x0bd7,
+        0x0be6, 0x0bef,
+        0x0c01, 0x0c03,
+        0x0c05, 0x0c0c,
+        0x0c0e, 0x0c10,
+        0x0c12, 0x0c28,
+        0x0c2a, 0x0c33,
+        0x0c35, 0x0c39,
+        0x0c3d, 0x0c44,
+        0x0c46, 0x0c48,
+        0x0c4a, 0x0c4d,
+        0x0c55, 0x0c56,
+        0x0c58, 0x0c59,
+        0x0c60, 0x0c63,
+        0x0c66, 0x0c6f,
+        0x0c82, 0x0c83,
+        0x0c85, 0x0c8c,
+        0x0c8e, 0x0c90,
+        0x0c92, 0x0ca8,
+        0x0caa, 0x0cb3,
+        0x0cb5, 0x0cb9,
+        0x0cbc, 0x0cc4,
+        0x0cc6, 0x0cc8,
+        0x0cca, 0x0ccd,
+        0x0cd5, 0x0cd6,
+        0x0cde, 0x0cde,
+        0x0ce0, 0x0ce3,
+        0x0ce6, 0x0cef,
+        0x0d02, 0x0d03,
+        0x0d05, 0x0d0c,
+        0x0d0e, 0x0d10,
+        0x0d12, 0x0d28,
+        0x0d2a, 0x0d39,
+        0x0d3d, 0x0d44,
+        0x0d46, 0x0d48,
+        0x0d4a, 0x0d4d,
+        0x0d57, 0x0d57,
+        0x0d60, 0x0d63,
+        0x0d66, 0x0d6f,
+        0x0d7a, 0x0d7f,
+        0x0d82, 0x0d83,
+        0x0d85, 0x0d96,
+        0x0d9a, 0x0db1,
+        0x0db3, 0x0dbb,
+        0x0dbd, 0x0dbd,
+        0x0dc0, 0x0dc6,
+        0x0dca, 0x0dca,
+        0x0dcf, 0x0dd4,
+        0x0dd6, 0x0dd6,
+        0x0dd8, 0x0ddf,
+        0x0df2, 0x0df3,
+        0x0e01, 0x0e3a,
+        0x0e40, 0x0e4e,
+        0x0e50, 0x0e59,
+        0x0e81, 0x0e82,
+        0x0e84, 0x0e84,
+        0x0e87, 0x0e88,
+        0x0e8a, 0x0e8a,
+        0x0e8d, 0x0e8d,
+        0x0e94, 0x0e97,
+        0x0e99, 0x0e9f,
+        0x0ea1, 0x0ea3,
+        0x0ea5, 0x0ea5,
+        0x0ea7, 0x0ea7,
+        0x0eaa, 0x0eab,
+        0x0ead, 0x0eb9,
+        0x0ebb, 0x0ebd,
+        0x0ec0, 0x0ec4,
+        0x0ec6, 0x0ec6,
+        0x0ec8, 0x0ecd,
+        0x0ed0, 0x0ed9,
+        0x0edc, 0x0edd,
+        0x0f00, 0x0f00,
+        0x0f18, 0x0f19,
+        0x0f20, 0x0f29,
+        0x0f35, 0x0f35,
+        0x0f37, 0x0f37,
+        0x0f39, 0x0f39,
+        0x0f3e, 0x0f47,
+        0x0f49, 0x0f6c,
+        0x0f71, 0x0f84,
+        0x0f86, 0x0f8b,
+        0x0f90, 0x0f97,
+        0x0f99, 0x0fbc,
+        0x0fc6, 0x0fc6,
+        0x1000, 0x1049,
+        0x1050, 0x109d,
+        0x10a0, 0x10c5,
+        0x10d0, 0x10fa,
+        0x10fc, 0x10fc,
+        0x1100, 0x1248,
+        0x124a, 0x124d,
+        0x1250, 0x1256,
+        0x1258, 0x1258,
+        0x125a, 0x125d,
+        0x1260, 0x1288,
+        0x128a, 0x128d,
+        0x1290, 0x12b0,
+        0x12b2, 0x12b5,
+        0x12b8, 0x12be,
+        0x12c0, 0x12c0,
+        0x12c2, 0x12c5,
+        0x12c8, 0x12d6,
+        0x12d8, 0x1310,
+        0x1312, 0x1315,
+        0x1318, 0x135a,
+        0x135f, 0x135f,
+        0x1369, 0x1371,
+        0x1380, 0x138f,
+        0x13a0, 0x13f4,
+        0x1401, 0x166c,
+        0x166f, 0x167f,
+        0x1681, 0x169a,
+        0x16a0, 0x16ea,
+        0x16ee, 0x16f0,
+        0x1700, 0x170c,
+        0x170e, 0x1714,
+        0x1720, 0x1734,
+        0x1740, 0x1753,
+        0x1760, 0x176c,
+        0x176e, 0x1770,
+        0x1772, 0x1773,
+        0x1780, 0x17b3,
+        0x17b6, 0x17d3,
+        0x17d7, 0x17d7,
+        0x17dc, 0x17dd,
+        0x17e0, 0x17e9,
+        0x180b, 0x180d,
+        0x1810, 0x1819,
+        0x1820, 0x1877,
+        0x1880, 0x18aa,
+        0x18b0, 0x18f5,
+        0x1900, 0x191c,
+        0x1920, 0x192b,
+        0x1930, 0x193b,
+        0x1946, 0x196d,
+        0x1970, 0x1974,
+        0x1980, 0x19ab,
+        0x19b0, 0x19c9,
+        0x19d0, 0x19da,
+        0x1a00, 0x1a1b,
+        0x1a20, 0x1a5e,
+        0x1a60, 0x1a7c,
+        0x1a7f, 0x1a89,
+        0x1a90, 0x1a99,
+        0x1aa7, 0x1aa7,
+        0x1b00, 0x1b4b,
+        0x1b50, 0x1b59,
+        0x1b6b, 0x1b73,
+        0x1b80, 0x1baa,
+        0x1bae, 0x1bb9,
+        0x1c00, 0x1c37,
+        0x1c40, 0x1c49,
+        0x1c4d, 0x1c7d,
+        0x1cd0, 0x1cd2,
+        0x1cd4, 0x1cf2,
+        0x1d00, 0x1de6,
+        0x1dfd, 0x1f15,
+        0x1f18, 0x1f1d,
+        0x1f20, 0x1f45,
+        0x1f48, 0x1f4d,
+        0x1f50, 0x1f57,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f7d,
+        0x1f80, 0x1fb4,
+        0x1fb6, 0x1fbc,
+        0x1fbe, 0x1fbe,
+        0x1fc2, 0x1fc4,
+        0x1fc6, 0x1fcc,
+        0x1fd0, 0x1fd3,
+        0x1fd6, 0x1fdb,
+        0x1fe0, 0x1fec,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ffc,
+        0x203f, 0x2040,
+        0x2054, 0x2054,
+        0x2071, 0x2071,
+        0x207f, 0x207f,
+        0x2090, 0x2094,
+        0x20d0, 0x20dc,
+        0x20e1, 0x20e1,
+        0x20e5, 0x20f0,
+        0x2102, 0x2102,
+        0x2107, 0x2107,
+        0x210a, 0x2113,
+        0x2115, 0x2115,
+        0x2118, 0x211d,
+        0x2124, 0x2124,
+        0x2126, 0x2126,
+        0x2128, 0x2128,
+        0x212a, 0x2139,
+        0x213c, 0x213f,
+        0x2145, 0x2149,
+        0x214e, 0x214e,
+        0x2160, 0x2188,
+        0x2c00, 0x2c2e,
+        0x2c30, 0x2c5e,
+        0x2c60, 0x2ce4,
+        0x2ceb, 0x2cf1,
+        0x2d00, 0x2d25,
+        0x2d30, 0x2d65,
+        0x2d6f, 0x2d6f,
+        0x2d80, 0x2d96,
+        0x2da0, 0x2da6,
+        0x2da8, 0x2dae,
+        0x2db0, 0x2db6,
+        0x2db8, 0x2dbe,
+        0x2dc0, 0x2dc6,
+        0x2dc8, 0x2dce,
+        0x2dd0, 0x2dd6,
+        0x2dd8, 0x2dde,
+        0x2de0, 0x2dff,
+        0x3005, 0x3007,
+        0x3021, 0x302f,
+        0x3031, 0x3035,
+        0x3038, 0x303c,
+        0x3041, 0x3096,
+        0x3099, 0x309f,
+        0x30a1, 0x30fa,
+        0x30fc, 0x30ff,
+        0x3105, 0x312d,
+        0x3131, 0x318e,
+        0x31a0, 0x31b7,
+        0x31f0, 0x31ff,
+        0x3400, 0x4db5,
+        0x4e00, 0x9fcb,
+        0xa000, 0xa48c,
+        0xa4d0, 0xa4fd,
+        0xa500, 0xa60c,
+        0xa610, 0xa62b,
+        0xa640, 0xa65f,
+        0xa662, 0xa66f,
+        0xa67c, 0xa67d,
+        0xa67f, 0xa697,
+        0xa6a0, 0xa6f1,
+        0xa717, 0xa71f,
+        0xa722, 0xa788,
+        0xa78b, 0xa78c,
+        0xa7fb, 0xa827,
+        0xa840, 0xa873,
+        0xa880, 0xa8c4,
+        0xa8d0, 0xa8d9,
+        0xa8e0, 0xa8f7,
+        0xa8fb, 0xa8fb,
+        0xa900, 0xa92d,
+        0xa930, 0xa953,
+        0xa960, 0xa97c,
+        0xa980, 0xa9c0,
+        0xa9cf, 0xa9d9,
+        0xaa00, 0xaa36,
+        0xaa40, 0xaa4d,
+        0xaa50, 0xaa59,
+        0xaa60, 0xaa76,
+        0xaa7a, 0xaa7b,
+        0xaa80, 0xaac2,
+        0xaadb, 0xaadd,
+        0xabc0, 0xabea,
+        0xabec, 0xabed,
+        0xabf0, 0xabf9,
+        0xac00, 0xd7a3,
+        0xd7b0, 0xd7c6,
+        0xd7cb, 0xd7fb,
+        0xf900, 0xfa2d,
+        0xfa30, 0xfa6d,
+        0xfa70, 0xfad9,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xfb1d, 0xfb28,
+        0xfb2a, 0xfb36,
+        0xfb38, 0xfb3c,
+        0xfb3e, 0xfb3e,
+        0xfb40, 0xfb41,
+        0xfb43, 0xfb44,
+        0xfb46, 0xfbb1,
+        0xfbd3, 0xfd3d,
+        0xfd50, 0xfd8f,
+        0xfd92, 0xfdc7,
+        0xfdf0, 0xfdfb,
+        0xfe00, 0xfe0f,
+        0xfe20, 0xfe26,
+        0xfe33, 0xfe34,
+        0xfe4d, 0xfe4f,
+        0xfe70, 0xfe74,
+        0xfe76, 0xfefc,
+        0xff10, 0xff19,
+        0xff21, 0xff3a,
+        0xff3f, 0xff3f,
+        0xff41, 0xff5a,
+        0xff66, 0xffbe,
+        0xffc2, 0xffc7,
+        0xffca, 0xffcf,
+        0xffd2, 0xffd7,
+        0xffda, 0xffdc,
+        0x10000, 0x1000b,
+        0x1000d, 0x10026,
+        0x10028, 0x1003a,
+        0x1003c, 0x1003d,
+        0x1003f, 0x1004d,
+        0x10050, 0x1005d,
+        0x10080, 0x100fa,
+        0x10140, 0x10174,
+        0x101fd, 0x101fd,
+        0x10280, 0x1029c,
+        0x102a0, 0x102d0,
+        0x10300, 0x1031e,
+        0x10330, 0x1034a,
+        0x10380, 0x1039d,
+        0x103a0, 0x103c3,
+        0x103c8, 0x103cf,
+        0x103d1, 0x103d5,
+        0x10400, 0x1049d,
+        0x104a0, 0x104a9,
+        0x10800, 0x10805,
+        0x10808, 0x10808,
+        0x1080a, 0x10835,
+        0x10837, 0x10838,
+        0x1083c, 0x1083c,
+        0x1083f, 0x10855,
+        0x10900, 0x10915,
+        0x10920, 0x10939,
+        0x10a00, 0x10a03,
+        0x10a05, 0x10a06,
+        0x10a0c, 0x10a13,
+        0x10a15, 0x10a17,
+        0x10a19, 0x10a33,
+        0x10a38, 0x10a3a,
+        0x10a3f, 0x10a3f,
+        0x10a60, 0x10a7c,
+        0x10b00, 0x10b35,
+        0x10b40, 0x10b55,
+        0x10b60, 0x10b72,
+        0x10c00, 0x10c48,
+        0x11080, 0x110ba,
+        0x12000, 0x1236e,
+        0x12400, 0x12462,
+        0x13000, 0x1342e,
+        0x1d165, 0x1d169,
+        0x1d16d, 0x1d172,
+        0x1d17b, 0x1d182,
+        0x1d185, 0x1d18b,
+        0x1d1aa, 0x1d1ad,
+        0x1d242, 0x1d244,
+        0x1d400, 0x1d454,
+        0x1d456, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d51e, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d552, 0x1d6a5,
+        0x1d6a8, 0x1d6c0,
+        0x1d6c2, 0x1d6da,
+        0x1d6dc, 0x1d6fa,
+        0x1d6fc, 0x1d714,
+        0x1d716, 0x1d734,
+        0x1d736, 0x1d74e,
+        0x1d750, 0x1d76e,
+        0x1d770, 0x1d788,
+        0x1d78a, 0x1d7a8,
+        0x1d7aa, 0x1d7c2,
+        0x1d7c4, 0x1d7cb,
+        0x1d7ce, 0x1d7ff,
+        0x20000, 0x2a6d6,
+        0x2a700, 0x2b734,
+        0x2f800, 0x2fa1d,
+        0xe0100, 0xe01ef,
 }; /* CR_ID_Continue */
 
 /* 'XID_Start': Derived Property */
 static const OnigCodePoint CR_XID_Start[] = {
-	431,
-	0x0041, 0x005a,
-	0x0061, 0x007a,
-	0x00aa, 0x00aa,
-	0x00b5, 0x00b5,
-	0x00ba, 0x00ba,
-	0x00c0, 0x00d6,
-	0x00d8, 0x00f6,
-	0x00f8, 0x02c1,
-	0x02c6, 0x02d1,
-	0x02e0, 0x02e4,
-	0x02ec, 0x02ec,
-	0x02ee, 0x02ee,
-	0x0370, 0x0374,
-	0x0376, 0x0377,
-	0x037b, 0x037d,
-	0x0386, 0x0386,
-	0x0388, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x03a1,
-	0x03a3, 0x03f5,
-	0x03f7, 0x0481,
-	0x048a, 0x0525,
-	0x0531, 0x0556,
-	0x0559, 0x0559,
-	0x0561, 0x0587,
-	0x05d0, 0x05ea,
-	0x05f0, 0x05f2,
-	0x0621, 0x064a,
-	0x066e, 0x066f,
-	0x0671, 0x06d3,
-	0x06d5, 0x06d5,
-	0x06e5, 0x06e6,
-	0x06ee, 0x06ef,
-	0x06fa, 0x06fc,
-	0x06ff, 0x06ff,
-	0x0710, 0x0710,
-	0x0712, 0x072f,
-	0x074d, 0x07a5,
-	0x07b1, 0x07b1,
-	0x07ca, 0x07ea,
-	0x07f4, 0x07f5,
-	0x07fa, 0x07fa,
-	0x0800, 0x0815,
-	0x081a, 0x081a,
-	0x0824, 0x0824,
-	0x0828, 0x0828,
-	0x0904, 0x0939,
-	0x093d, 0x093d,
-	0x0950, 0x0950,
-	0x0958, 0x0961,
-	0x0971, 0x0972,
-	0x0979, 0x097f,
-	0x0985, 0x098c,
-	0x098f, 0x0990,
-	0x0993, 0x09a8,
-	0x09aa, 0x09b0,
-	0x09b2, 0x09b2,
-	0x09b6, 0x09b9,
-	0x09bd, 0x09bd,
-	0x09ce, 0x09ce,
-	0x09dc, 0x09dd,
-	0x09df, 0x09e1,
-	0x09f0, 0x09f1,
-	0x0a05, 0x0a0a,
-	0x0a0f, 0x0a10,
-	0x0a13, 0x0a28,
-	0x0a2a, 0x0a30,
-	0x0a32, 0x0a33,
-	0x0a35, 0x0a36,
-	0x0a38, 0x0a39,
-	0x0a59, 0x0a5c,
-	0x0a5e, 0x0a5e,
-	0x0a72, 0x0a74,
-	0x0a85, 0x0a8d,
-	0x0a8f, 0x0a91,
-	0x0a93, 0x0aa8,
-	0x0aaa, 0x0ab0,
-	0x0ab2, 0x0ab3,
-	0x0ab5, 0x0ab9,
-	0x0abd, 0x0abd,
-	0x0ad0, 0x0ad0,
-	0x0ae0, 0x0ae1,
-	0x0b05, 0x0b0c,
-	0x0b0f, 0x0b10,
-	0x0b13, 0x0b28,
-	0x0b2a, 0x0b30,
-	0x0b32, 0x0b33,
-	0x0b35, 0x0b39,
-	0x0b3d, 0x0b3d,
-	0x0b5c, 0x0b5d,
-	0x0b5f, 0x0b61,
-	0x0b71, 0x0b71,
-	0x0b83, 0x0b83,
-	0x0b85, 0x0b8a,
-	0x0b8e, 0x0b90,
-	0x0b92, 0x0b95,
-	0x0b99, 0x0b9a,
-	0x0b9c, 0x0b9c,
-	0x0b9e, 0x0b9f,
-	0x0ba3, 0x0ba4,
-	0x0ba8, 0x0baa,
-	0x0bae, 0x0bb9,
-	0x0bd0, 0x0bd0,
-	0x0c05, 0x0c0c,
-	0x0c0e, 0x0c10,
-	0x0c12, 0x0c28,
-	0x0c2a, 0x0c33,
-	0x0c35, 0x0c39,
-	0x0c3d, 0x0c3d,
-	0x0c58, 0x0c59,
-	0x0c60, 0x0c61,
-	0x0c85, 0x0c8c,
-	0x0c8e, 0x0c90,
-	0x0c92, 0x0ca8,
-	0x0caa, 0x0cb3,
-	0x0cb5, 0x0cb9,
-	0x0cbd, 0x0cbd,
-	0x0cde, 0x0cde,
-	0x0ce0, 0x0ce1,
-	0x0d05, 0x0d0c,
-	0x0d0e, 0x0d10,
-	0x0d12, 0x0d28,
-	0x0d2a, 0x0d39,
-	0x0d3d, 0x0d3d,
-	0x0d60, 0x0d61,
-	0x0d7a, 0x0d7f,
-	0x0d85, 0x0d96,
-	0x0d9a, 0x0db1,
-	0x0db3, 0x0dbb,
-	0x0dbd, 0x0dbd,
-	0x0dc0, 0x0dc6,
-	0x0e01, 0x0e30,
-	0x0e32, 0x0e32,
-	0x0e40, 0x0e46,
-	0x0e81, 0x0e82,
-	0x0e84, 0x0e84,
-	0x0e87, 0x0e88,
-	0x0e8a, 0x0e8a,
-	0x0e8d, 0x0e8d,
-	0x0e94, 0x0e97,
-	0x0e99, 0x0e9f,
-	0x0ea1, 0x0ea3,
-	0x0ea5, 0x0ea5,
-	0x0ea7, 0x0ea7,
-	0x0eaa, 0x0eab,
-	0x0ead, 0x0eb0,
-	0x0eb2, 0x0eb2,
-	0x0ebd, 0x0ebd,
-	0x0ec0, 0x0ec4,
-	0x0ec6, 0x0ec6,
-	0x0edc, 0x0edd,
-	0x0f00, 0x0f00,
-	0x0f40, 0x0f47,
-	0x0f49, 0x0f6c,
-	0x0f88, 0x0f8b,
-	0x1000, 0x102a,
-	0x103f, 0x103f,
-	0x1050, 0x1055,
-	0x105a, 0x105d,
-	0x1061, 0x1061,
-	0x1065, 0x1066,
-	0x106e, 0x1070,
-	0x1075, 0x1081,
-	0x108e, 0x108e,
-	0x10a0, 0x10c5,
-	0x10d0, 0x10fa,
-	0x10fc, 0x10fc,
-	0x1100, 0x1248,
-	0x124a, 0x124d,
-	0x1250, 0x1256,
-	0x1258, 0x1258,
-	0x125a, 0x125d,
-	0x1260, 0x1288,
-	0x128a, 0x128d,
-	0x1290, 0x12b0,
-	0x12b2, 0x12b5,
-	0x12b8, 0x12be,
-	0x12c0, 0x12c0,
-	0x12c2, 0x12c5,
-	0x12c8, 0x12d6,
-	0x12d8, 0x1310,
-	0x1312, 0x1315,
-	0x1318, 0x135a,
-	0x1380, 0x138f,
-	0x13a0, 0x13f4,
-	0x1401, 0x166c,
-	0x166f, 0x167f,
-	0x1681, 0x169a,
-	0x16a0, 0x16ea,
-	0x16ee, 0x16f0,
-	0x1700, 0x170c,
-	0x170e, 0x1711,
-	0x1720, 0x1731,
-	0x1740, 0x1751,
-	0x1760, 0x176c,
-	0x176e, 0x1770,
-	0x1780, 0x17b3,
-	0x17d7, 0x17d7,
-	0x17dc, 0x17dc,
-	0x1820, 0x1877,
-	0x1880, 0x18a8,
-	0x18aa, 0x18aa,
-	0x18b0, 0x18f5,
-	0x1900, 0x191c,
-	0x1950, 0x196d,
-	0x1970, 0x1974,
-	0x1980, 0x19ab,
-	0x19c1, 0x19c7,
-	0x1a00, 0x1a16,
-	0x1a20, 0x1a54,
-	0x1aa7, 0x1aa7,
-	0x1b05, 0x1b33,
-	0x1b45, 0x1b4b,
-	0x1b83, 0x1ba0,
-	0x1bae, 0x1baf,
-	0x1c00, 0x1c23,
-	0x1c4d, 0x1c4f,
-	0x1c5a, 0x1c7d,
-	0x1ce9, 0x1cec,
-	0x1cee, 0x1cf1,
-	0x1d00, 0x1dbf,
-	0x1e00, 0x1f15,
-	0x1f18, 0x1f1d,
-	0x1f20, 0x1f45,
-	0x1f48, 0x1f4d,
-	0x1f50, 0x1f57,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f7d,
-	0x1f80, 0x1fb4,
-	0x1fb6, 0x1fbc,
-	0x1fbe, 0x1fbe,
-	0x1fc2, 0x1fc4,
-	0x1fc6, 0x1fcc,
-	0x1fd0, 0x1fd3,
-	0x1fd6, 0x1fdb,
-	0x1fe0, 0x1fec,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ffc,
-	0x2071, 0x2071,
-	0x207f, 0x207f,
-	0x2090, 0x2094,
-	0x2102, 0x2102,
-	0x2107, 0x2107,
-	0x210a, 0x2113,
-	0x2115, 0x2115,
-	0x2118, 0x211d,
-	0x2124, 0x2124,
-	0x2126, 0x2126,
-	0x2128, 0x2128,
-	0x212a, 0x2139,
-	0x213c, 0x213f,
-	0x2145, 0x2149,
-	0x214e, 0x214e,
-	0x2160, 0x2188,
-	0x2c00, 0x2c2e,
-	0x2c30, 0x2c5e,
-	0x2c60, 0x2ce4,
-	0x2ceb, 0x2cee,
-	0x2d00, 0x2d25,
-	0x2d30, 0x2d65,
-	0x2d6f, 0x2d6f,
-	0x2d80, 0x2d96,
-	0x2da0, 0x2da6,
-	0x2da8, 0x2dae,
-	0x2db0, 0x2db6,
-	0x2db8, 0x2dbe,
-	0x2dc0, 0x2dc6,
-	0x2dc8, 0x2dce,
-	0x2dd0, 0x2dd6,
-	0x2dd8, 0x2dde,
-	0x3005, 0x3007,
-	0x3021, 0x3029,
-	0x3031, 0x3035,
-	0x3038, 0x303c,
-	0x3041, 0x3096,
-	0x309d, 0x309f,
-	0x30a1, 0x30fa,
-	0x30fc, 0x30ff,
-	0x3105, 0x312d,
-	0x3131, 0x318e,
-	0x31a0, 0x31b7,
-	0x31f0, 0x31ff,
-	0x3400, 0x4db5,
-	0x4e00, 0x9fcb,
-	0xa000, 0xa48c,
-	0xa4d0, 0xa4fd,
-	0xa500, 0xa60c,
-	0xa610, 0xa61f,
-	0xa62a, 0xa62b,
-	0xa640, 0xa65f,
-	0xa662, 0xa66e,
-	0xa67f, 0xa697,
-	0xa6a0, 0xa6ef,
-	0xa717, 0xa71f,
-	0xa722, 0xa788,
-	0xa78b, 0xa78c,
-	0xa7fb, 0xa801,
-	0xa803, 0xa805,
-	0xa807, 0xa80a,
-	0xa80c, 0xa822,
-	0xa840, 0xa873,
-	0xa882, 0xa8b3,
-	0xa8f2, 0xa8f7,
-	0xa8fb, 0xa8fb,
-	0xa90a, 0xa925,
-	0xa930, 0xa946,
-	0xa960, 0xa97c,
-	0xa984, 0xa9b2,
-	0xa9cf, 0xa9cf,
-	0xaa00, 0xaa28,
-	0xaa40, 0xaa42,
-	0xaa44, 0xaa4b,
-	0xaa60, 0xaa76,
-	0xaa7a, 0xaa7a,
-	0xaa80, 0xaaaf,
-	0xaab1, 0xaab1,
-	0xaab5, 0xaab6,
-	0xaab9, 0xaabd,
-	0xaac0, 0xaac0,
-	0xaac2, 0xaac2,
-	0xaadb, 0xaadd,
-	0xabc0, 0xabe2,
-	0xac00, 0xd7a3,
-	0xd7b0, 0xd7c6,
-	0xd7cb, 0xd7fb,
-	0xf900, 0xfa2d,
-	0xfa30, 0xfa6d,
-	0xfa70, 0xfad9,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xfb1d, 0xfb1d,
-	0xfb1f, 0xfb28,
-	0xfb2a, 0xfb36,
-	0xfb38, 0xfb3c,
-	0xfb3e, 0xfb3e,
-	0xfb40, 0xfb41,
-	0xfb43, 0xfb44,
-	0xfb46, 0xfbb1,
-	0xfbd3, 0xfc5d,
-	0xfc64, 0xfd3d,
-	0xfd50, 0xfd8f,
-	0xfd92, 0xfdc7,
-	0xfdf0, 0xfdf9,
-	0xfe71, 0xfe71,
-	0xfe73, 0xfe73,
-	0xfe77, 0xfe77,
-	0xfe79, 0xfe79,
-	0xfe7b, 0xfe7b,
-	0xfe7d, 0xfe7d,
-	0xfe7f, 0xfefc,
-	0xff21, 0xff3a,
-	0xff41, 0xff5a,
-	0xff66, 0xff9d,
-	0xffa0, 0xffbe,
-	0xffc2, 0xffc7,
-	0xffca, 0xffcf,
-	0xffd2, 0xffd7,
-	0xffda, 0xffdc,
-	0x10000, 0x1000b,
-	0x1000d, 0x10026,
-	0x10028, 0x1003a,
-	0x1003c, 0x1003d,
-	0x1003f, 0x1004d,
-	0x10050, 0x1005d,
-	0x10080, 0x100fa,
-	0x10140, 0x10174,
-	0x10280, 0x1029c,
-	0x102a0, 0x102d0,
-	0x10300, 0x1031e,
-	0x10330, 0x1034a,
-	0x10380, 0x1039d,
-	0x103a0, 0x103c3,
-	0x103c8, 0x103cf,
-	0x103d1, 0x103d5,
-	0x10400, 0x1049d,
-	0x10800, 0x10805,
-	0x10808, 0x10808,
-	0x1080a, 0x10835,
-	0x10837, 0x10838,
-	0x1083c, 0x1083c,
-	0x1083f, 0x10855,
-	0x10900, 0x10915,
-	0x10920, 0x10939,
-	0x10a00, 0x10a00,
-	0x10a10, 0x10a13,
-	0x10a15, 0x10a17,
-	0x10a19, 0x10a33,
-	0x10a60, 0x10a7c,
-	0x10b00, 0x10b35,
-	0x10b40, 0x10b55,
-	0x10b60, 0x10b72,
-	0x10c00, 0x10c48,
-	0x11083, 0x110af,
-	0x12000, 0x1236e,
-	0x12400, 0x12462,
-	0x13000, 0x1342e,
-	0x1d400, 0x1d454,
-	0x1d456, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d51e, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d552, 0x1d6a5,
-	0x1d6a8, 0x1d6c0,
-	0x1d6c2, 0x1d6da,
-	0x1d6dc, 0x1d6fa,
-	0x1d6fc, 0x1d714,
-	0x1d716, 0x1d734,
-	0x1d736, 0x1d74e,
-	0x1d750, 0x1d76e,
-	0x1d770, 0x1d788,
-	0x1d78a, 0x1d7a8,
-	0x1d7aa, 0x1d7c2,
-	0x1d7c4, 0x1d7cb,
-	0x20000, 0x2a6d6,
-	0x2a700, 0x2b734,
-	0x2f800, 0x2fa1d,
+        431,
+        0x0041, 0x005a,
+        0x0061, 0x007a,
+        0x00aa, 0x00aa,
+        0x00b5, 0x00b5,
+        0x00ba, 0x00ba,
+        0x00c0, 0x00d6,
+        0x00d8, 0x00f6,
+        0x00f8, 0x02c1,
+        0x02c6, 0x02d1,
+        0x02e0, 0x02e4,
+        0x02ec, 0x02ec,
+        0x02ee, 0x02ee,
+        0x0370, 0x0374,
+        0x0376, 0x0377,
+        0x037b, 0x037d,
+        0x0386, 0x0386,
+        0x0388, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x03a1,
+        0x03a3, 0x03f5,
+        0x03f7, 0x0481,
+        0x048a, 0x0525,
+        0x0531, 0x0556,
+        0x0559, 0x0559,
+        0x0561, 0x0587,
+        0x05d0, 0x05ea,
+        0x05f0, 0x05f2,
+        0x0621, 0x064a,
+        0x066e, 0x066f,
+        0x0671, 0x06d3,
+        0x06d5, 0x06d5,
+        0x06e5, 0x06e6,
+        0x06ee, 0x06ef,
+        0x06fa, 0x06fc,
+        0x06ff, 0x06ff,
+        0x0710, 0x0710,
+        0x0712, 0x072f,
+        0x074d, 0x07a5,
+        0x07b1, 0x07b1,
+        0x07ca, 0x07ea,
+        0x07f4, 0x07f5,
+        0x07fa, 0x07fa,
+        0x0800, 0x0815,
+        0x081a, 0x081a,
+        0x0824, 0x0824,
+        0x0828, 0x0828,
+        0x0904, 0x0939,
+        0x093d, 0x093d,
+        0x0950, 0x0950,
+        0x0958, 0x0961,
+        0x0971, 0x0972,
+        0x0979, 0x097f,
+        0x0985, 0x098c,
+        0x098f, 0x0990,
+        0x0993, 0x09a8,
+        0x09aa, 0x09b0,
+        0x09b2, 0x09b2,
+        0x09b6, 0x09b9,
+        0x09bd, 0x09bd,
+        0x09ce, 0x09ce,
+        0x09dc, 0x09dd,
+        0x09df, 0x09e1,
+        0x09f0, 0x09f1,
+        0x0a05, 0x0a0a,
+        0x0a0f, 0x0a10,
+        0x0a13, 0x0a28,
+        0x0a2a, 0x0a30,
+        0x0a32, 0x0a33,
+        0x0a35, 0x0a36,
+        0x0a38, 0x0a39,
+        0x0a59, 0x0a5c,
+        0x0a5e, 0x0a5e,
+        0x0a72, 0x0a74,
+        0x0a85, 0x0a8d,
+        0x0a8f, 0x0a91,
+        0x0a93, 0x0aa8,
+        0x0aaa, 0x0ab0,
+        0x0ab2, 0x0ab3,
+        0x0ab5, 0x0ab9,
+        0x0abd, 0x0abd,
+        0x0ad0, 0x0ad0,
+        0x0ae0, 0x0ae1,
+        0x0b05, 0x0b0c,
+        0x0b0f, 0x0b10,
+        0x0b13, 0x0b28,
+        0x0b2a, 0x0b30,
+        0x0b32, 0x0b33,
+        0x0b35, 0x0b39,
+        0x0b3d, 0x0b3d,
+        0x0b5c, 0x0b5d,
+        0x0b5f, 0x0b61,
+        0x0b71, 0x0b71,
+        0x0b83, 0x0b83,
+        0x0b85, 0x0b8a,
+        0x0b8e, 0x0b90,
+        0x0b92, 0x0b95,
+        0x0b99, 0x0b9a,
+        0x0b9c, 0x0b9c,
+        0x0b9e, 0x0b9f,
+        0x0ba3, 0x0ba4,
+        0x0ba8, 0x0baa,
+        0x0bae, 0x0bb9,
+        0x0bd0, 0x0bd0,
+        0x0c05, 0x0c0c,
+        0x0c0e, 0x0c10,
+        0x0c12, 0x0c28,
+        0x0c2a, 0x0c33,
+        0x0c35, 0x0c39,
+        0x0c3d, 0x0c3d,
+        0x0c58, 0x0c59,
+        0x0c60, 0x0c61,
+        0x0c85, 0x0c8c,
+        0x0c8e, 0x0c90,
+        0x0c92, 0x0ca8,
+        0x0caa, 0x0cb3,
+        0x0cb5, 0x0cb9,
+        0x0cbd, 0x0cbd,
+        0x0cde, 0x0cde,
+        0x0ce0, 0x0ce1,
+        0x0d05, 0x0d0c,
+        0x0d0e, 0x0d10,
+        0x0d12, 0x0d28,
+        0x0d2a, 0x0d39,
+        0x0d3d, 0x0d3d,
+        0x0d60, 0x0d61,
+        0x0d7a, 0x0d7f,
+        0x0d85, 0x0d96,
+        0x0d9a, 0x0db1,
+        0x0db3, 0x0dbb,
+        0x0dbd, 0x0dbd,
+        0x0dc0, 0x0dc6,
+        0x0e01, 0x0e30,
+        0x0e32, 0x0e32,
+        0x0e40, 0x0e46,
+        0x0e81, 0x0e82,
+        0x0e84, 0x0e84,
+        0x0e87, 0x0e88,
+        0x0e8a, 0x0e8a,
+        0x0e8d, 0x0e8d,
+        0x0e94, 0x0e97,
+        0x0e99, 0x0e9f,
+        0x0ea1, 0x0ea3,
+        0x0ea5, 0x0ea5,
+        0x0ea7, 0x0ea7,
+        0x0eaa, 0x0eab,
+        0x0ead, 0x0eb0,
+        0x0eb2, 0x0eb2,
+        0x0ebd, 0x0ebd,
+        0x0ec0, 0x0ec4,
+        0x0ec6, 0x0ec6,
+        0x0edc, 0x0edd,
+        0x0f00, 0x0f00,
+        0x0f40, 0x0f47,
+        0x0f49, 0x0f6c,
+        0x0f88, 0x0f8b,
+        0x1000, 0x102a,
+        0x103f, 0x103f,
+        0x1050, 0x1055,
+        0x105a, 0x105d,
+        0x1061, 0x1061,
+        0x1065, 0x1066,
+        0x106e, 0x1070,
+        0x1075, 0x1081,
+        0x108e, 0x108e,
+        0x10a0, 0x10c5,
+        0x10d0, 0x10fa,
+        0x10fc, 0x10fc,
+        0x1100, 0x1248,
+        0x124a, 0x124d,
+        0x1250, 0x1256,
+        0x1258, 0x1258,
+        0x125a, 0x125d,
+        0x1260, 0x1288,
+        0x128a, 0x128d,
+        0x1290, 0x12b0,
+        0x12b2, 0x12b5,
+        0x12b8, 0x12be,
+        0x12c0, 0x12c0,
+        0x12c2, 0x12c5,
+        0x12c8, 0x12d6,
+        0x12d8, 0x1310,
+        0x1312, 0x1315,
+        0x1318, 0x135a,
+        0x1380, 0x138f,
+        0x13a0, 0x13f4,
+        0x1401, 0x166c,
+        0x166f, 0x167f,
+        0x1681, 0x169a,
+        0x16a0, 0x16ea,
+        0x16ee, 0x16f0,
+        0x1700, 0x170c,
+        0x170e, 0x1711,
+        0x1720, 0x1731,
+        0x1740, 0x1751,
+        0x1760, 0x176c,
+        0x176e, 0x1770,
+        0x1780, 0x17b3,
+        0x17d7, 0x17d7,
+        0x17dc, 0x17dc,
+        0x1820, 0x1877,
+        0x1880, 0x18a8,
+        0x18aa, 0x18aa,
+        0x18b0, 0x18f5,
+        0x1900, 0x191c,
+        0x1950, 0x196d,
+        0x1970, 0x1974,
+        0x1980, 0x19ab,
+        0x19c1, 0x19c7,
+        0x1a00, 0x1a16,
+        0x1a20, 0x1a54,
+        0x1aa7, 0x1aa7,
+        0x1b05, 0x1b33,
+        0x1b45, 0x1b4b,
+        0x1b83, 0x1ba0,
+        0x1bae, 0x1baf,
+        0x1c00, 0x1c23,
+        0x1c4d, 0x1c4f,
+        0x1c5a, 0x1c7d,
+        0x1ce9, 0x1cec,
+        0x1cee, 0x1cf1,
+        0x1d00, 0x1dbf,
+        0x1e00, 0x1f15,
+        0x1f18, 0x1f1d,
+        0x1f20, 0x1f45,
+        0x1f48, 0x1f4d,
+        0x1f50, 0x1f57,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f7d,
+        0x1f80, 0x1fb4,
+        0x1fb6, 0x1fbc,
+        0x1fbe, 0x1fbe,
+        0x1fc2, 0x1fc4,
+        0x1fc6, 0x1fcc,
+        0x1fd0, 0x1fd3,
+        0x1fd6, 0x1fdb,
+        0x1fe0, 0x1fec,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ffc,
+        0x2071, 0x2071,
+        0x207f, 0x207f,
+        0x2090, 0x2094,
+        0x2102, 0x2102,
+        0x2107, 0x2107,
+        0x210a, 0x2113,
+        0x2115, 0x2115,
+        0x2118, 0x211d,
+        0x2124, 0x2124,
+        0x2126, 0x2126,
+        0x2128, 0x2128,
+        0x212a, 0x2139,
+        0x213c, 0x213f,
+        0x2145, 0x2149,
+        0x214e, 0x214e,
+        0x2160, 0x2188,
+        0x2c00, 0x2c2e,
+        0x2c30, 0x2c5e,
+        0x2c60, 0x2ce4,
+        0x2ceb, 0x2cee,
+        0x2d00, 0x2d25,
+        0x2d30, 0x2d65,
+        0x2d6f, 0x2d6f,
+        0x2d80, 0x2d96,
+        0x2da0, 0x2da6,
+        0x2da8, 0x2dae,
+        0x2db0, 0x2db6,
+        0x2db8, 0x2dbe,
+        0x2dc0, 0x2dc6,
+        0x2dc8, 0x2dce,
+        0x2dd0, 0x2dd6,
+        0x2dd8, 0x2dde,
+        0x3005, 0x3007,
+        0x3021, 0x3029,
+        0x3031, 0x3035,
+        0x3038, 0x303c,
+        0x3041, 0x3096,
+        0x309d, 0x309f,
+        0x30a1, 0x30fa,
+        0x30fc, 0x30ff,
+        0x3105, 0x312d,
+        0x3131, 0x318e,
+        0x31a0, 0x31b7,
+        0x31f0, 0x31ff,
+        0x3400, 0x4db5,
+        0x4e00, 0x9fcb,
+        0xa000, 0xa48c,
+        0xa4d0, 0xa4fd,
+        0xa500, 0xa60c,
+        0xa610, 0xa61f,
+        0xa62a, 0xa62b,
+        0xa640, 0xa65f,
+        0xa662, 0xa66e,
+        0xa67f, 0xa697,
+        0xa6a0, 0xa6ef,
+        0xa717, 0xa71f,
+        0xa722, 0xa788,
+        0xa78b, 0xa78c,
+        0xa7fb, 0xa801,
+        0xa803, 0xa805,
+        0xa807, 0xa80a,
+        0xa80c, 0xa822,
+        0xa840, 0xa873,
+        0xa882, 0xa8b3,
+        0xa8f2, 0xa8f7,
+        0xa8fb, 0xa8fb,
+        0xa90a, 0xa925,
+        0xa930, 0xa946,
+        0xa960, 0xa97c,
+        0xa984, 0xa9b2,
+        0xa9cf, 0xa9cf,
+        0xaa00, 0xaa28,
+        0xaa40, 0xaa42,
+        0xaa44, 0xaa4b,
+        0xaa60, 0xaa76,
+        0xaa7a, 0xaa7a,
+        0xaa80, 0xaaaf,
+        0xaab1, 0xaab1,
+        0xaab5, 0xaab6,
+        0xaab9, 0xaabd,
+        0xaac0, 0xaac0,
+        0xaac2, 0xaac2,
+        0xaadb, 0xaadd,
+        0xabc0, 0xabe2,
+        0xac00, 0xd7a3,
+        0xd7b0, 0xd7c6,
+        0xd7cb, 0xd7fb,
+        0xf900, 0xfa2d,
+        0xfa30, 0xfa6d,
+        0xfa70, 0xfad9,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xfb1d, 0xfb1d,
+        0xfb1f, 0xfb28,
+        0xfb2a, 0xfb36,
+        0xfb38, 0xfb3c,
+        0xfb3e, 0xfb3e,
+        0xfb40, 0xfb41,
+        0xfb43, 0xfb44,
+        0xfb46, 0xfbb1,
+        0xfbd3, 0xfc5d,
+        0xfc64, 0xfd3d,
+        0xfd50, 0xfd8f,
+        0xfd92, 0xfdc7,
+        0xfdf0, 0xfdf9,
+        0xfe71, 0xfe71,
+        0xfe73, 0xfe73,
+        0xfe77, 0xfe77,
+        0xfe79, 0xfe79,
+        0xfe7b, 0xfe7b,
+        0xfe7d, 0xfe7d,
+        0xfe7f, 0xfefc,
+        0xff21, 0xff3a,
+        0xff41, 0xff5a,
+        0xff66, 0xff9d,
+        0xffa0, 0xffbe,
+        0xffc2, 0xffc7,
+        0xffca, 0xffcf,
+        0xffd2, 0xffd7,
+        0xffda, 0xffdc,
+        0x10000, 0x1000b,
+        0x1000d, 0x10026,
+        0x10028, 0x1003a,
+        0x1003c, 0x1003d,
+        0x1003f, 0x1004d,
+        0x10050, 0x1005d,
+        0x10080, 0x100fa,
+        0x10140, 0x10174,
+        0x10280, 0x1029c,
+        0x102a0, 0x102d0,
+        0x10300, 0x1031e,
+        0x10330, 0x1034a,
+        0x10380, 0x1039d,
+        0x103a0, 0x103c3,
+        0x103c8, 0x103cf,
+        0x103d1, 0x103d5,
+        0x10400, 0x1049d,
+        0x10800, 0x10805,
+        0x10808, 0x10808,
+        0x1080a, 0x10835,
+        0x10837, 0x10838,
+        0x1083c, 0x1083c,
+        0x1083f, 0x10855,
+        0x10900, 0x10915,
+        0x10920, 0x10939,
+        0x10a00, 0x10a00,
+        0x10a10, 0x10a13,
+        0x10a15, 0x10a17,
+        0x10a19, 0x10a33,
+        0x10a60, 0x10a7c,
+        0x10b00, 0x10b35,
+        0x10b40, 0x10b55,
+        0x10b60, 0x10b72,
+        0x10c00, 0x10c48,
+        0x11083, 0x110af,
+        0x12000, 0x1236e,
+        0x12400, 0x12462,
+        0x13000, 0x1342e,
+        0x1d400, 0x1d454,
+        0x1d456, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d51e, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d552, 0x1d6a5,
+        0x1d6a8, 0x1d6c0,
+        0x1d6c2, 0x1d6da,
+        0x1d6dc, 0x1d6fa,
+        0x1d6fc, 0x1d714,
+        0x1d716, 0x1d734,
+        0x1d736, 0x1d74e,
+        0x1d750, 0x1d76e,
+        0x1d770, 0x1d788,
+        0x1d78a, 0x1d7a8,
+        0x1d7aa, 0x1d7c2,
+        0x1d7c4, 0x1d7cb,
+        0x20000, 0x2a6d6,
+        0x2a700, 0x2b734,
+        0x2f800, 0x2fa1d,
 }; /* CR_XID_Start */
 
 /* 'XID_Continue': Derived Property */
 static const OnigCodePoint CR_XID_Continue[] = {
-	513,
-	0x0030, 0x0039,
-	0x0041, 0x005a,
-	0x005f, 0x005f,
-	0x0061, 0x007a,
-	0x00aa, 0x00aa,
-	0x00b5, 0x00b5,
-	0x00b7, 0x00b7,
-	0x00ba, 0x00ba,
-	0x00c0, 0x00d6,
-	0x00d8, 0x00f6,
-	0x00f8, 0x02c1,
-	0x02c6, 0x02d1,
-	0x02e0, 0x02e4,
-	0x02ec, 0x02ec,
-	0x02ee, 0x02ee,
-	0x0300, 0x0374,
-	0x0376, 0x0377,
-	0x037b, 0x037d,
-	0x0386, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x03a1,
-	0x03a3, 0x03f5,
-	0x03f7, 0x0481,
-	0x0483, 0x0487,
-	0x048a, 0x0525,
-	0x0531, 0x0556,
-	0x0559, 0x0559,
-	0x0561, 0x0587,
-	0x0591, 0x05bd,
-	0x05bf, 0x05bf,
-	0x05c1, 0x05c2,
-	0x05c4, 0x05c5,
-	0x05c7, 0x05c7,
-	0x05d0, 0x05ea,
-	0x05f0, 0x05f2,
-	0x0610, 0x061a,
-	0x0621, 0x065e,
-	0x0660, 0x0669,
-	0x066e, 0x06d3,
-	0x06d5, 0x06dc,
-	0x06df, 0x06e8,
-	0x06ea, 0x06fc,
-	0x06ff, 0x06ff,
-	0x0710, 0x074a,
-	0x074d, 0x07b1,
-	0x07c0, 0x07f5,
-	0x07fa, 0x07fa,
-	0x0800, 0x082d,
-	0x0900, 0x0939,
-	0x093c, 0x094e,
-	0x0950, 0x0955,
-	0x0958, 0x0963,
-	0x0966, 0x096f,
-	0x0971, 0x0972,
-	0x0979, 0x097f,
-	0x0981, 0x0983,
-	0x0985, 0x098c,
-	0x098f, 0x0990,
-	0x0993, 0x09a8,
-	0x09aa, 0x09b0,
-	0x09b2, 0x09b2,
-	0x09b6, 0x09b9,
-	0x09bc, 0x09c4,
-	0x09c7, 0x09c8,
-	0x09cb, 0x09ce,
-	0x09d7, 0x09d7,
-	0x09dc, 0x09dd,
-	0x09df, 0x09e3,
-	0x09e6, 0x09f1,
-	0x0a01, 0x0a03,
-	0x0a05, 0x0a0a,
-	0x0a0f, 0x0a10,
-	0x0a13, 0x0a28,
-	0x0a2a, 0x0a30,
-	0x0a32, 0x0a33,
-	0x0a35, 0x0a36,
-	0x0a38, 0x0a39,
-	0x0a3c, 0x0a3c,
-	0x0a3e, 0x0a42,
-	0x0a47, 0x0a48,
-	0x0a4b, 0x0a4d,
-	0x0a51, 0x0a51,
-	0x0a59, 0x0a5c,
-	0x0a5e, 0x0a5e,
-	0x0a66, 0x0a75,
-	0x0a81, 0x0a83,
-	0x0a85, 0x0a8d,
-	0x0a8f, 0x0a91,
-	0x0a93, 0x0aa8,
-	0x0aaa, 0x0ab0,
-	0x0ab2, 0x0ab3,
-	0x0ab5, 0x0ab9,
-	0x0abc, 0x0ac5,
-	0x0ac7, 0x0ac9,
-	0x0acb, 0x0acd,
-	0x0ad0, 0x0ad0,
-	0x0ae0, 0x0ae3,
-	0x0ae6, 0x0aef,
-	0x0b01, 0x0b03,
-	0x0b05, 0x0b0c,
-	0x0b0f, 0x0b10,
-	0x0b13, 0x0b28,
-	0x0b2a, 0x0b30,
-	0x0b32, 0x0b33,
-	0x0b35, 0x0b39,
-	0x0b3c, 0x0b44,
-	0x0b47, 0x0b48,
-	0x0b4b, 0x0b4d,
-	0x0b56, 0x0b57,
-	0x0b5c, 0x0b5d,
-	0x0b5f, 0x0b63,
-	0x0b66, 0x0b6f,
-	0x0b71, 0x0b71,
-	0x0b82, 0x0b83,
-	0x0b85, 0x0b8a,
-	0x0b8e, 0x0b90,
-	0x0b92, 0x0b95,
-	0x0b99, 0x0b9a,
-	0x0b9c, 0x0b9c,
-	0x0b9e, 0x0b9f,
-	0x0ba3, 0x0ba4,
-	0x0ba8, 0x0baa,
-	0x0bae, 0x0bb9,
-	0x0bbe, 0x0bc2,
-	0x0bc6, 0x0bc8,
-	0x0bca, 0x0bcd,
-	0x0bd0, 0x0bd0,
-	0x0bd7, 0x0bd7,
-	0x0be6, 0x0bef,
-	0x0c01, 0x0c03,
-	0x0c05, 0x0c0c,
-	0x0c0e, 0x0c10,
-	0x0c12, 0x0c28,
-	0x0c2a, 0x0c33,
-	0x0c35, 0x0c39,
-	0x0c3d, 0x0c44,
-	0x0c46, 0x0c48,
-	0x0c4a, 0x0c4d,
-	0x0c55, 0x0c56,
-	0x0c58, 0x0c59,
-	0x0c60, 0x0c63,
-	0x0c66, 0x0c6f,
-	0x0c82, 0x0c83,
-	0x0c85, 0x0c8c,
-	0x0c8e, 0x0c90,
-	0x0c92, 0x0ca8,
-	0x0caa, 0x0cb3,
-	0x0cb5, 0x0cb9,
-	0x0cbc, 0x0cc4,
-	0x0cc6, 0x0cc8,
-	0x0cca, 0x0ccd,
-	0x0cd5, 0x0cd6,
-	0x0cde, 0x0cde,
-	0x0ce0, 0x0ce3,
-	0x0ce6, 0x0cef,
-	0x0d02, 0x0d03,
-	0x0d05, 0x0d0c,
-	0x0d0e, 0x0d10,
-	0x0d12, 0x0d28,
-	0x0d2a, 0x0d39,
-	0x0d3d, 0x0d44,
-	0x0d46, 0x0d48,
-	0x0d4a, 0x0d4d,
-	0x0d57, 0x0d57,
-	0x0d60, 0x0d63,
-	0x0d66, 0x0d6f,
-	0x0d7a, 0x0d7f,
-	0x0d82, 0x0d83,
-	0x0d85, 0x0d96,
-	0x0d9a, 0x0db1,
-	0x0db3, 0x0dbb,
-	0x0dbd, 0x0dbd,
-	0x0dc0, 0x0dc6,
-	0x0dca, 0x0dca,
-	0x0dcf, 0x0dd4,
-	0x0dd6, 0x0dd6,
-	0x0dd8, 0x0ddf,
-	0x0df2, 0x0df3,
-	0x0e01, 0x0e3a,
-	0x0e40, 0x0e4e,
-	0x0e50, 0x0e59,
-	0x0e81, 0x0e82,
-	0x0e84, 0x0e84,
-	0x0e87, 0x0e88,
-	0x0e8a, 0x0e8a,
-	0x0e8d, 0x0e8d,
-	0x0e94, 0x0e97,
-	0x0e99, 0x0e9f,
-	0x0ea1, 0x0ea3,
-	0x0ea5, 0x0ea5,
-	0x0ea7, 0x0ea7,
-	0x0eaa, 0x0eab,
-	0x0ead, 0x0eb9,
-	0x0ebb, 0x0ebd,
-	0x0ec0, 0x0ec4,
-	0x0ec6, 0x0ec6,
-	0x0ec8, 0x0ecd,
-	0x0ed0, 0x0ed9,
-	0x0edc, 0x0edd,
-	0x0f00, 0x0f00,
-	0x0f18, 0x0f19,
-	0x0f20, 0x0f29,
-	0x0f35, 0x0f35,
-	0x0f37, 0x0f37,
-	0x0f39, 0x0f39,
-	0x0f3e, 0x0f47,
-	0x0f49, 0x0f6c,
-	0x0f71, 0x0f84,
-	0x0f86, 0x0f8b,
-	0x0f90, 0x0f97,
-	0x0f99, 0x0fbc,
-	0x0fc6, 0x0fc6,
-	0x1000, 0x1049,
-	0x1050, 0x109d,
-	0x10a0, 0x10c5,
-	0x10d0, 0x10fa,
-	0x10fc, 0x10fc,
-	0x1100, 0x1248,
-	0x124a, 0x124d,
-	0x1250, 0x1256,
-	0x1258, 0x1258,
-	0x125a, 0x125d,
-	0x1260, 0x1288,
-	0x128a, 0x128d,
-	0x1290, 0x12b0,
-	0x12b2, 0x12b5,
-	0x12b8, 0x12be,
-	0x12c0, 0x12c0,
-	0x12c2, 0x12c5,
-	0x12c8, 0x12d6,
-	0x12d8, 0x1310,
-	0x1312, 0x1315,
-	0x1318, 0x135a,
-	0x135f, 0x135f,
-	0x1369, 0x1371,
-	0x1380, 0x138f,
-	0x13a0, 0x13f4,
-	0x1401, 0x166c,
-	0x166f, 0x167f,
-	0x1681, 0x169a,
-	0x16a0, 0x16ea,
-	0x16ee, 0x16f0,
-	0x1700, 0x170c,
-	0x170e, 0x1714,
-	0x1720, 0x1734,
-	0x1740, 0x1753,
-	0x1760, 0x176c,
-	0x176e, 0x1770,
-	0x1772, 0x1773,
-	0x1780, 0x17b3,
-	0x17b6, 0x17d3,
-	0x17d7, 0x17d7,
-	0x17dc, 0x17dd,
-	0x17e0, 0x17e9,
-	0x180b, 0x180d,
-	0x1810, 0x1819,
-	0x1820, 0x1877,
-	0x1880, 0x18aa,
-	0x18b0, 0x18f5,
-	0x1900, 0x191c,
-	0x1920, 0x192b,
-	0x1930, 0x193b,
-	0x1946, 0x196d,
-	0x1970, 0x1974,
-	0x1980, 0x19ab,
-	0x19b0, 0x19c9,
-	0x19d0, 0x19da,
-	0x1a00, 0x1a1b,
-	0x1a20, 0x1a5e,
-	0x1a60, 0x1a7c,
-	0x1a7f, 0x1a89,
-	0x1a90, 0x1a99,
-	0x1aa7, 0x1aa7,
-	0x1b00, 0x1b4b,
-	0x1b50, 0x1b59,
-	0x1b6b, 0x1b73,
-	0x1b80, 0x1baa,
-	0x1bae, 0x1bb9,
-	0x1c00, 0x1c37,
-	0x1c40, 0x1c49,
-	0x1c4d, 0x1c7d,
-	0x1cd0, 0x1cd2,
-	0x1cd4, 0x1cf2,
-	0x1d00, 0x1de6,
-	0x1dfd, 0x1f15,
-	0x1f18, 0x1f1d,
-	0x1f20, 0x1f45,
-	0x1f48, 0x1f4d,
-	0x1f50, 0x1f57,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f7d,
-	0x1f80, 0x1fb4,
-	0x1fb6, 0x1fbc,
-	0x1fbe, 0x1fbe,
-	0x1fc2, 0x1fc4,
-	0x1fc6, 0x1fcc,
-	0x1fd0, 0x1fd3,
-	0x1fd6, 0x1fdb,
-	0x1fe0, 0x1fec,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ffc,
-	0x203f, 0x2040,
-	0x2054, 0x2054,
-	0x2071, 0x2071,
-	0x207f, 0x207f,
-	0x2090, 0x2094,
-	0x20d0, 0x20dc,
-	0x20e1, 0x20e1,
-	0x20e5, 0x20f0,
-	0x2102, 0x2102,
-	0x2107, 0x2107,
-	0x210a, 0x2113,
-	0x2115, 0x2115,
-	0x2118, 0x211d,
-	0x2124, 0x2124,
-	0x2126, 0x2126,
-	0x2128, 0x2128,
-	0x212a, 0x2139,
-	0x213c, 0x213f,
-	0x2145, 0x2149,
-	0x214e, 0x214e,
-	0x2160, 0x2188,
-	0x2c00, 0x2c2e,
-	0x2c30, 0x2c5e,
-	0x2c60, 0x2ce4,
-	0x2ceb, 0x2cf1,
-	0x2d00, 0x2d25,
-	0x2d30, 0x2d65,
-	0x2d6f, 0x2d6f,
-	0x2d80, 0x2d96,
-	0x2da0, 0x2da6,
-	0x2da8, 0x2dae,
-	0x2db0, 0x2db6,
-	0x2db8, 0x2dbe,
-	0x2dc0, 0x2dc6,
-	0x2dc8, 0x2dce,
-	0x2dd0, 0x2dd6,
-	0x2dd8, 0x2dde,
-	0x2de0, 0x2dff,
-	0x3005, 0x3007,
-	0x3021, 0x302f,
-	0x3031, 0x3035,
-	0x3038, 0x303c,
-	0x3041, 0x3096,
-	0x3099, 0x309a,
-	0x309d, 0x309f,
-	0x30a1, 0x30fa,
-	0x30fc, 0x30ff,
-	0x3105, 0x312d,
-	0x3131, 0x318e,
-	0x31a0, 0x31b7,
-	0x31f0, 0x31ff,
-	0x3400, 0x4db5,
-	0x4e00, 0x9fcb,
-	0xa000, 0xa48c,
-	0xa4d0, 0xa4fd,
-	0xa500, 0xa60c,
-	0xa610, 0xa62b,
-	0xa640, 0xa65f,
-	0xa662, 0xa66f,
-	0xa67c, 0xa67d,
-	0xa67f, 0xa697,
-	0xa6a0, 0xa6f1,
-	0xa717, 0xa71f,
-	0xa722, 0xa788,
-	0xa78b, 0xa78c,
-	0xa7fb, 0xa827,
-	0xa840, 0xa873,
-	0xa880, 0xa8c4,
-	0xa8d0, 0xa8d9,
-	0xa8e0, 0xa8f7,
-	0xa8fb, 0xa8fb,
-	0xa900, 0xa92d,
-	0xa930, 0xa953,
-	0xa960, 0xa97c,
-	0xa980, 0xa9c0,
-	0xa9cf, 0xa9d9,
-	0xaa00, 0xaa36,
-	0xaa40, 0xaa4d,
-	0xaa50, 0xaa59,
-	0xaa60, 0xaa76,
-	0xaa7a, 0xaa7b,
-	0xaa80, 0xaac2,
-	0xaadb, 0xaadd,
-	0xabc0, 0xabea,
-	0xabec, 0xabed,
-	0xabf0, 0xabf9,
-	0xac00, 0xd7a3,
-	0xd7b0, 0xd7c6,
-	0xd7cb, 0xd7fb,
-	0xf900, 0xfa2d,
-	0xfa30, 0xfa6d,
-	0xfa70, 0xfad9,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xfb1d, 0xfb28,
-	0xfb2a, 0xfb36,
-	0xfb38, 0xfb3c,
-	0xfb3e, 0xfb3e,
-	0xfb40, 0xfb41,
-	0xfb43, 0xfb44,
-	0xfb46, 0xfbb1,
-	0xfbd3, 0xfc5d,
-	0xfc64, 0xfd3d,
-	0xfd50, 0xfd8f,
-	0xfd92, 0xfdc7,
-	0xfdf0, 0xfdf9,
-	0xfe00, 0xfe0f,
-	0xfe20, 0xfe26,
-	0xfe33, 0xfe34,
-	0xfe4d, 0xfe4f,
-	0xfe71, 0xfe71,
-	0xfe73, 0xfe73,
-	0xfe77, 0xfe77,
-	0xfe79, 0xfe79,
-	0xfe7b, 0xfe7b,
-	0xfe7d, 0xfe7d,
-	0xfe7f, 0xfefc,
-	0xff10, 0xff19,
-	0xff21, 0xff3a,
-	0xff3f, 0xff3f,
-	0xff41, 0xff5a,
-	0xff66, 0xffbe,
-	0xffc2, 0xffc7,
-	0xffca, 0xffcf,
-	0xffd2, 0xffd7,
-	0xffda, 0xffdc,
-	0x10000, 0x1000b,
-	0x1000d, 0x10026,
-	0x10028, 0x1003a,
-	0x1003c, 0x1003d,
-	0x1003f, 0x1004d,
-	0x10050, 0x1005d,
-	0x10080, 0x100fa,
-	0x10140, 0x10174,
-	0x101fd, 0x101fd,
-	0x10280, 0x1029c,
-	0x102a0, 0x102d0,
-	0x10300, 0x1031e,
-	0x10330, 0x1034a,
-	0x10380, 0x1039d,
-	0x103a0, 0x103c3,
-	0x103c8, 0x103cf,
-	0x103d1, 0x103d5,
-	0x10400, 0x1049d,
-	0x104a0, 0x104a9,
-	0x10800, 0x10805,
-	0x10808, 0x10808,
-	0x1080a, 0x10835,
-	0x10837, 0x10838,
-	0x1083c, 0x1083c,
-	0x1083f, 0x10855,
-	0x10900, 0x10915,
-	0x10920, 0x10939,
-	0x10a00, 0x10a03,
-	0x10a05, 0x10a06,
-	0x10a0c, 0x10a13,
-	0x10a15, 0x10a17,
-	0x10a19, 0x10a33,
-	0x10a38, 0x10a3a,
-	0x10a3f, 0x10a3f,
-	0x10a60, 0x10a7c,
-	0x10b00, 0x10b35,
-	0x10b40, 0x10b55,
-	0x10b60, 0x10b72,
-	0x10c00, 0x10c48,
-	0x11080, 0x110ba,
-	0x12000, 0x1236e,
-	0x12400, 0x12462,
-	0x13000, 0x1342e,
-	0x1d165, 0x1d169,
-	0x1d16d, 0x1d172,
-	0x1d17b, 0x1d182,
-	0x1d185, 0x1d18b,
-	0x1d1aa, 0x1d1ad,
-	0x1d242, 0x1d244,
-	0x1d400, 0x1d454,
-	0x1d456, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d51e, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d552, 0x1d6a5,
-	0x1d6a8, 0x1d6c0,
-	0x1d6c2, 0x1d6da,
-	0x1d6dc, 0x1d6fa,
-	0x1d6fc, 0x1d714,
-	0x1d716, 0x1d734,
-	0x1d736, 0x1d74e,
-	0x1d750, 0x1d76e,
-	0x1d770, 0x1d788,
-	0x1d78a, 0x1d7a8,
-	0x1d7aa, 0x1d7c2,
-	0x1d7c4, 0x1d7cb,
-	0x1d7ce, 0x1d7ff,
-	0x20000, 0x2a6d6,
-	0x2a700, 0x2b734,
-	0x2f800, 0x2fa1d,
-	0xe0100, 0xe01ef,
+        513,
+        0x0030, 0x0039,
+        0x0041, 0x005a,
+        0x005f, 0x005f,
+        0x0061, 0x007a,
+        0x00aa, 0x00aa,
+        0x00b5, 0x00b5,
+        0x00b7, 0x00b7,
+        0x00ba, 0x00ba,
+        0x00c0, 0x00d6,
+        0x00d8, 0x00f6,
+        0x00f8, 0x02c1,
+        0x02c6, 0x02d1,
+        0x02e0, 0x02e4,
+        0x02ec, 0x02ec,
+        0x02ee, 0x02ee,
+        0x0300, 0x0374,
+        0x0376, 0x0377,
+        0x037b, 0x037d,
+        0x0386, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x03a1,
+        0x03a3, 0x03f5,
+        0x03f7, 0x0481,
+        0x0483, 0x0487,
+        0x048a, 0x0525,
+        0x0531, 0x0556,
+        0x0559, 0x0559,
+        0x0561, 0x0587,
+        0x0591, 0x05bd,
+        0x05bf, 0x05bf,
+        0x05c1, 0x05c2,
+        0x05c4, 0x05c5,
+        0x05c7, 0x05c7,
+        0x05d0, 0x05ea,
+        0x05f0, 0x05f2,
+        0x0610, 0x061a,
+        0x0621, 0x065e,
+        0x0660, 0x0669,
+        0x066e, 0x06d3,
+        0x06d5, 0x06dc,
+        0x06df, 0x06e8,
+        0x06ea, 0x06fc,
+        0x06ff, 0x06ff,
+        0x0710, 0x074a,
+        0x074d, 0x07b1,
+        0x07c0, 0x07f5,
+        0x07fa, 0x07fa,
+        0x0800, 0x082d,
+        0x0900, 0x0939,
+        0x093c, 0x094e,
+        0x0950, 0x0955,
+        0x0958, 0x0963,
+        0x0966, 0x096f,
+        0x0971, 0x0972,
+        0x0979, 0x097f,
+        0x0981, 0x0983,
+        0x0985, 0x098c,
+        0x098f, 0x0990,
+        0x0993, 0x09a8,
+        0x09aa, 0x09b0,
+        0x09b2, 0x09b2,
+        0x09b6, 0x09b9,
+        0x09bc, 0x09c4,
+        0x09c7, 0x09c8,
+        0x09cb, 0x09ce,
+        0x09d7, 0x09d7,
+        0x09dc, 0x09dd,
+        0x09df, 0x09e3,
+        0x09e6, 0x09f1,
+        0x0a01, 0x0a03,
+        0x0a05, 0x0a0a,
+        0x0a0f, 0x0a10,
+        0x0a13, 0x0a28,
+        0x0a2a, 0x0a30,
+        0x0a32, 0x0a33,
+        0x0a35, 0x0a36,
+        0x0a38, 0x0a39,
+        0x0a3c, 0x0a3c,
+        0x0a3e, 0x0a42,
+        0x0a47, 0x0a48,
+        0x0a4b, 0x0a4d,
+        0x0a51, 0x0a51,
+        0x0a59, 0x0a5c,
+        0x0a5e, 0x0a5e,
+        0x0a66, 0x0a75,
+        0x0a81, 0x0a83,
+        0x0a85, 0x0a8d,
+        0x0a8f, 0x0a91,
+        0x0a93, 0x0aa8,
+        0x0aaa, 0x0ab0,
+        0x0ab2, 0x0ab3,
+        0x0ab5, 0x0ab9,
+        0x0abc, 0x0ac5,
+        0x0ac7, 0x0ac9,
+        0x0acb, 0x0acd,
+        0x0ad0, 0x0ad0,
+        0x0ae0, 0x0ae3,
+        0x0ae6, 0x0aef,
+        0x0b01, 0x0b03,
+        0x0b05, 0x0b0c,
+        0x0b0f, 0x0b10,
+        0x0b13, 0x0b28,
+        0x0b2a, 0x0b30,
+        0x0b32, 0x0b33,
+        0x0b35, 0x0b39,
+        0x0b3c, 0x0b44,
+        0x0b47, 0x0b48,
+        0x0b4b, 0x0b4d,
+        0x0b56, 0x0b57,
+        0x0b5c, 0x0b5d,
+        0x0b5f, 0x0b63,
+        0x0b66, 0x0b6f,
+        0x0b71, 0x0b71,
+        0x0b82, 0x0b83,
+        0x0b85, 0x0b8a,
+        0x0b8e, 0x0b90,
+        0x0b92, 0x0b95,
+        0x0b99, 0x0b9a,
+        0x0b9c, 0x0b9c,
+        0x0b9e, 0x0b9f,
+        0x0ba3, 0x0ba4,
+        0x0ba8, 0x0baa,
+        0x0bae, 0x0bb9,
+        0x0bbe, 0x0bc2,
+        0x0bc6, 0x0bc8,
+        0x0bca, 0x0bcd,
+        0x0bd0, 0x0bd0,
+        0x0bd7, 0x0bd7,
+        0x0be6, 0x0bef,
+        0x0c01, 0x0c03,
+        0x0c05, 0x0c0c,
+        0x0c0e, 0x0c10,
+        0x0c12, 0x0c28,
+        0x0c2a, 0x0c33,
+        0x0c35, 0x0c39,
+        0x0c3d, 0x0c44,
+        0x0c46, 0x0c48,
+        0x0c4a, 0x0c4d,
+        0x0c55, 0x0c56,
+        0x0c58, 0x0c59,
+        0x0c60, 0x0c63,
+        0x0c66, 0x0c6f,
+        0x0c82, 0x0c83,
+        0x0c85, 0x0c8c,
+        0x0c8e, 0x0c90,
+        0x0c92, 0x0ca8,
+        0x0caa, 0x0cb3,
+        0x0cb5, 0x0cb9,
+        0x0cbc, 0x0cc4,
+        0x0cc6, 0x0cc8,
+        0x0cca, 0x0ccd,
+        0x0cd5, 0x0cd6,
+        0x0cde, 0x0cde,
+        0x0ce0, 0x0ce3,
+        0x0ce6, 0x0cef,
+        0x0d02, 0x0d03,
+        0x0d05, 0x0d0c,
+        0x0d0e, 0x0d10,
+        0x0d12, 0x0d28,
+        0x0d2a, 0x0d39,
+        0x0d3d, 0x0d44,
+        0x0d46, 0x0d48,
+        0x0d4a, 0x0d4d,
+        0x0d57, 0x0d57,
+        0x0d60, 0x0d63,
+        0x0d66, 0x0d6f,
+        0x0d7a, 0x0d7f,
+        0x0d82, 0x0d83,
+        0x0d85, 0x0d96,
+        0x0d9a, 0x0db1,
+        0x0db3, 0x0dbb,
+        0x0dbd, 0x0dbd,
+        0x0dc0, 0x0dc6,
+        0x0dca, 0x0dca,
+        0x0dcf, 0x0dd4,
+        0x0dd6, 0x0dd6,
+        0x0dd8, 0x0ddf,
+        0x0df2, 0x0df3,
+        0x0e01, 0x0e3a,
+        0x0e40, 0x0e4e,
+        0x0e50, 0x0e59,
+        0x0e81, 0x0e82,
+        0x0e84, 0x0e84,
+        0x0e87, 0x0e88,
+        0x0e8a, 0x0e8a,
+        0x0e8d, 0x0e8d,
+        0x0e94, 0x0e97,
+        0x0e99, 0x0e9f,
+        0x0ea1, 0x0ea3,
+        0x0ea5, 0x0ea5,
+        0x0ea7, 0x0ea7,
+        0x0eaa, 0x0eab,
+        0x0ead, 0x0eb9,
+        0x0ebb, 0x0ebd,
+        0x0ec0, 0x0ec4,
+        0x0ec6, 0x0ec6,
+        0x0ec8, 0x0ecd,
+        0x0ed0, 0x0ed9,
+        0x0edc, 0x0edd,
+        0x0f00, 0x0f00,
+        0x0f18, 0x0f19,
+        0x0f20, 0x0f29,
+        0x0f35, 0x0f35,
+        0x0f37, 0x0f37,
+        0x0f39, 0x0f39,
+        0x0f3e, 0x0f47,
+        0x0f49, 0x0f6c,
+        0x0f71, 0x0f84,
+        0x0f86, 0x0f8b,
+        0x0f90, 0x0f97,
+        0x0f99, 0x0fbc,
+        0x0fc6, 0x0fc6,
+        0x1000, 0x1049,
+        0x1050, 0x109d,
+        0x10a0, 0x10c5,
+        0x10d0, 0x10fa,
+        0x10fc, 0x10fc,
+        0x1100, 0x1248,
+        0x124a, 0x124d,
+        0x1250, 0x1256,
+        0x1258, 0x1258,
+        0x125a, 0x125d,
+        0x1260, 0x1288,
+        0x128a, 0x128d,
+        0x1290, 0x12b0,
+        0x12b2, 0x12b5,
+        0x12b8, 0x12be,
+        0x12c0, 0x12c0,
+        0x12c2, 0x12c5,
+        0x12c8, 0x12d6,
+        0x12d8, 0x1310,
+        0x1312, 0x1315,
+        0x1318, 0x135a,
+        0x135f, 0x135f,
+        0x1369, 0x1371,
+        0x1380, 0x138f,
+        0x13a0, 0x13f4,
+        0x1401, 0x166c,
+        0x166f, 0x167f,
+        0x1681, 0x169a,
+        0x16a0, 0x16ea,
+        0x16ee, 0x16f0,
+        0x1700, 0x170c,
+        0x170e, 0x1714,
+        0x1720, 0x1734,
+        0x1740, 0x1753,
+        0x1760, 0x176c,
+        0x176e, 0x1770,
+        0x1772, 0x1773,
+        0x1780, 0x17b3,
+        0x17b6, 0x17d3,
+        0x17d7, 0x17d7,
+        0x17dc, 0x17dd,
+        0x17e0, 0x17e9,
+        0x180b, 0x180d,
+        0x1810, 0x1819,
+        0x1820, 0x1877,
+        0x1880, 0x18aa,
+        0x18b0, 0x18f5,
+        0x1900, 0x191c,
+        0x1920, 0x192b,
+        0x1930, 0x193b,
+        0x1946, 0x196d,
+        0x1970, 0x1974,
+        0x1980, 0x19ab,
+        0x19b0, 0x19c9,
+        0x19d0, 0x19da,
+        0x1a00, 0x1a1b,
+        0x1a20, 0x1a5e,
+        0x1a60, 0x1a7c,
+        0x1a7f, 0x1a89,
+        0x1a90, 0x1a99,
+        0x1aa7, 0x1aa7,
+        0x1b00, 0x1b4b,
+        0x1b50, 0x1b59,
+        0x1b6b, 0x1b73,
+        0x1b80, 0x1baa,
+        0x1bae, 0x1bb9,
+        0x1c00, 0x1c37,
+        0x1c40, 0x1c49,
+        0x1c4d, 0x1c7d,
+        0x1cd0, 0x1cd2,
+        0x1cd4, 0x1cf2,
+        0x1d00, 0x1de6,
+        0x1dfd, 0x1f15,
+        0x1f18, 0x1f1d,
+        0x1f20, 0x1f45,
+        0x1f48, 0x1f4d,
+        0x1f50, 0x1f57,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f7d,
+        0x1f80, 0x1fb4,
+        0x1fb6, 0x1fbc,
+        0x1fbe, 0x1fbe,
+        0x1fc2, 0x1fc4,
+        0x1fc6, 0x1fcc,
+        0x1fd0, 0x1fd3,
+        0x1fd6, 0x1fdb,
+        0x1fe0, 0x1fec,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ffc,
+        0x203f, 0x2040,
+        0x2054, 0x2054,
+        0x2071, 0x2071,
+        0x207f, 0x207f,
+        0x2090, 0x2094,
+        0x20d0, 0x20dc,
+        0x20e1, 0x20e1,
+        0x20e5, 0x20f0,
+        0x2102, 0x2102,
+        0x2107, 0x2107,
+        0x210a, 0x2113,
+        0x2115, 0x2115,
+        0x2118, 0x211d,
+        0x2124, 0x2124,
+        0x2126, 0x2126,
+        0x2128, 0x2128,
+        0x212a, 0x2139,
+        0x213c, 0x213f,
+        0x2145, 0x2149,
+        0x214e, 0x214e,
+        0x2160, 0x2188,
+        0x2c00, 0x2c2e,
+        0x2c30, 0x2c5e,
+        0x2c60, 0x2ce4,
+        0x2ceb, 0x2cf1,
+        0x2d00, 0x2d25,
+        0x2d30, 0x2d65,
+        0x2d6f, 0x2d6f,
+        0x2d80, 0x2d96,
+        0x2da0, 0x2da6,
+        0x2da8, 0x2dae,
+        0x2db0, 0x2db6,
+        0x2db8, 0x2dbe,
+        0x2dc0, 0x2dc6,
+        0x2dc8, 0x2dce,
+        0x2dd0, 0x2dd6,
+        0x2dd8, 0x2dde,
+        0x2de0, 0x2dff,
+        0x3005, 0x3007,
+        0x3021, 0x302f,
+        0x3031, 0x3035,
+        0x3038, 0x303c,
+        0x3041, 0x3096,
+        0x3099, 0x309a,
+        0x309d, 0x309f,
+        0x30a1, 0x30fa,
+        0x30fc, 0x30ff,
+        0x3105, 0x312d,
+        0x3131, 0x318e,
+        0x31a0, 0x31b7,
+        0x31f0, 0x31ff,
+        0x3400, 0x4db5,
+        0x4e00, 0x9fcb,
+        0xa000, 0xa48c,
+        0xa4d0, 0xa4fd,
+        0xa500, 0xa60c,
+        0xa610, 0xa62b,
+        0xa640, 0xa65f,
+        0xa662, 0xa66f,
+        0xa67c, 0xa67d,
+        0xa67f, 0xa697,
+        0xa6a0, 0xa6f1,
+        0xa717, 0xa71f,
+        0xa722, 0xa788,
+        0xa78b, 0xa78c,
+        0xa7fb, 0xa827,
+        0xa840, 0xa873,
+        0xa880, 0xa8c4,
+        0xa8d0, 0xa8d9,
+        0xa8e0, 0xa8f7,
+        0xa8fb, 0xa8fb,
+        0xa900, 0xa92d,
+        0xa930, 0xa953,
+        0xa960, 0xa97c,
+        0xa980, 0xa9c0,
+        0xa9cf, 0xa9d9,
+        0xaa00, 0xaa36,
+        0xaa40, 0xaa4d,
+        0xaa50, 0xaa59,
+        0xaa60, 0xaa76,
+        0xaa7a, 0xaa7b,
+        0xaa80, 0xaac2,
+        0xaadb, 0xaadd,
+        0xabc0, 0xabea,
+        0xabec, 0xabed,
+        0xabf0, 0xabf9,
+        0xac00, 0xd7a3,
+        0xd7b0, 0xd7c6,
+        0xd7cb, 0xd7fb,
+        0xf900, 0xfa2d,
+        0xfa30, 0xfa6d,
+        0xfa70, 0xfad9,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xfb1d, 0xfb28,
+        0xfb2a, 0xfb36,
+        0xfb38, 0xfb3c,
+        0xfb3e, 0xfb3e,
+        0xfb40, 0xfb41,
+        0xfb43, 0xfb44,
+        0xfb46, 0xfbb1,
+        0xfbd3, 0xfc5d,
+        0xfc64, 0xfd3d,
+        0xfd50, 0xfd8f,
+        0xfd92, 0xfdc7,
+        0xfdf0, 0xfdf9,
+        0xfe00, 0xfe0f,
+        0xfe20, 0xfe26,
+        0xfe33, 0xfe34,
+        0xfe4d, 0xfe4f,
+        0xfe71, 0xfe71,
+        0xfe73, 0xfe73,
+        0xfe77, 0xfe77,
+        0xfe79, 0xfe79,
+        0xfe7b, 0xfe7b,
+        0xfe7d, 0xfe7d,
+        0xfe7f, 0xfefc,
+        0xff10, 0xff19,
+        0xff21, 0xff3a,
+        0xff3f, 0xff3f,
+        0xff41, 0xff5a,
+        0xff66, 0xffbe,
+        0xffc2, 0xffc7,
+        0xffca, 0xffcf,
+        0xffd2, 0xffd7,
+        0xffda, 0xffdc,
+        0x10000, 0x1000b,
+        0x1000d, 0x10026,
+        0x10028, 0x1003a,
+        0x1003c, 0x1003d,
+        0x1003f, 0x1004d,
+        0x10050, 0x1005d,
+        0x10080, 0x100fa,
+        0x10140, 0x10174,
+        0x101fd, 0x101fd,
+        0x10280, 0x1029c,
+        0x102a0, 0x102d0,
+        0x10300, 0x1031e,
+        0x10330, 0x1034a,
+        0x10380, 0x1039d,
+        0x103a0, 0x103c3,
+        0x103c8, 0x103cf,
+        0x103d1, 0x103d5,
+        0x10400, 0x1049d,
+        0x104a0, 0x104a9,
+        0x10800, 0x10805,
+        0x10808, 0x10808,
+        0x1080a, 0x10835,
+        0x10837, 0x10838,
+        0x1083c, 0x1083c,
+        0x1083f, 0x10855,
+        0x10900, 0x10915,
+        0x10920, 0x10939,
+        0x10a00, 0x10a03,
+        0x10a05, 0x10a06,
+        0x10a0c, 0x10a13,
+        0x10a15, 0x10a17,
+        0x10a19, 0x10a33,
+        0x10a38, 0x10a3a,
+        0x10a3f, 0x10a3f,
+        0x10a60, 0x10a7c,
+        0x10b00, 0x10b35,
+        0x10b40, 0x10b55,
+        0x10b60, 0x10b72,
+        0x10c00, 0x10c48,
+        0x11080, 0x110ba,
+        0x12000, 0x1236e,
+        0x12400, 0x12462,
+        0x13000, 0x1342e,
+        0x1d165, 0x1d169,
+        0x1d16d, 0x1d172,
+        0x1d17b, 0x1d182,
+        0x1d185, 0x1d18b,
+        0x1d1aa, 0x1d1ad,
+        0x1d242, 0x1d244,
+        0x1d400, 0x1d454,
+        0x1d456, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d51e, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d552, 0x1d6a5,
+        0x1d6a8, 0x1d6c0,
+        0x1d6c2, 0x1d6da,
+        0x1d6dc, 0x1d6fa,
+        0x1d6fc, 0x1d714,
+        0x1d716, 0x1d734,
+        0x1d736, 0x1d74e,
+        0x1d750, 0x1d76e,
+        0x1d770, 0x1d788,
+        0x1d78a, 0x1d7a8,
+        0x1d7aa, 0x1d7c2,
+        0x1d7c4, 0x1d7cb,
+        0x1d7ce, 0x1d7ff,
+        0x20000, 0x2a6d6,
+        0x2a700, 0x2b734,
+        0x2f800, 0x2fa1d,
+        0xe0100, 0xe01ef,
 }; /* CR_XID_Continue */
 
 /* 'Default_Ignorable_Code_Point': Derived Property */
 static const OnigCodePoint CR_Default_Ignorable_Code_Point[] = {
-	15,
-	0x00ad, 0x00ad,
-	0x034f, 0x034f,
-	0x115f, 0x1160,
-	0x17b4, 0x17b5,
-	0x180b, 0x180d,
-	0x200b, 0x200f,
-	0x202a, 0x202e,
-	0x2060, 0x206f,
-	0x3164, 0x3164,
-	0xfe00, 0xfe0f,
-	0xfeff, 0xfeff,
-	0xffa0, 0xffa0,
-	0xfff0, 0xfff8,
-	0x1d173, 0x1d17a,
-	0xe0000, 0xe0fff,
+        15,
+        0x00ad, 0x00ad,
+        0x034f, 0x034f,
+        0x115f, 0x1160,
+        0x17b4, 0x17b5,
+        0x180b, 0x180d,
+        0x200b, 0x200f,
+        0x202a, 0x202e,
+        0x2060, 0x206f,
+        0x3164, 0x3164,
+        0xfe00, 0xfe0f,
+        0xfeff, 0xfeff,
+        0xffa0, 0xffa0,
+        0xfff0, 0xfff8,
+        0x1d173, 0x1d17a,
+        0xe0000, 0xe0fff,
 }; /* CR_Default_Ignorable_Code_Point */
 
 /* 'Grapheme_Extend': Derived Property */
 static const OnigCodePoint CR_Grapheme_Extend[] = {
-	206,
-	0x0300, 0x036f,
-	0x0483, 0x0489,
-	0x0591, 0x05bd,
-	0x05bf, 0x05bf,
-	0x05c1, 0x05c2,
-	0x05c4, 0x05c5,
-	0x05c7, 0x05c7,
-	0x0610, 0x061a,
-	0x064b, 0x065e,
-	0x0670, 0x0670,
-	0x06d6, 0x06dc,
-	0x06de, 0x06e4,
-	0x06e7, 0x06e8,
-	0x06ea, 0x06ed,
-	0x0711, 0x0711,
-	0x0730, 0x074a,
-	0x07a6, 0x07b0,
-	0x07eb, 0x07f3,
-	0x0816, 0x0819,
-	0x081b, 0x0823,
-	0x0825, 0x0827,
-	0x0829, 0x082d,
-	0x0900, 0x0902,
-	0x093c, 0x093c,
-	0x0941, 0x0948,
-	0x094d, 0x094d,
-	0x0951, 0x0955,
-	0x0962, 0x0963,
-	0x0981, 0x0981,
-	0x09bc, 0x09bc,
-	0x09be, 0x09be,
-	0x09c1, 0x09c4,
-	0x09cd, 0x09cd,
-	0x09d7, 0x09d7,
-	0x09e2, 0x09e3,
-	0x0a01, 0x0a02,
-	0x0a3c, 0x0a3c,
-	0x0a41, 0x0a42,
-	0x0a47, 0x0a48,
-	0x0a4b, 0x0a4d,
-	0x0a51, 0x0a51,
-	0x0a70, 0x0a71,
-	0x0a75, 0x0a75,
-	0x0a81, 0x0a82,
-	0x0abc, 0x0abc,
-	0x0ac1, 0x0ac5,
-	0x0ac7, 0x0ac8,
-	0x0acd, 0x0acd,
-	0x0ae2, 0x0ae3,
-	0x0b01, 0x0b01,
-	0x0b3c, 0x0b3c,
-	0x0b3e, 0x0b3f,
-	0x0b41, 0x0b44,
-	0x0b4d, 0x0b4d,
-	0x0b56, 0x0b57,
-	0x0b62, 0x0b63,
-	0x0b82, 0x0b82,
-	0x0bbe, 0x0bbe,
-	0x0bc0, 0x0bc0,
-	0x0bcd, 0x0bcd,
-	0x0bd7, 0x0bd7,
-	0x0c3e, 0x0c40,
-	0x0c46, 0x0c48,
-	0x0c4a, 0x0c4d,
-	0x0c55, 0x0c56,
-	0x0c62, 0x0c63,
-	0x0cbc, 0x0cbc,
-	0x0cbf, 0x0cbf,
-	0x0cc2, 0x0cc2,
-	0x0cc6, 0x0cc6,
-	0x0ccc, 0x0ccd,
-	0x0cd5, 0x0cd6,
-	0x0ce2, 0x0ce3,
-	0x0d3e, 0x0d3e,
-	0x0d41, 0x0d44,
-	0x0d4d, 0x0d4d,
-	0x0d57, 0x0d57,
-	0x0d62, 0x0d63,
-	0x0dca, 0x0dca,
-	0x0dcf, 0x0dcf,
-	0x0dd2, 0x0dd4,
-	0x0dd6, 0x0dd6,
-	0x0ddf, 0x0ddf,
-	0x0e31, 0x0e31,
-	0x0e34, 0x0e3a,
-	0x0e47, 0x0e4e,
-	0x0eb1, 0x0eb1,
-	0x0eb4, 0x0eb9,
-	0x0ebb, 0x0ebc,
-	0x0ec8, 0x0ecd,
-	0x0f18, 0x0f19,
-	0x0f35, 0x0f35,
-	0x0f37, 0x0f37,
-	0x0f39, 0x0f39,
-	0x0f71, 0x0f7e,
-	0x0f80, 0x0f84,
-	0x0f86, 0x0f87,
-	0x0f90, 0x0f97,
-	0x0f99, 0x0fbc,
-	0x0fc6, 0x0fc6,
-	0x102d, 0x1030,
-	0x1032, 0x1037,
-	0x1039, 0x103a,
-	0x103d, 0x103e,
-	0x1058, 0x1059,
-	0x105e, 0x1060,
-	0x1071, 0x1074,
-	0x1082, 0x1082,
-	0x1085, 0x1086,
-	0x108d, 0x108d,
-	0x109d, 0x109d,
-	0x135f, 0x135f,
-	0x1712, 0x1714,
-	0x1732, 0x1734,
-	0x1752, 0x1753,
-	0x1772, 0x1773,
-	0x17b7, 0x17bd,
-	0x17c6, 0x17c6,
-	0x17c9, 0x17d3,
-	0x17dd, 0x17dd,
-	0x180b, 0x180d,
-	0x18a9, 0x18a9,
-	0x1920, 0x1922,
-	0x1927, 0x1928,
-	0x1932, 0x1932,
-	0x1939, 0x193b,
-	0x1a17, 0x1a18,
-	0x1a56, 0x1a56,
-	0x1a58, 0x1a5e,
-	0x1a60, 0x1a60,
-	0x1a62, 0x1a62,
-	0x1a65, 0x1a6c,
-	0x1a73, 0x1a7c,
-	0x1a7f, 0x1a7f,
-	0x1b00, 0x1b03,
-	0x1b34, 0x1b34,
-	0x1b36, 0x1b3a,
-	0x1b3c, 0x1b3c,
-	0x1b42, 0x1b42,
-	0x1b6b, 0x1b73,
-	0x1b80, 0x1b81,
-	0x1ba2, 0x1ba5,
-	0x1ba8, 0x1ba9,
-	0x1c2c, 0x1c33,
-	0x1c36, 0x1c37,
-	0x1cd0, 0x1cd2,
-	0x1cd4, 0x1ce0,
-	0x1ce2, 0x1ce8,
-	0x1ced, 0x1ced,
-	0x1dc0, 0x1de6,
-	0x1dfd, 0x1dff,
-	0x200c, 0x200d,
-	0x20d0, 0x20f0,
-	0x2cef, 0x2cf1,
-	0x2de0, 0x2dff,
-	0x302a, 0x302f,
-	0x3099, 0x309a,
-	0xa66f, 0xa672,
-	0xa67c, 0xa67d,
-	0xa6f0, 0xa6f1,
-	0xa802, 0xa802,
-	0xa806, 0xa806,
-	0xa80b, 0xa80b,
-	0xa825, 0xa826,
-	0xa8c4, 0xa8c4,
-	0xa8e0, 0xa8f1,
-	0xa926, 0xa92d,
-	0xa947, 0xa951,
-	0xa980, 0xa982,
-	0xa9b3, 0xa9b3,
-	0xa9b6, 0xa9b9,
-	0xa9bc, 0xa9bc,
-	0xaa29, 0xaa2e,
-	0xaa31, 0xaa32,
-	0xaa35, 0xaa36,
-	0xaa43, 0xaa43,
-	0xaa4c, 0xaa4c,
-	0xaab0, 0xaab0,
-	0xaab2, 0xaab4,
-	0xaab7, 0xaab8,
-	0xaabe, 0xaabf,
-	0xaac1, 0xaac1,
-	0xabe5, 0xabe5,
-	0xabe8, 0xabe8,
-	0xabed, 0xabed,
-	0xfb1e, 0xfb1e,
-	0xfe00, 0xfe0f,
-	0xfe20, 0xfe26,
-	0xff9e, 0xff9f,
-	0x101fd, 0x101fd,
-	0x10a01, 0x10a03,
-	0x10a05, 0x10a06,
-	0x10a0c, 0x10a0f,
-	0x10a38, 0x10a3a,
-	0x10a3f, 0x10a3f,
-	0x11080, 0x11081,
-	0x110b3, 0x110b6,
-	0x110b9, 0x110ba,
-	0x1d165, 0x1d165,
-	0x1d167, 0x1d169,
-	0x1d16e, 0x1d172,
-	0x1d17b, 0x1d182,
-	0x1d185, 0x1d18b,
-	0x1d1aa, 0x1d1ad,
-	0x1d242, 0x1d244,
-	0xe0100, 0xe01ef,
+        206,
+        0x0300, 0x036f,
+        0x0483, 0x0489,
+        0x0591, 0x05bd,
+        0x05bf, 0x05bf,
+        0x05c1, 0x05c2,
+        0x05c4, 0x05c5,
+        0x05c7, 0x05c7,
+        0x0610, 0x061a,
+        0x064b, 0x065e,
+        0x0670, 0x0670,
+        0x06d6, 0x06dc,
+        0x06de, 0x06e4,
+        0x06e7, 0x06e8,
+        0x06ea, 0x06ed,
+        0x0711, 0x0711,
+        0x0730, 0x074a,
+        0x07a6, 0x07b0,
+        0x07eb, 0x07f3,
+        0x0816, 0x0819,
+        0x081b, 0x0823,
+        0x0825, 0x0827,
+        0x0829, 0x082d,
+        0x0900, 0x0902,
+        0x093c, 0x093c,
+        0x0941, 0x0948,
+        0x094d, 0x094d,
+        0x0951, 0x0955,
+        0x0962, 0x0963,
+        0x0981, 0x0981,
+        0x09bc, 0x09bc,
+        0x09be, 0x09be,
+        0x09c1, 0x09c4,
+        0x09cd, 0x09cd,
+        0x09d7, 0x09d7,
+        0x09e2, 0x09e3,
+        0x0a01, 0x0a02,
+        0x0a3c, 0x0a3c,
+        0x0a41, 0x0a42,
+        0x0a47, 0x0a48,
+        0x0a4b, 0x0a4d,
+        0x0a51, 0x0a51,
+        0x0a70, 0x0a71,
+        0x0a75, 0x0a75,
+        0x0a81, 0x0a82,
+        0x0abc, 0x0abc,
+        0x0ac1, 0x0ac5,
+        0x0ac7, 0x0ac8,
+        0x0acd, 0x0acd,
+        0x0ae2, 0x0ae3,
+        0x0b01, 0x0b01,
+        0x0b3c, 0x0b3c,
+        0x0b3e, 0x0b3f,
+        0x0b41, 0x0b44,
+        0x0b4d, 0x0b4d,
+        0x0b56, 0x0b57,
+        0x0b62, 0x0b63,
+        0x0b82, 0x0b82,
+        0x0bbe, 0x0bbe,
+        0x0bc0, 0x0bc0,
+        0x0bcd, 0x0bcd,
+        0x0bd7, 0x0bd7,
+        0x0c3e, 0x0c40,
+        0x0c46, 0x0c48,
+        0x0c4a, 0x0c4d,
+        0x0c55, 0x0c56,
+        0x0c62, 0x0c63,
+        0x0cbc, 0x0cbc,
+        0x0cbf, 0x0cbf,
+        0x0cc2, 0x0cc2,
+        0x0cc6, 0x0cc6,
+        0x0ccc, 0x0ccd,
+        0x0cd5, 0x0cd6,
+        0x0ce2, 0x0ce3,
+        0x0d3e, 0x0d3e,
+        0x0d41, 0x0d44,
+        0x0d4d, 0x0d4d,
+        0x0d57, 0x0d57,
+        0x0d62, 0x0d63,
+        0x0dca, 0x0dca,
+        0x0dcf, 0x0dcf,
+        0x0dd2, 0x0dd4,
+        0x0dd6, 0x0dd6,
+        0x0ddf, 0x0ddf,
+        0x0e31, 0x0e31,
+        0x0e34, 0x0e3a,
+        0x0e47, 0x0e4e,
+        0x0eb1, 0x0eb1,
+        0x0eb4, 0x0eb9,
+        0x0ebb, 0x0ebc,
+        0x0ec8, 0x0ecd,
+        0x0f18, 0x0f19,
+        0x0f35, 0x0f35,
+        0x0f37, 0x0f37,
+        0x0f39, 0x0f39,
+        0x0f71, 0x0f7e,
+        0x0f80, 0x0f84,
+        0x0f86, 0x0f87,
+        0x0f90, 0x0f97,
+        0x0f99, 0x0fbc,
+        0x0fc6, 0x0fc6,
+        0x102d, 0x1030,
+        0x1032, 0x1037,
+        0x1039, 0x103a,
+        0x103d, 0x103e,
+        0x1058, 0x1059,
+        0x105e, 0x1060,
+        0x1071, 0x1074,
+        0x1082, 0x1082,
+        0x1085, 0x1086,
+        0x108d, 0x108d,
+        0x109d, 0x109d,
+        0x135f, 0x135f,
+        0x1712, 0x1714,
+        0x1732, 0x1734,
+        0x1752, 0x1753,
+        0x1772, 0x1773,
+        0x17b7, 0x17bd,
+        0x17c6, 0x17c6,
+        0x17c9, 0x17d3,
+        0x17dd, 0x17dd,
+        0x180b, 0x180d,
+        0x18a9, 0x18a9,
+        0x1920, 0x1922,
+        0x1927, 0x1928,
+        0x1932, 0x1932,
+        0x1939, 0x193b,
+        0x1a17, 0x1a18,
+        0x1a56, 0x1a56,
+        0x1a58, 0x1a5e,
+        0x1a60, 0x1a60,
+        0x1a62, 0x1a62,
+        0x1a65, 0x1a6c,
+        0x1a73, 0x1a7c,
+        0x1a7f, 0x1a7f,
+        0x1b00, 0x1b03,
+        0x1b34, 0x1b34,
+        0x1b36, 0x1b3a,
+        0x1b3c, 0x1b3c,
+        0x1b42, 0x1b42,
+        0x1b6b, 0x1b73,
+        0x1b80, 0x1b81,
+        0x1ba2, 0x1ba5,
+        0x1ba8, 0x1ba9,
+        0x1c2c, 0x1c33,
+        0x1c36, 0x1c37,
+        0x1cd0, 0x1cd2,
+        0x1cd4, 0x1ce0,
+        0x1ce2, 0x1ce8,
+        0x1ced, 0x1ced,
+        0x1dc0, 0x1de6,
+        0x1dfd, 0x1dff,
+        0x200c, 0x200d,
+        0x20d0, 0x20f0,
+        0x2cef, 0x2cf1,
+        0x2de0, 0x2dff,
+        0x302a, 0x302f,
+        0x3099, 0x309a,
+        0xa66f, 0xa672,
+        0xa67c, 0xa67d,
+        0xa6f0, 0xa6f1,
+        0xa802, 0xa802,
+        0xa806, 0xa806,
+        0xa80b, 0xa80b,
+        0xa825, 0xa826,
+        0xa8c4, 0xa8c4,
+        0xa8e0, 0xa8f1,
+        0xa926, 0xa92d,
+        0xa947, 0xa951,
+        0xa980, 0xa982,
+        0xa9b3, 0xa9b3,
+        0xa9b6, 0xa9b9,
+        0xa9bc, 0xa9bc,
+        0xaa29, 0xaa2e,
+        0xaa31, 0xaa32,
+        0xaa35, 0xaa36,
+        0xaa43, 0xaa43,
+        0xaa4c, 0xaa4c,
+        0xaab0, 0xaab0,
+        0xaab2, 0xaab4,
+        0xaab7, 0xaab8,
+        0xaabe, 0xaabf,
+        0xaac1, 0xaac1,
+        0xabe5, 0xabe5,
+        0xabe8, 0xabe8,
+        0xabed, 0xabed,
+        0xfb1e, 0xfb1e,
+        0xfe00, 0xfe0f,
+        0xfe20, 0xfe26,
+        0xff9e, 0xff9f,
+        0x101fd, 0x101fd,
+        0x10a01, 0x10a03,
+        0x10a05, 0x10a06,
+        0x10a0c, 0x10a0f,
+        0x10a38, 0x10a3a,
+        0x10a3f, 0x10a3f,
+        0x11080, 0x11081,
+        0x110b3, 0x110b6,
+        0x110b9, 0x110ba,
+        0x1d165, 0x1d165,
+        0x1d167, 0x1d169,
+        0x1d16e, 0x1d172,
+        0x1d17b, 0x1d182,
+        0x1d185, 0x1d18b,
+        0x1d1aa, 0x1d1ad,
+        0x1d242, 0x1d244,
+        0xe0100, 0xe01ef,
 }; /* CR_Grapheme_Extend */
 
 /* 'Grapheme_Base': Derived Property */
 static const OnigCodePoint CR_Grapheme_Base[] = {
-	567,
-	0x0020, 0x007e,
-	0x00a0, 0x00ac,
-	0x00ae, 0x02ff,
-	0x0370, 0x0377,
-	0x037a, 0x037e,
-	0x0384, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x03a1,
-	0x03a3, 0x0482,
-	0x048a, 0x0525,
-	0x0531, 0x0556,
-	0x0559, 0x055f,
-	0x0561, 0x0587,
-	0x0589, 0x058a,
-	0x05be, 0x05be,
-	0x05c0, 0x05c0,
-	0x05c3, 0x05c3,
-	0x05c6, 0x05c6,
-	0x05d0, 0x05ea,
-	0x05f0, 0x05f4,
-	0x0606, 0x060f,
-	0x061b, 0x061b,
-	0x061e, 0x061f,
-	0x0621, 0x064a,
-	0x0660, 0x066f,
-	0x0671, 0x06d5,
-	0x06e5, 0x06e6,
-	0x06e9, 0x06e9,
-	0x06ee, 0x070d,
-	0x0710, 0x0710,
-	0x0712, 0x072f,
-	0x074d, 0x07a5,
-	0x07b1, 0x07b1,
-	0x07c0, 0x07ea,
-	0x07f4, 0x07fa,
-	0x0800, 0x0815,
-	0x081a, 0x081a,
-	0x0824, 0x0824,
-	0x0828, 0x0828,
-	0x0830, 0x083e,
-	0x0903, 0x0939,
-	0x093d, 0x0940,
-	0x0949, 0x094c,
-	0x094e, 0x094e,
-	0x0950, 0x0950,
-	0x0958, 0x0961,
-	0x0964, 0x0972,
-	0x0979, 0x097f,
-	0x0982, 0x0983,
-	0x0985, 0x098c,
-	0x098f, 0x0990,
-	0x0993, 0x09a8,
-	0x09aa, 0x09b0,
-	0x09b2, 0x09b2,
-	0x09b6, 0x09b9,
-	0x09bd, 0x09bd,
-	0x09bf, 0x09c0,
-	0x09c7, 0x09c8,
-	0x09cb, 0x09cc,
-	0x09ce, 0x09ce,
-	0x09dc, 0x09dd,
-	0x09df, 0x09e1,
-	0x09e6, 0x09fb,
-	0x0a03, 0x0a03,
-	0x0a05, 0x0a0a,
-	0x0a0f, 0x0a10,
-	0x0a13, 0x0a28,
-	0x0a2a, 0x0a30,
-	0x0a32, 0x0a33,
-	0x0a35, 0x0a36,
-	0x0a38, 0x0a39,
-	0x0a3e, 0x0a40,
-	0x0a59, 0x0a5c,
-	0x0a5e, 0x0a5e,
-	0x0a66, 0x0a6f,
-	0x0a72, 0x0a74,
-	0x0a83, 0x0a83,
-	0x0a85, 0x0a8d,
-	0x0a8f, 0x0a91,
-	0x0a93, 0x0aa8,
-	0x0aaa, 0x0ab0,
-	0x0ab2, 0x0ab3,
-	0x0ab5, 0x0ab9,
-	0x0abd, 0x0ac0,
-	0x0ac9, 0x0ac9,
-	0x0acb, 0x0acc,
-	0x0ad0, 0x0ad0,
-	0x0ae0, 0x0ae1,
-	0x0ae6, 0x0aef,
-	0x0af1, 0x0af1,
-	0x0b02, 0x0b03,
-	0x0b05, 0x0b0c,
-	0x0b0f, 0x0b10,
-	0x0b13, 0x0b28,
-	0x0b2a, 0x0b30,
-	0x0b32, 0x0b33,
-	0x0b35, 0x0b39,
-	0x0b3d, 0x0b3d,
-	0x0b40, 0x0b40,
-	0x0b47, 0x0b48,
-	0x0b4b, 0x0b4c,
-	0x0b5c, 0x0b5d,
-	0x0b5f, 0x0b61,
-	0x0b66, 0x0b71,
-	0x0b83, 0x0b83,
-	0x0b85, 0x0b8a,
-	0x0b8e, 0x0b90,
-	0x0b92, 0x0b95,
-	0x0b99, 0x0b9a,
-	0x0b9c, 0x0b9c,
-	0x0b9e, 0x0b9f,
-	0x0ba3, 0x0ba4,
-	0x0ba8, 0x0baa,
-	0x0bae, 0x0bb9,
-	0x0bbf, 0x0bbf,
-	0x0bc1, 0x0bc2,
-	0x0bc6, 0x0bc8,
-	0x0bca, 0x0bcc,
-	0x0bd0, 0x0bd0,
-	0x0be6, 0x0bfa,
-	0x0c01, 0x0c03,
-	0x0c05, 0x0c0c,
-	0x0c0e, 0x0c10,
-	0x0c12, 0x0c28,
-	0x0c2a, 0x0c33,
-	0x0c35, 0x0c39,
-	0x0c3d, 0x0c3d,
-	0x0c41, 0x0c44,
-	0x0c58, 0x0c59,
-	0x0c60, 0x0c61,
-	0x0c66, 0x0c6f,
-	0x0c78, 0x0c7f,
-	0x0c82, 0x0c83,
-	0x0c85, 0x0c8c,
-	0x0c8e, 0x0c90,
-	0x0c92, 0x0ca8,
-	0x0caa, 0x0cb3,
-	0x0cb5, 0x0cb9,
-	0x0cbd, 0x0cbe,
-	0x0cc0, 0x0cc1,
-	0x0cc3, 0x0cc4,
-	0x0cc7, 0x0cc8,
-	0x0cca, 0x0ccb,
-	0x0cde, 0x0cde,
-	0x0ce0, 0x0ce1,
-	0x0ce6, 0x0cef,
-	0x0cf1, 0x0cf2,
-	0x0d02, 0x0d03,
-	0x0d05, 0x0d0c,
-	0x0d0e, 0x0d10,
-	0x0d12, 0x0d28,
-	0x0d2a, 0x0d39,
-	0x0d3d, 0x0d3d,
-	0x0d3f, 0x0d40,
-	0x0d46, 0x0d48,
-	0x0d4a, 0x0d4c,
-	0x0d60, 0x0d61,
-	0x0d66, 0x0d75,
-	0x0d79, 0x0d7f,
-	0x0d82, 0x0d83,
-	0x0d85, 0x0d96,
-	0x0d9a, 0x0db1,
-	0x0db3, 0x0dbb,
-	0x0dbd, 0x0dbd,
-	0x0dc0, 0x0dc6,
-	0x0dd0, 0x0dd1,
-	0x0dd8, 0x0dde,
-	0x0df2, 0x0df4,
-	0x0e01, 0x0e30,
-	0x0e32, 0x0e33,
-	0x0e3f, 0x0e46,
-	0x0e4f, 0x0e5b,
-	0x0e81, 0x0e82,
-	0x0e84, 0x0e84,
-	0x0e87, 0x0e88,
-	0x0e8a, 0x0e8a,
-	0x0e8d, 0x0e8d,
-	0x0e94, 0x0e97,
-	0x0e99, 0x0e9f,
-	0x0ea1, 0x0ea3,
-	0x0ea5, 0x0ea5,
-	0x0ea7, 0x0ea7,
-	0x0eaa, 0x0eab,
-	0x0ead, 0x0eb0,
-	0x0eb2, 0x0eb3,
-	0x0ebd, 0x0ebd,
-	0x0ec0, 0x0ec4,
-	0x0ec6, 0x0ec6,
-	0x0ed0, 0x0ed9,
-	0x0edc, 0x0edd,
-	0x0f00, 0x0f17,
-	0x0f1a, 0x0f34,
-	0x0f36, 0x0f36,
-	0x0f38, 0x0f38,
-	0x0f3a, 0x0f47,
-	0x0f49, 0x0f6c,
-	0x0f7f, 0x0f7f,
-	0x0f85, 0x0f85,
-	0x0f88, 0x0f8b,
-	0x0fbe, 0x0fc5,
-	0x0fc7, 0x0fcc,
-	0x0fce, 0x0fd8,
-	0x1000, 0x102c,
-	0x1031, 0x1031,
-	0x1038, 0x1038,
-	0x103b, 0x103c,
-	0x103f, 0x1057,
-	0x105a, 0x105d,
-	0x1061, 0x1070,
-	0x1075, 0x1081,
-	0x1083, 0x1084,
-	0x1087, 0x108c,
-	0x108e, 0x109c,
-	0x109e, 0x10c5,
-	0x10d0, 0x10fc,
-	0x1100, 0x1248,
-	0x124a, 0x124d,
-	0x1250, 0x1256,
-	0x1258, 0x1258,
-	0x125a, 0x125d,
-	0x1260, 0x1288,
-	0x128a, 0x128d,
-	0x1290, 0x12b0,
-	0x12b2, 0x12b5,
-	0x12b8, 0x12be,
-	0x12c0, 0x12c0,
-	0x12c2, 0x12c5,
-	0x12c8, 0x12d6,
-	0x12d8, 0x1310,
-	0x1312, 0x1315,
-	0x1318, 0x135a,
-	0x1360, 0x137c,
-	0x1380, 0x1399,
-	0x13a0, 0x13f4,
-	0x1400, 0x169c,
-	0x16a0, 0x16f0,
-	0x1700, 0x170c,
-	0x170e, 0x1711,
-	0x1720, 0x1731,
-	0x1735, 0x1736,
-	0x1740, 0x1751,
-	0x1760, 0x176c,
-	0x176e, 0x1770,
-	0x1780, 0x17b3,
-	0x17b6, 0x17b6,
-	0x17be, 0x17c5,
-	0x17c7, 0x17c8,
-	0x17d4, 0x17dc,
-	0x17e0, 0x17e9,
-	0x17f0, 0x17f9,
-	0x1800, 0x180a,
-	0x180e, 0x180e,
-	0x1810, 0x1819,
-	0x1820, 0x1877,
-	0x1880, 0x18a8,
-	0x18aa, 0x18aa,
-	0x18b0, 0x18f5,
-	0x1900, 0x191c,
-	0x1923, 0x1926,
-	0x1929, 0x192b,
-	0x1930, 0x1931,
-	0x1933, 0x1938,
-	0x1940, 0x1940,
-	0x1944, 0x196d,
-	0x1970, 0x1974,
-	0x1980, 0x19ab,
-	0x19b0, 0x19c9,
-	0x19d0, 0x19da,
-	0x19de, 0x1a16,
-	0x1a19, 0x1a1b,
-	0x1a1e, 0x1a55,
-	0x1a57, 0x1a57,
-	0x1a61, 0x1a61,
-	0x1a63, 0x1a64,
-	0x1a6d, 0x1a72,
-	0x1a80, 0x1a89,
-	0x1a90, 0x1a99,
-	0x1aa0, 0x1aad,
-	0x1b04, 0x1b33,
-	0x1b35, 0x1b35,
-	0x1b3b, 0x1b3b,
-	0x1b3d, 0x1b41,
-	0x1b43, 0x1b4b,
-	0x1b50, 0x1b6a,
-	0x1b74, 0x1b7c,
-	0x1b82, 0x1ba1,
-	0x1ba6, 0x1ba7,
-	0x1baa, 0x1baa,
-	0x1bae, 0x1bb9,
-	0x1c00, 0x1c2b,
-	0x1c34, 0x1c35,
-	0x1c3b, 0x1c49,
-	0x1c4d, 0x1c7f,
-	0x1cd3, 0x1cd3,
-	0x1ce1, 0x1ce1,
-	0x1ce9, 0x1cec,
-	0x1cee, 0x1cf2,
-	0x1d00, 0x1dbf,
-	0x1e00, 0x1f15,
-	0x1f18, 0x1f1d,
-	0x1f20, 0x1f45,
-	0x1f48, 0x1f4d,
-	0x1f50, 0x1f57,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f7d,
-	0x1f80, 0x1fb4,
-	0x1fb6, 0x1fc4,
-	0x1fc6, 0x1fd3,
-	0x1fd6, 0x1fdb,
-	0x1fdd, 0x1fef,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ffe,
-	0x2000, 0x200a,
-	0x2010, 0x2027,
-	0x202f, 0x205f,
-	0x2070, 0x2071,
-	0x2074, 0x208e,
-	0x2090, 0x2094,
-	0x20a0, 0x20b8,
-	0x2100, 0x2189,
-	0x2190, 0x23e8,
-	0x2400, 0x2426,
-	0x2440, 0x244a,
-	0x2460, 0x26cd,
-	0x26cf, 0x26e1,
-	0x26e3, 0x26e3,
-	0x26e8, 0x26ff,
-	0x2701, 0x2704,
-	0x2706, 0x2709,
-	0x270c, 0x2727,
-	0x2729, 0x274b,
-	0x274d, 0x274d,
-	0x274f, 0x2752,
-	0x2756, 0x275e,
-	0x2761, 0x2794,
-	0x2798, 0x27af,
-	0x27b1, 0x27be,
-	0x27c0, 0x27ca,
-	0x27cc, 0x27cc,
-	0x27d0, 0x2b4c,
-	0x2b50, 0x2b59,
-	0x2c00, 0x2c2e,
-	0x2c30, 0x2c5e,
-	0x2c60, 0x2cee,
-	0x2cf9, 0x2d25,
-	0x2d30, 0x2d65,
-	0x2d6f, 0x2d6f,
-	0x2d80, 0x2d96,
-	0x2da0, 0x2da6,
-	0x2da8, 0x2dae,
-	0x2db0, 0x2db6,
-	0x2db8, 0x2dbe,
-	0x2dc0, 0x2dc6,
-	0x2dc8, 0x2dce,
-	0x2dd0, 0x2dd6,
-	0x2dd8, 0x2dde,
-	0x2e00, 0x2e31,
-	0x2e80, 0x2e99,
-	0x2e9b, 0x2ef3,
-	0x2f00, 0x2fd5,
-	0x2ff0, 0x2ffb,
-	0x3000, 0x3029,
-	0x3030, 0x303f,
-	0x3041, 0x3096,
-	0x309b, 0x30ff,
-	0x3105, 0x312d,
-	0x3131, 0x318e,
-	0x3190, 0x31b7,
-	0x31c0, 0x31e3,
-	0x31f0, 0x321e,
-	0x3220, 0x32fe,
-	0x3300, 0x4db5,
-	0x4dc0, 0x9fcb,
-	0xa000, 0xa48c,
-	0xa490, 0xa4c6,
-	0xa4d0, 0xa62b,
-	0xa640, 0xa65f,
-	0xa662, 0xa66e,
-	0xa673, 0xa673,
-	0xa67e, 0xa697,
-	0xa6a0, 0xa6ef,
-	0xa6f2, 0xa6f7,
-	0xa700, 0xa78c,
-	0xa7fb, 0xa801,
-	0xa803, 0xa805,
-	0xa807, 0xa80a,
-	0xa80c, 0xa824,
-	0xa827, 0xa82b,
-	0xa830, 0xa839,
-	0xa840, 0xa877,
-	0xa880, 0xa8c3,
-	0xa8ce, 0xa8d9,
-	0xa8f2, 0xa8fb,
-	0xa900, 0xa925,
-	0xa92e, 0xa946,
-	0xa952, 0xa953,
-	0xa95f, 0xa97c,
-	0xa983, 0xa9b2,
-	0xa9b4, 0xa9b5,
-	0xa9ba, 0xa9bb,
-	0xa9bd, 0xa9cd,
-	0xa9cf, 0xa9d9,
-	0xa9de, 0xa9df,
-	0xaa00, 0xaa28,
-	0xaa2f, 0xaa30,
-	0xaa33, 0xaa34,
-	0xaa40, 0xaa42,
-	0xaa44, 0xaa4b,
-	0xaa4d, 0xaa4d,
-	0xaa50, 0xaa59,
-	0xaa5c, 0xaa7b,
-	0xaa80, 0xaaaf,
-	0xaab1, 0xaab1,
-	0xaab5, 0xaab6,
-	0xaab9, 0xaabd,
-	0xaac0, 0xaac0,
-	0xaac2, 0xaac2,
-	0xaadb, 0xaadf,
-	0xabc0, 0xabe4,
-	0xabe6, 0xabe7,
-	0xabe9, 0xabec,
-	0xabf0, 0xabf9,
-	0xac00, 0xd7a3,
-	0xd7b0, 0xd7c6,
-	0xd7cb, 0xd7fb,
-	0xf900, 0xfa2d,
-	0xfa30, 0xfa6d,
-	0xfa70, 0xfad9,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xfb1d, 0xfb1d,
-	0xfb1f, 0xfb36,
-	0xfb38, 0xfb3c,
-	0xfb3e, 0xfb3e,
-	0xfb40, 0xfb41,
-	0xfb43, 0xfb44,
-	0xfb46, 0xfbb1,
-	0xfbd3, 0xfd3f,
-	0xfd50, 0xfd8f,
-	0xfd92, 0xfdc7,
-	0xfdf0, 0xfdfd,
-	0xfe10, 0xfe19,
-	0xfe30, 0xfe52,
-	0xfe54, 0xfe66,
-	0xfe68, 0xfe6b,
-	0xfe70, 0xfe74,
-	0xfe76, 0xfefc,
-	0xff01, 0xff9d,
-	0xffa0, 0xffbe,
-	0xffc2, 0xffc7,
-	0xffca, 0xffcf,
-	0xffd2, 0xffd7,
-	0xffda, 0xffdc,
-	0xffe0, 0xffe6,
-	0xffe8, 0xffee,
-	0xfffc, 0xfffd,
-	0x10000, 0x1000b,
-	0x1000d, 0x10026,
-	0x10028, 0x1003a,
-	0x1003c, 0x1003d,
-	0x1003f, 0x1004d,
-	0x10050, 0x1005d,
-	0x10080, 0x100fa,
-	0x10100, 0x10102,
-	0x10107, 0x10133,
-	0x10137, 0x1018a,
-	0x10190, 0x1019b,
-	0x101d0, 0x101fc,
-	0x10280, 0x1029c,
-	0x102a0, 0x102d0,
-	0x10300, 0x1031e,
-	0x10320, 0x10323,
-	0x10330, 0x1034a,
-	0x10380, 0x1039d,
-	0x1039f, 0x103c3,
-	0x103c8, 0x103d5,
-	0x10400, 0x1049d,
-	0x104a0, 0x104a9,
-	0x10800, 0x10805,
-	0x10808, 0x10808,
-	0x1080a, 0x10835,
-	0x10837, 0x10838,
-	0x1083c, 0x1083c,
-	0x1083f, 0x10855,
-	0x10857, 0x1085f,
-	0x10900, 0x1091b,
-	0x1091f, 0x10939,
-	0x1093f, 0x1093f,
-	0x10a00, 0x10a00,
-	0x10a10, 0x10a13,
-	0x10a15, 0x10a17,
-	0x10a19, 0x10a33,
-	0x10a40, 0x10a47,
-	0x10a50, 0x10a58,
-	0x10a60, 0x10a7f,
-	0x10b00, 0x10b35,
-	0x10b39, 0x10b55,
-	0x10b58, 0x10b72,
-	0x10b78, 0x10b7f,
-	0x10c00, 0x10c48,
-	0x10e60, 0x10e7e,
-	0x11082, 0x110b2,
-	0x110b7, 0x110b8,
-	0x110bb, 0x110bc,
-	0x110be, 0x110c1,
-	0x12000, 0x1236e,
-	0x12400, 0x12462,
-	0x12470, 0x12473,
-	0x13000, 0x1342e,
-	0x1d000, 0x1d0f5,
-	0x1d100, 0x1d126,
-	0x1d129, 0x1d164,
-	0x1d166, 0x1d166,
-	0x1d16a, 0x1d16d,
-	0x1d183, 0x1d184,
-	0x1d18c, 0x1d1a9,
-	0x1d1ae, 0x1d1dd,
-	0x1d200, 0x1d241,
-	0x1d245, 0x1d245,
-	0x1d300, 0x1d356,
-	0x1d360, 0x1d371,
-	0x1d400, 0x1d454,
-	0x1d456, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d51e, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d552, 0x1d6a5,
-	0x1d6a8, 0x1d7cb,
-	0x1d7ce, 0x1d7ff,
-	0x1f000, 0x1f02b,
-	0x1f030, 0x1f093,
-	0x1f100, 0x1f10a,
-	0x1f110, 0x1f12e,
-	0x1f131, 0x1f131,
-	0x1f13d, 0x1f13d,
-	0x1f13f, 0x1f13f,
-	0x1f142, 0x1f142,
-	0x1f146, 0x1f146,
-	0x1f14a, 0x1f14e,
-	0x1f157, 0x1f157,
-	0x1f15f, 0x1f15f,
-	0x1f179, 0x1f179,
-	0x1f17b, 0x1f17c,
-	0x1f17f, 0x1f17f,
-	0x1f18a, 0x1f18d,
-	0x1f190, 0x1f190,
-	0x1f200, 0x1f200,
-	0x1f210, 0x1f231,
-	0x1f240, 0x1f248,
-	0x20000, 0x2a6d6,
-	0x2a700, 0x2b734,
-	0x2f800, 0x2fa1d,
+        567,
+        0x0020, 0x007e,
+        0x00a0, 0x00ac,
+        0x00ae, 0x02ff,
+        0x0370, 0x0377,
+        0x037a, 0x037e,
+        0x0384, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x03a1,
+        0x03a3, 0x0482,
+        0x048a, 0x0525,
+        0x0531, 0x0556,
+        0x0559, 0x055f,
+        0x0561, 0x0587,
+        0x0589, 0x058a,
+        0x05be, 0x05be,
+        0x05c0, 0x05c0,
+        0x05c3, 0x05c3,
+        0x05c6, 0x05c6,
+        0x05d0, 0x05ea,
+        0x05f0, 0x05f4,
+        0x0606, 0x060f,
+        0x061b, 0x061b,
+        0x061e, 0x061f,
+        0x0621, 0x064a,
+        0x0660, 0x066f,
+        0x0671, 0x06d5,
+        0x06e5, 0x06e6,
+        0x06e9, 0x06e9,
+        0x06ee, 0x070d,
+        0x0710, 0x0710,
+        0x0712, 0x072f,
+        0x074d, 0x07a5,
+        0x07b1, 0x07b1,
+        0x07c0, 0x07ea,
+        0x07f4, 0x07fa,
+        0x0800, 0x0815,
+        0x081a, 0x081a,
+        0x0824, 0x0824,
+        0x0828, 0x0828,
+        0x0830, 0x083e,
+        0x0903, 0x0939,
+        0x093d, 0x0940,
+        0x0949, 0x094c,
+        0x094e, 0x094e,
+        0x0950, 0x0950,
+        0x0958, 0x0961,
+        0x0964, 0x0972,
+        0x0979, 0x097f,
+        0x0982, 0x0983,
+        0x0985, 0x098c,
+        0x098f, 0x0990,
+        0x0993, 0x09a8,
+        0x09aa, 0x09b0,
+        0x09b2, 0x09b2,
+        0x09b6, 0x09b9,
+        0x09bd, 0x09bd,
+        0x09bf, 0x09c0,
+        0x09c7, 0x09c8,
+        0x09cb, 0x09cc,
+        0x09ce, 0x09ce,
+        0x09dc, 0x09dd,
+        0x09df, 0x09e1,
+        0x09e6, 0x09fb,
+        0x0a03, 0x0a03,
+        0x0a05, 0x0a0a,
+        0x0a0f, 0x0a10,
+        0x0a13, 0x0a28,
+        0x0a2a, 0x0a30,
+        0x0a32, 0x0a33,
+        0x0a35, 0x0a36,
+        0x0a38, 0x0a39,
+        0x0a3e, 0x0a40,
+        0x0a59, 0x0a5c,
+        0x0a5e, 0x0a5e,
+        0x0a66, 0x0a6f,
+        0x0a72, 0x0a74,
+        0x0a83, 0x0a83,
+        0x0a85, 0x0a8d,
+        0x0a8f, 0x0a91,
+        0x0a93, 0x0aa8,
+        0x0aaa, 0x0ab0,
+        0x0ab2, 0x0ab3,
+        0x0ab5, 0x0ab9,
+        0x0abd, 0x0ac0,
+        0x0ac9, 0x0ac9,
+        0x0acb, 0x0acc,
+        0x0ad0, 0x0ad0,
+        0x0ae0, 0x0ae1,
+        0x0ae6, 0x0aef,
+        0x0af1, 0x0af1,
+        0x0b02, 0x0b03,
+        0x0b05, 0x0b0c,
+        0x0b0f, 0x0b10,
+        0x0b13, 0x0b28,
+        0x0b2a, 0x0b30,
+        0x0b32, 0x0b33,
+        0x0b35, 0x0b39,
+        0x0b3d, 0x0b3d,
+        0x0b40, 0x0b40,
+        0x0b47, 0x0b48,
+        0x0b4b, 0x0b4c,
+        0x0b5c, 0x0b5d,
+        0x0b5f, 0x0b61,
+        0x0b66, 0x0b71,
+        0x0b83, 0x0b83,
+        0x0b85, 0x0b8a,
+        0x0b8e, 0x0b90,
+        0x0b92, 0x0b95,
+        0x0b99, 0x0b9a,
+        0x0b9c, 0x0b9c,
+        0x0b9e, 0x0b9f,
+        0x0ba3, 0x0ba4,
+        0x0ba8, 0x0baa,
+        0x0bae, 0x0bb9,
+        0x0bbf, 0x0bbf,
+        0x0bc1, 0x0bc2,
+        0x0bc6, 0x0bc8,
+        0x0bca, 0x0bcc,
+        0x0bd0, 0x0bd0,
+        0x0be6, 0x0bfa,
+        0x0c01, 0x0c03,
+        0x0c05, 0x0c0c,
+        0x0c0e, 0x0c10,
+        0x0c12, 0x0c28,
+        0x0c2a, 0x0c33,
+        0x0c35, 0x0c39,
+        0x0c3d, 0x0c3d,
+        0x0c41, 0x0c44,
+        0x0c58, 0x0c59,
+        0x0c60, 0x0c61,
+        0x0c66, 0x0c6f,
+        0x0c78, 0x0c7f,
+        0x0c82, 0x0c83,
+        0x0c85, 0x0c8c,
+        0x0c8e, 0x0c90,
+        0x0c92, 0x0ca8,
+        0x0caa, 0x0cb3,
+        0x0cb5, 0x0cb9,
+        0x0cbd, 0x0cbe,
+        0x0cc0, 0x0cc1,
+        0x0cc3, 0x0cc4,
+        0x0cc7, 0x0cc8,
+        0x0cca, 0x0ccb,
+        0x0cde, 0x0cde,
+        0x0ce0, 0x0ce1,
+        0x0ce6, 0x0cef,
+        0x0cf1, 0x0cf2,
+        0x0d02, 0x0d03,
+        0x0d05, 0x0d0c,
+        0x0d0e, 0x0d10,
+        0x0d12, 0x0d28,
+        0x0d2a, 0x0d39,
+        0x0d3d, 0x0d3d,
+        0x0d3f, 0x0d40,
+        0x0d46, 0x0d48,
+        0x0d4a, 0x0d4c,
+        0x0d60, 0x0d61,
+        0x0d66, 0x0d75,
+        0x0d79, 0x0d7f,
+        0x0d82, 0x0d83,
+        0x0d85, 0x0d96,
+        0x0d9a, 0x0db1,
+        0x0db3, 0x0dbb,
+        0x0dbd, 0x0dbd,
+        0x0dc0, 0x0dc6,
+        0x0dd0, 0x0dd1,
+        0x0dd8, 0x0dde,
+        0x0df2, 0x0df4,
+        0x0e01, 0x0e30,
+        0x0e32, 0x0e33,
+        0x0e3f, 0x0e46,
+        0x0e4f, 0x0e5b,
+        0x0e81, 0x0e82,
+        0x0e84, 0x0e84,
+        0x0e87, 0x0e88,
+        0x0e8a, 0x0e8a,
+        0x0e8d, 0x0e8d,
+        0x0e94, 0x0e97,
+        0x0e99, 0x0e9f,
+        0x0ea1, 0x0ea3,
+        0x0ea5, 0x0ea5,
+        0x0ea7, 0x0ea7,
+        0x0eaa, 0x0eab,
+        0x0ead, 0x0eb0,
+        0x0eb2, 0x0eb3,
+        0x0ebd, 0x0ebd,
+        0x0ec0, 0x0ec4,
+        0x0ec6, 0x0ec6,
+        0x0ed0, 0x0ed9,
+        0x0edc, 0x0edd,
+        0x0f00, 0x0f17,
+        0x0f1a, 0x0f34,
+        0x0f36, 0x0f36,
+        0x0f38, 0x0f38,
+        0x0f3a, 0x0f47,
+        0x0f49, 0x0f6c,
+        0x0f7f, 0x0f7f,
+        0x0f85, 0x0f85,
+        0x0f88, 0x0f8b,
+        0x0fbe, 0x0fc5,
+        0x0fc7, 0x0fcc,
+        0x0fce, 0x0fd8,
+        0x1000, 0x102c,
+        0x1031, 0x1031,
+        0x1038, 0x1038,
+        0x103b, 0x103c,
+        0x103f, 0x1057,
+        0x105a, 0x105d,
+        0x1061, 0x1070,
+        0x1075, 0x1081,
+        0x1083, 0x1084,
+        0x1087, 0x108c,
+        0x108e, 0x109c,
+        0x109e, 0x10c5,
+        0x10d0, 0x10fc,
+        0x1100, 0x1248,
+        0x124a, 0x124d,
+        0x1250, 0x1256,
+        0x1258, 0x1258,
+        0x125a, 0x125d,
+        0x1260, 0x1288,
+        0x128a, 0x128d,
+        0x1290, 0x12b0,
+        0x12b2, 0x12b5,
+        0x12b8, 0x12be,
+        0x12c0, 0x12c0,
+        0x12c2, 0x12c5,
+        0x12c8, 0x12d6,
+        0x12d8, 0x1310,
+        0x1312, 0x1315,
+        0x1318, 0x135a,
+        0x1360, 0x137c,
+        0x1380, 0x1399,
+        0x13a0, 0x13f4,
+        0x1400, 0x169c,
+        0x16a0, 0x16f0,
+        0x1700, 0x170c,
+        0x170e, 0x1711,
+        0x1720, 0x1731,
+        0x1735, 0x1736,
+        0x1740, 0x1751,
+        0x1760, 0x176c,
+        0x176e, 0x1770,
+        0x1780, 0x17b3,
+        0x17b6, 0x17b6,
+        0x17be, 0x17c5,
+        0x17c7, 0x17c8,
+        0x17d4, 0x17dc,
+        0x17e0, 0x17e9,
+        0x17f0, 0x17f9,
+        0x1800, 0x180a,
+        0x180e, 0x180e,
+        0x1810, 0x1819,
+        0x1820, 0x1877,
+        0x1880, 0x18a8,
+        0x18aa, 0x18aa,
+        0x18b0, 0x18f5,
+        0x1900, 0x191c,
+        0x1923, 0x1926,
+        0x1929, 0x192b,
+        0x1930, 0x1931,
+        0x1933, 0x1938,
+        0x1940, 0x1940,
+        0x1944, 0x196d,
+        0x1970, 0x1974,
+        0x1980, 0x19ab,
+        0x19b0, 0x19c9,
+        0x19d0, 0x19da,
+        0x19de, 0x1a16,
+        0x1a19, 0x1a1b,
+        0x1a1e, 0x1a55,
+        0x1a57, 0x1a57,
+        0x1a61, 0x1a61,
+        0x1a63, 0x1a64,
+        0x1a6d, 0x1a72,
+        0x1a80, 0x1a89,
+        0x1a90, 0x1a99,
+        0x1aa0, 0x1aad,
+        0x1b04, 0x1b33,
+        0x1b35, 0x1b35,
+        0x1b3b, 0x1b3b,
+        0x1b3d, 0x1b41,
+        0x1b43, 0x1b4b,
+        0x1b50, 0x1b6a,
+        0x1b74, 0x1b7c,
+        0x1b82, 0x1ba1,
+        0x1ba6, 0x1ba7,
+        0x1baa, 0x1baa,
+        0x1bae, 0x1bb9,
+        0x1c00, 0x1c2b,
+        0x1c34, 0x1c35,
+        0x1c3b, 0x1c49,
+        0x1c4d, 0x1c7f,
+        0x1cd3, 0x1cd3,
+        0x1ce1, 0x1ce1,
+        0x1ce9, 0x1cec,
+        0x1cee, 0x1cf2,
+        0x1d00, 0x1dbf,
+        0x1e00, 0x1f15,
+        0x1f18, 0x1f1d,
+        0x1f20, 0x1f45,
+        0x1f48, 0x1f4d,
+        0x1f50, 0x1f57,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f7d,
+        0x1f80, 0x1fb4,
+        0x1fb6, 0x1fc4,
+        0x1fc6, 0x1fd3,
+        0x1fd6, 0x1fdb,
+        0x1fdd, 0x1fef,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ffe,
+        0x2000, 0x200a,
+        0x2010, 0x2027,
+        0x202f, 0x205f,
+        0x2070, 0x2071,
+        0x2074, 0x208e,
+        0x2090, 0x2094,
+        0x20a0, 0x20b8,
+        0x2100, 0x2189,
+        0x2190, 0x23e8,
+        0x2400, 0x2426,
+        0x2440, 0x244a,
+        0x2460, 0x26cd,
+        0x26cf, 0x26e1,
+        0x26e3, 0x26e3,
+        0x26e8, 0x26ff,
+        0x2701, 0x2704,
+        0x2706, 0x2709,
+        0x270c, 0x2727,
+        0x2729, 0x274b,
+        0x274d, 0x274d,
+        0x274f, 0x2752,
+        0x2756, 0x275e,
+        0x2761, 0x2794,
+        0x2798, 0x27af,
+        0x27b1, 0x27be,
+        0x27c0, 0x27ca,
+        0x27cc, 0x27cc,
+        0x27d0, 0x2b4c,
+        0x2b50, 0x2b59,
+        0x2c00, 0x2c2e,
+        0x2c30, 0x2c5e,
+        0x2c60, 0x2cee,
+        0x2cf9, 0x2d25,
+        0x2d30, 0x2d65,
+        0x2d6f, 0x2d6f,
+        0x2d80, 0x2d96,
+        0x2da0, 0x2da6,
+        0x2da8, 0x2dae,
+        0x2db0, 0x2db6,
+        0x2db8, 0x2dbe,
+        0x2dc0, 0x2dc6,
+        0x2dc8, 0x2dce,
+        0x2dd0, 0x2dd6,
+        0x2dd8, 0x2dde,
+        0x2e00, 0x2e31,
+        0x2e80, 0x2e99,
+        0x2e9b, 0x2ef3,
+        0x2f00, 0x2fd5,
+        0x2ff0, 0x2ffb,
+        0x3000, 0x3029,
+        0x3030, 0x303f,
+        0x3041, 0x3096,
+        0x309b, 0x30ff,
+        0x3105, 0x312d,
+        0x3131, 0x318e,
+        0x3190, 0x31b7,
+        0x31c0, 0x31e3,
+        0x31f0, 0x321e,
+        0x3220, 0x32fe,
+        0x3300, 0x4db5,
+        0x4dc0, 0x9fcb,
+        0xa000, 0xa48c,
+        0xa490, 0xa4c6,
+        0xa4d0, 0xa62b,
+        0xa640, 0xa65f,
+        0xa662, 0xa66e,
+        0xa673, 0xa673,
+        0xa67e, 0xa697,
+        0xa6a0, 0xa6ef,
+        0xa6f2, 0xa6f7,
+        0xa700, 0xa78c,
+        0xa7fb, 0xa801,
+        0xa803, 0xa805,
+        0xa807, 0xa80a,
+        0xa80c, 0xa824,
+        0xa827, 0xa82b,
+        0xa830, 0xa839,
+        0xa840, 0xa877,
+        0xa880, 0xa8c3,
+        0xa8ce, 0xa8d9,
+        0xa8f2, 0xa8fb,
+        0xa900, 0xa925,
+        0xa92e, 0xa946,
+        0xa952, 0xa953,
+        0xa95f, 0xa97c,
+        0xa983, 0xa9b2,
+        0xa9b4, 0xa9b5,
+        0xa9ba, 0xa9bb,
+        0xa9bd, 0xa9cd,
+        0xa9cf, 0xa9d9,
+        0xa9de, 0xa9df,
+        0xaa00, 0xaa28,
+        0xaa2f, 0xaa30,
+        0xaa33, 0xaa34,
+        0xaa40, 0xaa42,
+        0xaa44, 0xaa4b,
+        0xaa4d, 0xaa4d,
+        0xaa50, 0xaa59,
+        0xaa5c, 0xaa7b,
+        0xaa80, 0xaaaf,
+        0xaab1, 0xaab1,
+        0xaab5, 0xaab6,
+        0xaab9, 0xaabd,
+        0xaac0, 0xaac0,
+        0xaac2, 0xaac2,
+        0xaadb, 0xaadf,
+        0xabc0, 0xabe4,
+        0xabe6, 0xabe7,
+        0xabe9, 0xabec,
+        0xabf0, 0xabf9,
+        0xac00, 0xd7a3,
+        0xd7b0, 0xd7c6,
+        0xd7cb, 0xd7fb,
+        0xf900, 0xfa2d,
+        0xfa30, 0xfa6d,
+        0xfa70, 0xfad9,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xfb1d, 0xfb1d,
+        0xfb1f, 0xfb36,
+        0xfb38, 0xfb3c,
+        0xfb3e, 0xfb3e,
+        0xfb40, 0xfb41,
+        0xfb43, 0xfb44,
+        0xfb46, 0xfbb1,
+        0xfbd3, 0xfd3f,
+        0xfd50, 0xfd8f,
+        0xfd92, 0xfdc7,
+        0xfdf0, 0xfdfd,
+        0xfe10, 0xfe19,
+        0xfe30, 0xfe52,
+        0xfe54, 0xfe66,
+        0xfe68, 0xfe6b,
+        0xfe70, 0xfe74,
+        0xfe76, 0xfefc,
+        0xff01, 0xff9d,
+        0xffa0, 0xffbe,
+        0xffc2, 0xffc7,
+        0xffca, 0xffcf,
+        0xffd2, 0xffd7,
+        0xffda, 0xffdc,
+        0xffe0, 0xffe6,
+        0xffe8, 0xffee,
+        0xfffc, 0xfffd,
+        0x10000, 0x1000b,
+        0x1000d, 0x10026,
+        0x10028, 0x1003a,
+        0x1003c, 0x1003d,
+        0x1003f, 0x1004d,
+        0x10050, 0x1005d,
+        0x10080, 0x100fa,
+        0x10100, 0x10102,
+        0x10107, 0x10133,
+        0x10137, 0x1018a,
+        0x10190, 0x1019b,
+        0x101d0, 0x101fc,
+        0x10280, 0x1029c,
+        0x102a0, 0x102d0,
+        0x10300, 0x1031e,
+        0x10320, 0x10323,
+        0x10330, 0x1034a,
+        0x10380, 0x1039d,
+        0x1039f, 0x103c3,
+        0x103c8, 0x103d5,
+        0x10400, 0x1049d,
+        0x104a0, 0x104a9,
+        0x10800, 0x10805,
+        0x10808, 0x10808,
+        0x1080a, 0x10835,
+        0x10837, 0x10838,
+        0x1083c, 0x1083c,
+        0x1083f, 0x10855,
+        0x10857, 0x1085f,
+        0x10900, 0x1091b,
+        0x1091f, 0x10939,
+        0x1093f, 0x1093f,
+        0x10a00, 0x10a00,
+        0x10a10, 0x10a13,
+        0x10a15, 0x10a17,
+        0x10a19, 0x10a33,
+        0x10a40, 0x10a47,
+        0x10a50, 0x10a58,
+        0x10a60, 0x10a7f,
+        0x10b00, 0x10b35,
+        0x10b39, 0x10b55,
+        0x10b58, 0x10b72,
+        0x10b78, 0x10b7f,
+        0x10c00, 0x10c48,
+        0x10e60, 0x10e7e,
+        0x11082, 0x110b2,
+        0x110b7, 0x110b8,
+        0x110bb, 0x110bc,
+        0x110be, 0x110c1,
+        0x12000, 0x1236e,
+        0x12400, 0x12462,
+        0x12470, 0x12473,
+        0x13000, 0x1342e,
+        0x1d000, 0x1d0f5,
+        0x1d100, 0x1d126,
+        0x1d129, 0x1d164,
+        0x1d166, 0x1d166,
+        0x1d16a, 0x1d16d,
+        0x1d183, 0x1d184,
+        0x1d18c, 0x1d1a9,
+        0x1d1ae, 0x1d1dd,
+        0x1d200, 0x1d241,
+        0x1d245, 0x1d245,
+        0x1d300, 0x1d356,
+        0x1d360, 0x1d371,
+        0x1d400, 0x1d454,
+        0x1d456, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d51e, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d552, 0x1d6a5,
+        0x1d6a8, 0x1d7cb,
+        0x1d7ce, 0x1d7ff,
+        0x1f000, 0x1f02b,
+        0x1f030, 0x1f093,
+        0x1f100, 0x1f10a,
+        0x1f110, 0x1f12e,
+        0x1f131, 0x1f131,
+        0x1f13d, 0x1f13d,
+        0x1f13f, 0x1f13f,
+        0x1f142, 0x1f142,
+        0x1f146, 0x1f146,
+        0x1f14a, 0x1f14e,
+        0x1f157, 0x1f157,
+        0x1f15f, 0x1f15f,
+        0x1f179, 0x1f179,
+        0x1f17b, 0x1f17c,
+        0x1f17f, 0x1f17f,
+        0x1f18a, 0x1f18d,
+        0x1f190, 0x1f190,
+        0x1f200, 0x1f200,
+        0x1f210, 0x1f231,
+        0x1f240, 0x1f248,
+        0x20000, 0x2a6d6,
+        0x2a700, 0x2b734,
+        0x2f800, 0x2fa1d,
 }; /* CR_Grapheme_Base */
 
 /* 'Grapheme_Link': Derived Property */
 static const OnigCodePoint CR_Grapheme_Link[] = {
-	26,
-	0x094d, 0x094d,
-	0x09cd, 0x09cd,
-	0x0a4d, 0x0a4d,
-	0x0acd, 0x0acd,
-	0x0b4d, 0x0b4d,
-	0x0bcd, 0x0bcd,
-	0x0c4d, 0x0c4d,
-	0x0ccd, 0x0ccd,
-	0x0d4d, 0x0d4d,
-	0x0dca, 0x0dca,
-	0x0e3a, 0x0e3a,
-	0x0f84, 0x0f84,
-	0x1039, 0x103a,
-	0x1714, 0x1714,
-	0x1734, 0x1734,
-	0x17d2, 0x17d2,
-	0x1a60, 0x1a60,
-	0x1b44, 0x1b44,
-	0x1baa, 0x1baa,
-	0xa806, 0xa806,
-	0xa8c4, 0xa8c4,
-	0xa953, 0xa953,
-	0xa9c0, 0xa9c0,
-	0xabed, 0xabed,
-	0x10a3f, 0x10a3f,
-	0x110b9, 0x110b9,
+        26,
+        0x094d, 0x094d,
+        0x09cd, 0x09cd,
+        0x0a4d, 0x0a4d,
+        0x0acd, 0x0acd,
+        0x0b4d, 0x0b4d,
+        0x0bcd, 0x0bcd,
+        0x0c4d, 0x0c4d,
+        0x0ccd, 0x0ccd,
+        0x0d4d, 0x0d4d,
+        0x0dca, 0x0dca,
+        0x0e3a, 0x0e3a,
+        0x0f84, 0x0f84,
+        0x1039, 0x103a,
+        0x1714, 0x1714,
+        0x1734, 0x1734,
+        0x17d2, 0x17d2,
+        0x1a60, 0x1a60,
+        0x1b44, 0x1b44,
+        0x1baa, 0x1baa,
+        0xa806, 0xa806,
+        0xa8c4, 0xa8c4,
+        0xa953, 0xa953,
+        0xa9c0, 0xa9c0,
+        0xabed, 0xabed,
+        0x10a3f, 0x10a3f,
+        0x110b9, 0x110b9,
 }; /* CR_Grapheme_Link */
 
 /* 'Common': Script */
 static const OnigCodePoint CR_Common[] = {
-	159,
-	0x0000, 0x0040,
-	0x005b, 0x0060,
-	0x007b, 0x00a9,
-	0x00ab, 0x00b9,
-	0x00bb, 0x00bf,
-	0x00d7, 0x00d7,
-	0x00f7, 0x00f7,
-	0x02b9, 0x02df,
-	0x02e5, 0x02ff,
-	0x0374, 0x0374,
-	0x037e, 0x037e,
-	0x0385, 0x0385,
-	0x0387, 0x0387,
-	0x0589, 0x0589,
-	0x0600, 0x0603,
-	0x060c, 0x060c,
-	0x061b, 0x061b,
-	0x061f, 0x061f,
-	0x0640, 0x0640,
-	0x0660, 0x0669,
-	0x06dd, 0x06dd,
-	0x0964, 0x0965,
-	0x0970, 0x0970,
-	0x0cf1, 0x0cf2,
-	0x0e3f, 0x0e3f,
-	0x0fd5, 0x0fd8,
-	0x10fb, 0x10fb,
-	0x16eb, 0x16ed,
-	0x1735, 0x1736,
-	0x1802, 0x1803,
-	0x1805, 0x1805,
-	0x1cd3, 0x1cd3,
-	0x1ce1, 0x1ce1,
-	0x1ce9, 0x1cec,
-	0x1cee, 0x1cf2,
-	0x2000, 0x200b,
-	0x200e, 0x2064,
-	0x206a, 0x2070,
-	0x2074, 0x207e,
-	0x2080, 0x208e,
-	0x20a0, 0x20b8,
-	0x2100, 0x2125,
-	0x2127, 0x2129,
-	0x212c, 0x2131,
-	0x2133, 0x214d,
-	0x214f, 0x215f,
-	0x2189, 0x2189,
-	0x2190, 0x23e8,
-	0x2400, 0x2426,
-	0x2440, 0x244a,
-	0x2460, 0x26cd,
-	0x26cf, 0x26e1,
-	0x26e3, 0x26e3,
-	0x26e8, 0x26ff,
-	0x2701, 0x2704,
-	0x2706, 0x2709,
-	0x270c, 0x2727,
-	0x2729, 0x274b,
-	0x274d, 0x274d,
-	0x274f, 0x2752,
-	0x2756, 0x275e,
-	0x2761, 0x2794,
-	0x2798, 0x27af,
-	0x27b1, 0x27be,
-	0x27c0, 0x27ca,
-	0x27cc, 0x27cc,
-	0x27d0, 0x27ff,
-	0x2900, 0x2b4c,
-	0x2b50, 0x2b59,
-	0x2e00, 0x2e31,
-	0x2ff0, 0x2ffb,
-	0x3000, 0x3004,
-	0x3006, 0x3006,
-	0x3008, 0x3020,
-	0x3030, 0x3037,
-	0x303c, 0x303f,
-	0x309b, 0x309c,
-	0x30a0, 0x30a0,
-	0x30fb, 0x30fc,
-	0x3190, 0x319f,
-	0x31c0, 0x31e3,
-	0x3220, 0x325f,
-	0x327f, 0x32cf,
-	0x3358, 0x33ff,
-	0x4dc0, 0x4dff,
-	0xa700, 0xa721,
-	0xa788, 0xa78a,
-	0xa830, 0xa839,
-	0xfd3e, 0xfd3f,
-	0xfdfd, 0xfdfd,
-	0xfe10, 0xfe19,
-	0xfe30, 0xfe52,
-	0xfe54, 0xfe66,
-	0xfe68, 0xfe6b,
-	0xfeff, 0xfeff,
-	0xff01, 0xff20,
-	0xff3b, 0xff40,
-	0xff5b, 0xff65,
-	0xff70, 0xff70,
-	0xff9e, 0xff9f,
-	0xffe0, 0xffe6,
-	0xffe8, 0xffee,
-	0xfff9, 0xfffd,
-	0x10100, 0x10102,
-	0x10107, 0x10133,
-	0x10137, 0x1013f,
-	0x10190, 0x1019b,
-	0x101d0, 0x101fc,
-	0x1d000, 0x1d0f5,
-	0x1d100, 0x1d126,
-	0x1d129, 0x1d166,
-	0x1d16a, 0x1d17a,
-	0x1d183, 0x1d184,
-	0x1d18c, 0x1d1a9,
-	0x1d1ae, 0x1d1dd,
-	0x1d300, 0x1d356,
-	0x1d360, 0x1d371,
-	0x1d400, 0x1d454,
-	0x1d456, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d51e, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d552, 0x1d6a5,
-	0x1d6a8, 0x1d7cb,
-	0x1d7ce, 0x1d7ff,
-	0x1f000, 0x1f02b,
-	0x1f030, 0x1f093,
-	0x1f100, 0x1f10a,
-	0x1f110, 0x1f12e,
-	0x1f131, 0x1f131,
-	0x1f13d, 0x1f13d,
-	0x1f13f, 0x1f13f,
-	0x1f142, 0x1f142,
-	0x1f146, 0x1f146,
-	0x1f14a, 0x1f14e,
-	0x1f157, 0x1f157,
-	0x1f15f, 0x1f15f,
-	0x1f179, 0x1f179,
-	0x1f17b, 0x1f17c,
-	0x1f17f, 0x1f17f,
-	0x1f18a, 0x1f18d,
-	0x1f190, 0x1f190,
-	0x1f210, 0x1f231,
-	0x1f240, 0x1f248,
-	0xe0001, 0xe0001,
-	0xe0020, 0xe007f,
+        159,
+        0x0000, 0x0040,
+        0x005b, 0x0060,
+        0x007b, 0x00a9,
+        0x00ab, 0x00b9,
+        0x00bb, 0x00bf,
+        0x00d7, 0x00d7,
+        0x00f7, 0x00f7,
+        0x02b9, 0x02df,
+        0x02e5, 0x02ff,
+        0x0374, 0x0374,
+        0x037e, 0x037e,
+        0x0385, 0x0385,
+        0x0387, 0x0387,
+        0x0589, 0x0589,
+        0x0600, 0x0603,
+        0x060c, 0x060c,
+        0x061b, 0x061b,
+        0x061f, 0x061f,
+        0x0640, 0x0640,
+        0x0660, 0x0669,
+        0x06dd, 0x06dd,
+        0x0964, 0x0965,
+        0x0970, 0x0970,
+        0x0cf1, 0x0cf2,
+        0x0e3f, 0x0e3f,
+        0x0fd5, 0x0fd8,
+        0x10fb, 0x10fb,
+        0x16eb, 0x16ed,
+        0x1735, 0x1736,
+        0x1802, 0x1803,
+        0x1805, 0x1805,
+        0x1cd3, 0x1cd3,
+        0x1ce1, 0x1ce1,
+        0x1ce9, 0x1cec,
+        0x1cee, 0x1cf2,
+        0x2000, 0x200b,
+        0x200e, 0x2064,
+        0x206a, 0x2070,
+        0x2074, 0x207e,
+        0x2080, 0x208e,
+        0x20a0, 0x20b8,
+        0x2100, 0x2125,
+        0x2127, 0x2129,
+        0x212c, 0x2131,
+        0x2133, 0x214d,
+        0x214f, 0x215f,
+        0x2189, 0x2189,
+        0x2190, 0x23e8,
+        0x2400, 0x2426,
+        0x2440, 0x244a,
+        0x2460, 0x26cd,
+        0x26cf, 0x26e1,
+        0x26e3, 0x26e3,
+        0x26e8, 0x26ff,
+        0x2701, 0x2704,
+        0x2706, 0x2709,
+        0x270c, 0x2727,
+        0x2729, 0x274b,
+        0x274d, 0x274d,
+        0x274f, 0x2752,
+        0x2756, 0x275e,
+        0x2761, 0x2794,
+        0x2798, 0x27af,
+        0x27b1, 0x27be,
+        0x27c0, 0x27ca,
+        0x27cc, 0x27cc,
+        0x27d0, 0x27ff,
+        0x2900, 0x2b4c,
+        0x2b50, 0x2b59,
+        0x2e00, 0x2e31,
+        0x2ff0, 0x2ffb,
+        0x3000, 0x3004,
+        0x3006, 0x3006,
+        0x3008, 0x3020,
+        0x3030, 0x3037,
+        0x303c, 0x303f,
+        0x309b, 0x309c,
+        0x30a0, 0x30a0,
+        0x30fb, 0x30fc,
+        0x3190, 0x319f,
+        0x31c0, 0x31e3,
+        0x3220, 0x325f,
+        0x327f, 0x32cf,
+        0x3358, 0x33ff,
+        0x4dc0, 0x4dff,
+        0xa700, 0xa721,
+        0xa788, 0xa78a,
+        0xa830, 0xa839,
+        0xfd3e, 0xfd3f,
+        0xfdfd, 0xfdfd,
+        0xfe10, 0xfe19,
+        0xfe30, 0xfe52,
+        0xfe54, 0xfe66,
+        0xfe68, 0xfe6b,
+        0xfeff, 0xfeff,
+        0xff01, 0xff20,
+        0xff3b, 0xff40,
+        0xff5b, 0xff65,
+        0xff70, 0xff70,
+        0xff9e, 0xff9f,
+        0xffe0, 0xffe6,
+        0xffe8, 0xffee,
+        0xfff9, 0xfffd,
+        0x10100, 0x10102,
+        0x10107, 0x10133,
+        0x10137, 0x1013f,
+        0x10190, 0x1019b,
+        0x101d0, 0x101fc,
+        0x1d000, 0x1d0f5,
+        0x1d100, 0x1d126,
+        0x1d129, 0x1d166,
+        0x1d16a, 0x1d17a,
+        0x1d183, 0x1d184,
+        0x1d18c, 0x1d1a9,
+        0x1d1ae, 0x1d1dd,
+        0x1d300, 0x1d356,
+        0x1d360, 0x1d371,
+        0x1d400, 0x1d454,
+        0x1d456, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d51e, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d552, 0x1d6a5,
+        0x1d6a8, 0x1d7cb,
+        0x1d7ce, 0x1d7ff,
+        0x1f000, 0x1f02b,
+        0x1f030, 0x1f093,
+        0x1f100, 0x1f10a,
+        0x1f110, 0x1f12e,
+        0x1f131, 0x1f131,
+        0x1f13d, 0x1f13d,
+        0x1f13f, 0x1f13f,
+        0x1f142, 0x1f142,
+        0x1f146, 0x1f146,
+        0x1f14a, 0x1f14e,
+        0x1f157, 0x1f157,
+        0x1f15f, 0x1f15f,
+        0x1f179, 0x1f179,
+        0x1f17b, 0x1f17c,
+        0x1f17f, 0x1f17f,
+        0x1f18a, 0x1f18d,
+        0x1f190, 0x1f190,
+        0x1f210, 0x1f231,
+        0x1f240, 0x1f248,
+        0xe0001, 0xe0001,
+        0xe0020, 0xe007f,
 }; /* CR_Common */
 
 /* 'Latin': Script */
 static const OnigCodePoint CR_Latin[] = {
-	28,
-	0x0041, 0x005a,
-	0x0061, 0x007a,
-	0x00aa, 0x00aa,
-	0x00ba, 0x00ba,
-	0x00c0, 0x00d6,
-	0x00d8, 0x00f6,
-	0x00f8, 0x02b8,
-	0x02e0, 0x02e4,
-	0x1d00, 0x1d25,
-	0x1d2c, 0x1d5c,
-	0x1d62, 0x1d65,
-	0x1d6b, 0x1d77,
-	0x1d79, 0x1dbe,
-	0x1e00, 0x1eff,
-	0x2071, 0x2071,
-	0x207f, 0x207f,
-	0x2090, 0x2094,
-	0x212a, 0x212b,
-	0x2132, 0x2132,
-	0x214e, 0x214e,
-	0x2160, 0x2188,
-	0x2c60, 0x2c7f,
-	0xa722, 0xa787,
-	0xa78b, 0xa78c,
-	0xa7fb, 0xa7ff,
-	0xfb00, 0xfb06,
-	0xff21, 0xff3a,
-	0xff41, 0xff5a,
+        28,
+        0x0041, 0x005a,
+        0x0061, 0x007a,
+        0x00aa, 0x00aa,
+        0x00ba, 0x00ba,
+        0x00c0, 0x00d6,
+        0x00d8, 0x00f6,
+        0x00f8, 0x02b8,
+        0x02e0, 0x02e4,
+        0x1d00, 0x1d25,
+        0x1d2c, 0x1d5c,
+        0x1d62, 0x1d65,
+        0x1d6b, 0x1d77,
+        0x1d79, 0x1dbe,
+        0x1e00, 0x1eff,
+        0x2071, 0x2071,
+        0x207f, 0x207f,
+        0x2090, 0x2094,
+        0x212a, 0x212b,
+        0x2132, 0x2132,
+        0x214e, 0x214e,
+        0x2160, 0x2188,
+        0x2c60, 0x2c7f,
+        0xa722, 0xa787,
+        0xa78b, 0xa78c,
+        0xa7fb, 0xa7ff,
+        0xfb00, 0xfb06,
+        0xff21, 0xff3a,
+        0xff41, 0xff5a,
 }; /* CR_Latin */
 
 /* 'Greek': Script */
 static const OnigCodePoint CR_Greek[] = {
-	33,
-	0x0370, 0x0373,
-	0x0375, 0x0377,
-	0x037a, 0x037d,
-	0x0384, 0x0384,
-	0x0386, 0x0386,
-	0x0388, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x03a1,
-	0x03a3, 0x03e1,
-	0x03f0, 0x03ff,
-	0x1d26, 0x1d2a,
-	0x1d5d, 0x1d61,
-	0x1d66, 0x1d6a,
-	0x1dbf, 0x1dbf,
-	0x1f00, 0x1f15,
-	0x1f18, 0x1f1d,
-	0x1f20, 0x1f45,
-	0x1f48, 0x1f4d,
-	0x1f50, 0x1f57,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f7d,
-	0x1f80, 0x1fb4,
-	0x1fb6, 0x1fc4,
-	0x1fc6, 0x1fd3,
-	0x1fd6, 0x1fdb,
-	0x1fdd, 0x1fef,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ffe,
-	0x2126, 0x2126,
-	0x10140, 0x1018a,
-	0x1d200, 0x1d245,
+        33,
+        0x0370, 0x0373,
+        0x0375, 0x0377,
+        0x037a, 0x037d,
+        0x0384, 0x0384,
+        0x0386, 0x0386,
+        0x0388, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x03a1,
+        0x03a3, 0x03e1,
+        0x03f0, 0x03ff,
+        0x1d26, 0x1d2a,
+        0x1d5d, 0x1d61,
+        0x1d66, 0x1d6a,
+        0x1dbf, 0x1dbf,
+        0x1f00, 0x1f15,
+        0x1f18, 0x1f1d,
+        0x1f20, 0x1f45,
+        0x1f48, 0x1f4d,
+        0x1f50, 0x1f57,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f7d,
+        0x1f80, 0x1fb4,
+        0x1fb6, 0x1fc4,
+        0x1fc6, 0x1fd3,
+        0x1fd6, 0x1fdb,
+        0x1fdd, 0x1fef,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ffe,
+        0x2126, 0x2126,
+        0x10140, 0x1018a,
+        0x1d200, 0x1d245,
 }; /* CR_Greek */
 
 /* 'Cyrillic': Script */
 static const OnigCodePoint CR_Cyrillic[] = {
-	8,
-	0x0400, 0x0484,
-	0x0487, 0x0525,
-	0x1d2b, 0x1d2b,
-	0x1d78, 0x1d78,
-	0x2de0, 0x2dff,
-	0xa640, 0xa65f,
-	0xa662, 0xa673,
-	0xa67c, 0xa697,
+        8,
+        0x0400, 0x0484,
+        0x0487, 0x0525,
+        0x1d2b, 0x1d2b,
+        0x1d78, 0x1d78,
+        0x2de0, 0x2dff,
+        0xa640, 0xa65f,
+        0xa662, 0xa673,
+        0xa67c, 0xa697,
 }; /* CR_Cyrillic */
 
 /* 'Armenian': Script */
 static const OnigCodePoint CR_Armenian[] = {
-	5,
-	0x0531, 0x0556,
-	0x0559, 0x055f,
-	0x0561, 0x0587,
-	0x058a, 0x058a,
-	0xfb13, 0xfb17,
+        5,
+        0x0531, 0x0556,
+        0x0559, 0x055f,
+        0x0561, 0x0587,
+        0x058a, 0x058a,
+        0xfb13, 0xfb17,
 }; /* CR_Armenian */
 
 /* 'Hebrew': Script */
 static const OnigCodePoint CR_Hebrew[] = {
-	9,
-	0x0591, 0x05c7,
-	0x05d0, 0x05ea,
-	0x05f0, 0x05f4,
-	0xfb1d, 0xfb36,
-	0xfb38, 0xfb3c,
-	0xfb3e, 0xfb3e,
-	0xfb40, 0xfb41,
-	0xfb43, 0xfb44,
-	0xfb46, 0xfb4f,
+        9,
+        0x0591, 0x05c7,
+        0x05d0, 0x05ea,
+        0x05f0, 0x05f4,
+        0xfb1d, 0xfb36,
+        0xfb38, 0xfb3c,
+        0xfb3e, 0xfb3e,
+        0xfb40, 0xfb41,
+        0xfb43, 0xfb44,
+        0xfb46, 0xfb4f,
 }; /* CR_Hebrew */
 
 /* 'Arabic': Script */
 static const OnigCodePoint CR_Arabic[] = {
-	18,
-	0x0606, 0x060b,
-	0x060d, 0x061a,
-	0x061e, 0x061e,
-	0x0621, 0x063f,
-	0x0641, 0x064a,
-	0x0656, 0x065e,
-	0x066a, 0x066f,
-	0x0671, 0x06dc,
-	0x06de, 0x06ff,
-	0x0750, 0x077f,
-	0xfb50, 0xfbb1,
-	0xfbd3, 0xfd3d,
-	0xfd50, 0xfd8f,
-	0xfd92, 0xfdc7,
-	0xfdf0, 0xfdfc,
-	0xfe70, 0xfe74,
-	0xfe76, 0xfefc,
-	0x10e60, 0x10e7e,
+        18,
+        0x0606, 0x060b,
+        0x060d, 0x061a,
+        0x061e, 0x061e,
+        0x0621, 0x063f,
+        0x0641, 0x064a,
+        0x0656, 0x065e,
+        0x066a, 0x066f,
+        0x0671, 0x06dc,
+        0x06de, 0x06ff,
+        0x0750, 0x077f,
+        0xfb50, 0xfbb1,
+        0xfbd3, 0xfd3d,
+        0xfd50, 0xfd8f,
+        0xfd92, 0xfdc7,
+        0xfdf0, 0xfdfc,
+        0xfe70, 0xfe74,
+        0xfe76, 0xfefc,
+        0x10e60, 0x10e7e,
 }; /* CR_Arabic */
 
 /* 'Syriac': Script */
 static const OnigCodePoint CR_Syriac[] = {
-	3,
-	0x0700, 0x070d,
-	0x070f, 0x074a,
-	0x074d, 0x074f,
+        3,
+        0x0700, 0x070d,
+        0x070f, 0x074a,
+        0x074d, 0x074f,
 }; /* CR_Syriac */
 
 /* 'Thaana': Script */
 static const OnigCodePoint CR_Thaana[] = {
-	1,
-	0x0780, 0x07b1,
+        1,
+        0x0780, 0x07b1,
 }; /* CR_Thaana */
 
 /* 'Devanagari': Script */
 static const OnigCodePoint CR_Devanagari[] = {
-	9,
-	0x0900, 0x0939,
-	0x093c, 0x094e,
-	0x0950, 0x0950,
-	0x0953, 0x0955,
-	0x0958, 0x0963,
-	0x0966, 0x096f,
-	0x0971, 0x0972,
-	0x0979, 0x097f,
-	0xa8e0, 0xa8fb,
+        9,
+        0x0900, 0x0939,
+        0x093c, 0x094e,
+        0x0950, 0x0950,
+        0x0953, 0x0955,
+        0x0958, 0x0963,
+        0x0966, 0x096f,
+        0x0971, 0x0972,
+        0x0979, 0x097f,
+        0xa8e0, 0xa8fb,
 }; /* CR_Devanagari */
 
 /* 'Bengali': Script */
 static const OnigCodePoint CR_Bengali[] = {
-	14,
-	0x0981, 0x0983,
-	0x0985, 0x098c,
-	0x098f, 0x0990,
-	0x0993, 0x09a8,
-	0x09aa, 0x09b0,
-	0x09b2, 0x09b2,
-	0x09b6, 0x09b9,
-	0x09bc, 0x09c4,
-	0x09c7, 0x09c8,
-	0x09cb, 0x09ce,
-	0x09d7, 0x09d7,
-	0x09dc, 0x09dd,
-	0x09df, 0x09e3,
-	0x09e6, 0x09fb,
+        14,
+        0x0981, 0x0983,
+        0x0985, 0x098c,
+        0x098f, 0x0990,
+        0x0993, 0x09a8,
+        0x09aa, 0x09b0,
+        0x09b2, 0x09b2,
+        0x09b6, 0x09b9,
+        0x09bc, 0x09c4,
+        0x09c7, 0x09c8,
+        0x09cb, 0x09ce,
+        0x09d7, 0x09d7,
+        0x09dc, 0x09dd,
+        0x09df, 0x09e3,
+        0x09e6, 0x09fb,
 }; /* CR_Bengali */
 
 /* 'Gurmukhi': Script */
 static const OnigCodePoint CR_Gurmukhi[] = {
-	16,
-	0x0a01, 0x0a03,
-	0x0a05, 0x0a0a,
-	0x0a0f, 0x0a10,
-	0x0a13, 0x0a28,
-	0x0a2a, 0x0a30,
-	0x0a32, 0x0a33,
-	0x0a35, 0x0a36,
-	0x0a38, 0x0a39,
-	0x0a3c, 0x0a3c,
-	0x0a3e, 0x0a42,
-	0x0a47, 0x0a48,
-	0x0a4b, 0x0a4d,
-	0x0a51, 0x0a51,
-	0x0a59, 0x0a5c,
-	0x0a5e, 0x0a5e,
-	0x0a66, 0x0a75,
+        16,
+        0x0a01, 0x0a03,
+        0x0a05, 0x0a0a,
+        0x0a0f, 0x0a10,
+        0x0a13, 0x0a28,
+        0x0a2a, 0x0a30,
+        0x0a32, 0x0a33,
+        0x0a35, 0x0a36,
+        0x0a38, 0x0a39,
+        0x0a3c, 0x0a3c,
+        0x0a3e, 0x0a42,
+        0x0a47, 0x0a48,
+        0x0a4b, 0x0a4d,
+        0x0a51, 0x0a51,
+        0x0a59, 0x0a5c,
+        0x0a5e, 0x0a5e,
+        0x0a66, 0x0a75,
 }; /* CR_Gurmukhi */
 
 /* 'Gujarati': Script */
 static const OnigCodePoint CR_Gujarati[] = {
-	14,
-	0x0a81, 0x0a83,
-	0x0a85, 0x0a8d,
-	0x0a8f, 0x0a91,
-	0x0a93, 0x0aa8,
-	0x0aaa, 0x0ab0,
-	0x0ab2, 0x0ab3,
-	0x0ab5, 0x0ab9,
-	0x0abc, 0x0ac5,
-	0x0ac7, 0x0ac9,
-	0x0acb, 0x0acd,
-	0x0ad0, 0x0ad0,
-	0x0ae0, 0x0ae3,
-	0x0ae6, 0x0aef,
-	0x0af1, 0x0af1,
+        14,
+        0x0a81, 0x0a83,
+        0x0a85, 0x0a8d,
+        0x0a8f, 0x0a91,
+        0x0a93, 0x0aa8,
+        0x0aaa, 0x0ab0,
+        0x0ab2, 0x0ab3,
+        0x0ab5, 0x0ab9,
+        0x0abc, 0x0ac5,
+        0x0ac7, 0x0ac9,
+        0x0acb, 0x0acd,
+        0x0ad0, 0x0ad0,
+        0x0ae0, 0x0ae3,
+        0x0ae6, 0x0aef,
+        0x0af1, 0x0af1,
 }; /* CR_Gujarati */
 
 /* 'Oriya': Script */
 static const OnigCodePoint CR_Oriya[] = {
-	14,
-	0x0b01, 0x0b03,
-	0x0b05, 0x0b0c,
-	0x0b0f, 0x0b10,
-	0x0b13, 0x0b28,
-	0x0b2a, 0x0b30,
-	0x0b32, 0x0b33,
-	0x0b35, 0x0b39,
-	0x0b3c, 0x0b44,
-	0x0b47, 0x0b48,
-	0x0b4b, 0x0b4d,
-	0x0b56, 0x0b57,
-	0x0b5c, 0x0b5d,
-	0x0b5f, 0x0b63,
-	0x0b66, 0x0b71,
+        14,
+        0x0b01, 0x0b03,
+        0x0b05, 0x0b0c,
+        0x0b0f, 0x0b10,
+        0x0b13, 0x0b28,
+        0x0b2a, 0x0b30,
+        0x0b32, 0x0b33,
+        0x0b35, 0x0b39,
+        0x0b3c, 0x0b44,
+        0x0b47, 0x0b48,
+        0x0b4b, 0x0b4d,
+        0x0b56, 0x0b57,
+        0x0b5c, 0x0b5d,
+        0x0b5f, 0x0b63,
+        0x0b66, 0x0b71,
 }; /* CR_Oriya */
 
 /* 'Tamil': Script */
 static const OnigCodePoint CR_Tamil[] = {
-	16,
-	0x0b82, 0x0b83,
-	0x0b85, 0x0b8a,
-	0x0b8e, 0x0b90,
-	0x0b92, 0x0b95,
-	0x0b99, 0x0b9a,
-	0x0b9c, 0x0b9c,
-	0x0b9e, 0x0b9f,
-	0x0ba3, 0x0ba4,
-	0x0ba8, 0x0baa,
-	0x0bae, 0x0bb9,
-	0x0bbe, 0x0bc2,
-	0x0bc6, 0x0bc8,
-	0x0bca, 0x0bcd,
-	0x0bd0, 0x0bd0,
-	0x0bd7, 0x0bd7,
-	0x0be6, 0x0bfa,
+        16,
+        0x0b82, 0x0b83,
+        0x0b85, 0x0b8a,
+        0x0b8e, 0x0b90,
+        0x0b92, 0x0b95,
+        0x0b99, 0x0b9a,
+        0x0b9c, 0x0b9c,
+        0x0b9e, 0x0b9f,
+        0x0ba3, 0x0ba4,
+        0x0ba8, 0x0baa,
+        0x0bae, 0x0bb9,
+        0x0bbe, 0x0bc2,
+        0x0bc6, 0x0bc8,
+        0x0bca, 0x0bcd,
+        0x0bd0, 0x0bd0,
+        0x0bd7, 0x0bd7,
+        0x0be6, 0x0bfa,
 }; /* CR_Tamil */
 
 /* 'Telugu': Script */
 static const OnigCodePoint CR_Telugu[] = {
-	14,
-	0x0c01, 0x0c03,
-	0x0c05, 0x0c0c,
-	0x0c0e, 0x0c10,
-	0x0c12, 0x0c28,
-	0x0c2a, 0x0c33,
-	0x0c35, 0x0c39,
-	0x0c3d, 0x0c44,
-	0x0c46, 0x0c48,
-	0x0c4a, 0x0c4d,
-	0x0c55, 0x0c56,
-	0x0c58, 0x0c59,
-	0x0c60, 0x0c63,
-	0x0c66, 0x0c6f,
-	0x0c78, 0x0c7f,
+        14,
+        0x0c01, 0x0c03,
+        0x0c05, 0x0c0c,
+        0x0c0e, 0x0c10,
+        0x0c12, 0x0c28,
+        0x0c2a, 0x0c33,
+        0x0c35, 0x0c39,
+        0x0c3d, 0x0c44,
+        0x0c46, 0x0c48,
+        0x0c4a, 0x0c4d,
+        0x0c55, 0x0c56,
+        0x0c58, 0x0c59,
+        0x0c60, 0x0c63,
+        0x0c66, 0x0c6f,
+        0x0c78, 0x0c7f,
 }; /* CR_Telugu */
 
 /* 'Kannada': Script */
 static const OnigCodePoint CR_Kannada[] = {
-	13,
-	0x0c82, 0x0c83,
-	0x0c85, 0x0c8c,
-	0x0c8e, 0x0c90,
-	0x0c92, 0x0ca8,
-	0x0caa, 0x0cb3,
-	0x0cb5, 0x0cb9,
-	0x0cbc, 0x0cc4,
-	0x0cc6, 0x0cc8,
-	0x0cca, 0x0ccd,
-	0x0cd5, 0x0cd6,
-	0x0cde, 0x0cde,
-	0x0ce0, 0x0ce3,
-	0x0ce6, 0x0cef,
+        13,
+        0x0c82, 0x0c83,
+        0x0c85, 0x0c8c,
+        0x0c8e, 0x0c90,
+        0x0c92, 0x0ca8,
+        0x0caa, 0x0cb3,
+        0x0cb5, 0x0cb9,
+        0x0cbc, 0x0cc4,
+        0x0cc6, 0x0cc8,
+        0x0cca, 0x0ccd,
+        0x0cd5, 0x0cd6,
+        0x0cde, 0x0cde,
+        0x0ce0, 0x0ce3,
+        0x0ce6, 0x0cef,
 }; /* CR_Kannada */
 
 /* 'Malayalam': Script */
 static const OnigCodePoint CR_Malayalam[] = {
-	12,
-	0x0d02, 0x0d03,
-	0x0d05, 0x0d0c,
-	0x0d0e, 0x0d10,
-	0x0d12, 0x0d28,
-	0x0d2a, 0x0d39,
-	0x0d3d, 0x0d44,
-	0x0d46, 0x0d48,
-	0x0d4a, 0x0d4d,
-	0x0d57, 0x0d57,
-	0x0d60, 0x0d63,
-	0x0d66, 0x0d75,
-	0x0d79, 0x0d7f,
+        12,
+        0x0d02, 0x0d03,
+        0x0d05, 0x0d0c,
+        0x0d0e, 0x0d10,
+        0x0d12, 0x0d28,
+        0x0d2a, 0x0d39,
+        0x0d3d, 0x0d44,
+        0x0d46, 0x0d48,
+        0x0d4a, 0x0d4d,
+        0x0d57, 0x0d57,
+        0x0d60, 0x0d63,
+        0x0d66, 0x0d75,
+        0x0d79, 0x0d7f,
 }; /* CR_Malayalam */
 
 /* 'Sinhala': Script */
 static const OnigCodePoint CR_Sinhala[] = {
-	11,
-	0x0d82, 0x0d83,
-	0x0d85, 0x0d96,
-	0x0d9a, 0x0db1,
-	0x0db3, 0x0dbb,
-	0x0dbd, 0x0dbd,
-	0x0dc0, 0x0dc6,
-	0x0dca, 0x0dca,
-	0x0dcf, 0x0dd4,
-	0x0dd6, 0x0dd6,
-	0x0dd8, 0x0ddf,
-	0x0df2, 0x0df4,
+        11,
+        0x0d82, 0x0d83,
+        0x0d85, 0x0d96,
+        0x0d9a, 0x0db1,
+        0x0db3, 0x0dbb,
+        0x0dbd, 0x0dbd,
+        0x0dc0, 0x0dc6,
+        0x0dca, 0x0dca,
+        0x0dcf, 0x0dd4,
+        0x0dd6, 0x0dd6,
+        0x0dd8, 0x0ddf,
+        0x0df2, 0x0df4,
 }; /* CR_Sinhala */
 
 /* 'Thai': Script */
 static const OnigCodePoint CR_Thai[] = {
-	2,
-	0x0e01, 0x0e3a,
-	0x0e40, 0x0e5b,
+        2,
+        0x0e01, 0x0e3a,
+        0x0e40, 0x0e5b,
 }; /* CR_Thai */
 
 /* 'Lao': Script */
 static const OnigCodePoint CR_Lao[] = {
-	18,
-	0x0e81, 0x0e82,
-	0x0e84, 0x0e84,
-	0x0e87, 0x0e88,
-	0x0e8a, 0x0e8a,
-	0x0e8d, 0x0e8d,
-	0x0e94, 0x0e97,
-	0x0e99, 0x0e9f,
-	0x0ea1, 0x0ea3,
-	0x0ea5, 0x0ea5,
-	0x0ea7, 0x0ea7,
-	0x0eaa, 0x0eab,
-	0x0ead, 0x0eb9,
-	0x0ebb, 0x0ebd,
-	0x0ec0, 0x0ec4,
-	0x0ec6, 0x0ec6,
-	0x0ec8, 0x0ecd,
-	0x0ed0, 0x0ed9,
-	0x0edc, 0x0edd,
+        18,
+        0x0e81, 0x0e82,
+        0x0e84, 0x0e84,
+        0x0e87, 0x0e88,
+        0x0e8a, 0x0e8a,
+        0x0e8d, 0x0e8d,
+        0x0e94, 0x0e97,
+        0x0e99, 0x0e9f,
+        0x0ea1, 0x0ea3,
+        0x0ea5, 0x0ea5,
+        0x0ea7, 0x0ea7,
+        0x0eaa, 0x0eab,
+        0x0ead, 0x0eb9,
+        0x0ebb, 0x0ebd,
+        0x0ec0, 0x0ec4,
+        0x0ec6, 0x0ec6,
+        0x0ec8, 0x0ecd,
+        0x0ed0, 0x0ed9,
+        0x0edc, 0x0edd,
 }; /* CR_Lao */
 
 /* 'Tibetan': Script */
 static const OnigCodePoint CR_Tibetan[] = {
-	7,
-	0x0f00, 0x0f47,
-	0x0f49, 0x0f6c,
-	0x0f71, 0x0f8b,
-	0x0f90, 0x0f97,
-	0x0f99, 0x0fbc,
-	0x0fbe, 0x0fcc,
-	0x0fce, 0x0fd4,
+        7,
+        0x0f00, 0x0f47,
+        0x0f49, 0x0f6c,
+        0x0f71, 0x0f8b,
+        0x0f90, 0x0f97,
+        0x0f99, 0x0fbc,
+        0x0fbe, 0x0fcc,
+        0x0fce, 0x0fd4,
 }; /* CR_Tibetan */
 
 /* 'Myanmar': Script */
 static const OnigCodePoint CR_Myanmar[] = {
-	2,
-	0x1000, 0x109f,
-	0xaa60, 0xaa7b,
+        2,
+        0x1000, 0x109f,
+        0xaa60, 0xaa7b,
 }; /* CR_Myanmar */
 
 /* 'Georgian': Script */
 static const OnigCodePoint CR_Georgian[] = {
-	4,
-	0x10a0, 0x10c5,
-	0x10d0, 0x10fa,
-	0x10fc, 0x10fc,
-	0x2d00, 0x2d25,
+        4,
+        0x10a0, 0x10c5,
+        0x10d0, 0x10fa,
+        0x10fc, 0x10fc,
+        0x2d00, 0x2d25,
 }; /* CR_Georgian */
 
 /* 'Hangul': Script */
 static const OnigCodePoint CR_Hangul[] = {
-	13,
-	0x1100, 0x11ff,
-	0x3131, 0x318e,
-	0x3200, 0x321e,
-	0x3260, 0x327e,
-	0xa960, 0xa97c,
-	0xac00, 0xd7a3,
-	0xd7b0, 0xd7c6,
-	0xd7cb, 0xd7fb,
-	0xffa0, 0xffbe,
-	0xffc2, 0xffc7,
-	0xffca, 0xffcf,
-	0xffd2, 0xffd7,
-	0xffda, 0xffdc,
+        13,
+        0x1100, 0x11ff,
+        0x3131, 0x318e,
+        0x3200, 0x321e,
+        0x3260, 0x327e,
+        0xa960, 0xa97c,
+        0xac00, 0xd7a3,
+        0xd7b0, 0xd7c6,
+        0xd7cb, 0xd7fb,
+        0xffa0, 0xffbe,
+        0xffc2, 0xffc7,
+        0xffca, 0xffcf,
+        0xffd2, 0xffd7,
+        0xffda, 0xffdc,
 }; /* CR_Hangul */
 
 /* 'Ethiopic': Script */
 static const OnigCodePoint CR_Ethiopic[] = {
-	27,
-	0x1200, 0x1248,
-	0x124a, 0x124d,
-	0x1250, 0x1256,
-	0x1258, 0x1258,
-	0x125a, 0x125d,
-	0x1260, 0x1288,
-	0x128a, 0x128d,
-	0x1290, 0x12b0,
-	0x12b2, 0x12b5,
-	0x12b8, 0x12be,
-	0x12c0, 0x12c0,
-	0x12c2, 0x12c5,
-	0x12c8, 0x12d6,
-	0x12d8, 0x1310,
-	0x1312, 0x1315,
-	0x1318, 0x135a,
-	0x135f, 0x137c,
-	0x1380, 0x1399,
-	0x2d80, 0x2d96,
-	0x2da0, 0x2da6,
-	0x2da8, 0x2dae,
-	0x2db0, 0x2db6,
-	0x2db8, 0x2dbe,
-	0x2dc0, 0x2dc6,
-	0x2dc8, 0x2dce,
-	0x2dd0, 0x2dd6,
-	0x2dd8, 0x2dde,
+        27,
+        0x1200, 0x1248,
+        0x124a, 0x124d,
+        0x1250, 0x1256,
+        0x1258, 0x1258,
+        0x125a, 0x125d,
+        0x1260, 0x1288,
+        0x128a, 0x128d,
+        0x1290, 0x12b0,
+        0x12b2, 0x12b5,
+        0x12b8, 0x12be,
+        0x12c0, 0x12c0,
+        0x12c2, 0x12c5,
+        0x12c8, 0x12d6,
+        0x12d8, 0x1310,
+        0x1312, 0x1315,
+        0x1318, 0x135a,
+        0x135f, 0x137c,
+        0x1380, 0x1399,
+        0x2d80, 0x2d96,
+        0x2da0, 0x2da6,
+        0x2da8, 0x2dae,
+        0x2db0, 0x2db6,
+        0x2db8, 0x2dbe,
+        0x2dc0, 0x2dc6,
+        0x2dc8, 0x2dce,
+        0x2dd0, 0x2dd6,
+        0x2dd8, 0x2dde,
 }; /* CR_Ethiopic */
 
 /* 'Cherokee': Script */
 static const OnigCodePoint CR_Cherokee[] = {
-	1,
-	0x13a0, 0x13f4,
+        1,
+        0x13a0, 0x13f4,
 }; /* CR_Cherokee */
 
 /* 'Canadian_Aboriginal': Script */
 static const OnigCodePoint CR_Canadian_Aboriginal[] = {
-	2,
-	0x1400, 0x167f,
-	0x18b0, 0x18f5,
+        2,
+        0x1400, 0x167f,
+        0x18b0, 0x18f5,
 }; /* CR_Canadian_Aboriginal */
 
 /* 'Ogham': Script */
 static const OnigCodePoint CR_Ogham[] = {
-	1,
-	0x1680, 0x169c,
+        1,
+        0x1680, 0x169c,
 }; /* CR_Ogham */
 
 /* 'Runic': Script */
 static const OnigCodePoint CR_Runic[] = {
-	2,
-	0x16a0, 0x16ea,
-	0x16ee, 0x16f0,
+        2,
+        0x16a0, 0x16ea,
+        0x16ee, 0x16f0,
 }; /* CR_Runic */
 
 /* 'Khmer': Script */
 static const OnigCodePoint CR_Khmer[] = {
-	4,
-	0x1780, 0x17dd,
-	0x17e0, 0x17e9,
-	0x17f0, 0x17f9,
-	0x19e0, 0x19ff,
+        4,
+        0x1780, 0x17dd,
+        0x17e0, 0x17e9,
+        0x17f0, 0x17f9,
+        0x19e0, 0x19ff,
 }; /* CR_Khmer */
 
 /* 'Mongolian': Script */
 static const OnigCodePoint CR_Mongolian[] = {
-	6,
-	0x1800, 0x1801,
-	0x1804, 0x1804,
-	0x1806, 0x180e,
-	0x1810, 0x1819,
-	0x1820, 0x1877,
-	0x1880, 0x18aa,
+        6,
+        0x1800, 0x1801,
+        0x1804, 0x1804,
+        0x1806, 0x180e,
+        0x1810, 0x1819,
+        0x1820, 0x1877,
+        0x1880, 0x18aa,
 }; /* CR_Mongolian */
 
 /* 'Hiragana': Script */
 static const OnigCodePoint CR_Hiragana[] = {
-	3,
-	0x3041, 0x3096,
-	0x309d, 0x309f,
-	0x1f200, 0x1f200,
+        3,
+        0x3041, 0x3096,
+        0x309d, 0x309f,
+        0x1f200, 0x1f200,
 }; /* CR_Hiragana */
 
 /* 'Katakana': Script */
 static const OnigCodePoint CR_Katakana[] = {
-	7,
-	0x30a1, 0x30fa,
-	0x30fd, 0x30ff,
-	0x31f0, 0x31ff,
-	0x32d0, 0x32fe,
-	0x3300, 0x3357,
-	0xff66, 0xff6f,
-	0xff71, 0xff9d,
+        7,
+        0x30a1, 0x30fa,
+        0x30fd, 0x30ff,
+        0x31f0, 0x31ff,
+        0x32d0, 0x32fe,
+        0x3300, 0x3357,
+        0xff66, 0xff6f,
+        0xff71, 0xff9d,
 }; /* CR_Katakana */
 
 /* 'Bopomofo': Script */
 static const OnigCodePoint CR_Bopomofo[] = {
-	2,
-	0x3105, 0x312d,
-	0x31a0, 0x31b7,
+        2,
+        0x3105, 0x312d,
+        0x31a0, 0x31b7,
 }; /* CR_Bopomofo */
 
 /* 'Han': Script */
 static const OnigCodePoint CR_Han[] = {
-	15,
-	0x2e80, 0x2e99,
-	0x2e9b, 0x2ef3,
-	0x2f00, 0x2fd5,
-	0x3005, 0x3005,
-	0x3007, 0x3007,
-	0x3021, 0x3029,
-	0x3038, 0x303b,
-	0x3400, 0x4db5,
-	0x4e00, 0x9fcb,
-	0xf900, 0xfa2d,
-	0xfa30, 0xfa6d,
-	0xfa70, 0xfad9,
-	0x20000, 0x2a6d6,
-	0x2a700, 0x2b734,
-	0x2f800, 0x2fa1d,
+        15,
+        0x2e80, 0x2e99,
+        0x2e9b, 0x2ef3,
+        0x2f00, 0x2fd5,
+        0x3005, 0x3005,
+        0x3007, 0x3007,
+        0x3021, 0x3029,
+        0x3038, 0x303b,
+        0x3400, 0x4db5,
+        0x4e00, 0x9fcb,
+        0xf900, 0xfa2d,
+        0xfa30, 0xfa6d,
+        0xfa70, 0xfad9,
+        0x20000, 0x2a6d6,
+        0x2a700, 0x2b734,
+        0x2f800, 0x2fa1d,
 }; /* CR_Han */
 
 /* 'Yi': Script */
 static const OnigCodePoint CR_Yi[] = {
-	2,
-	0xa000, 0xa48c,
-	0xa490, 0xa4c6,
+        2,
+        0xa000, 0xa48c,
+        0xa490, 0xa4c6,
 }; /* CR_Yi */
 
 /* 'Old_Italic': Script */
 static const OnigCodePoint CR_Old_Italic[] = {
-	2,
-	0x10300, 0x1031e,
-	0x10320, 0x10323,
+        2,
+        0x10300, 0x1031e,
+        0x10320, 0x10323,
 }; /* CR_Old_Italic */
 
 /* 'Gothic': Script */
 static const OnigCodePoint CR_Gothic[] = {
-	1,
-	0x10330, 0x1034a,
+        1,
+        0x10330, 0x1034a,
 }; /* CR_Gothic */
 
 /* 'Deseret': Script */
 static const OnigCodePoint CR_Deseret[] = {
-	1,
-	0x10400, 0x1044f,
+        1,
+        0x10400, 0x1044f,
 }; /* CR_Deseret */
 
 /* 'Inherited': Script */
 static const OnigCodePoint CR_Inherited[] = {
-	23,
-	0x0300, 0x036f,
-	0x0485, 0x0486,
-	0x064b, 0x0655,
-	0x0670, 0x0670,
-	0x0951, 0x0952,
-	0x1cd0, 0x1cd2,
-	0x1cd4, 0x1ce0,
-	0x1ce2, 0x1ce8,
-	0x1ced, 0x1ced,
-	0x1dc0, 0x1de6,
-	0x1dfd, 0x1dff,
-	0x200c, 0x200d,
-	0x20d0, 0x20f0,
-	0x302a, 0x302f,
-	0x3099, 0x309a,
-	0xfe00, 0xfe0f,
-	0xfe20, 0xfe26,
-	0x101fd, 0x101fd,
-	0x1d167, 0x1d169,
-	0x1d17b, 0x1d182,
-	0x1d185, 0x1d18b,
-	0x1d1aa, 0x1d1ad,
-	0xe0100, 0xe01ef,
+        23,
+        0x0300, 0x036f,
+        0x0485, 0x0486,
+        0x064b, 0x0655,
+        0x0670, 0x0670,
+        0x0951, 0x0952,
+        0x1cd0, 0x1cd2,
+        0x1cd4, 0x1ce0,
+        0x1ce2, 0x1ce8,
+        0x1ced, 0x1ced,
+        0x1dc0, 0x1de6,
+        0x1dfd, 0x1dff,
+        0x200c, 0x200d,
+        0x20d0, 0x20f0,
+        0x302a, 0x302f,
+        0x3099, 0x309a,
+        0xfe00, 0xfe0f,
+        0xfe20, 0xfe26,
+        0x101fd, 0x101fd,
+        0x1d167, 0x1d169,
+        0x1d17b, 0x1d182,
+        0x1d185, 0x1d18b,
+        0x1d1aa, 0x1d1ad,
+        0xe0100, 0xe01ef,
 }; /* CR_Inherited */
 
 /* 'Tagalog': Script */
 static const OnigCodePoint CR_Tagalog[] = {
-	2,
-	0x1700, 0x170c,
-	0x170e, 0x1714,
+        2,
+        0x1700, 0x170c,
+        0x170e, 0x1714,
 }; /* CR_Tagalog */
 
 /* 'Hanunoo': Script */
 static const OnigCodePoint CR_Hanunoo[] = {
-	1,
-	0x1720, 0x1734,
+        1,
+        0x1720, 0x1734,
 }; /* CR_Hanunoo */
 
 /* 'Buhid': Script */
 static const OnigCodePoint CR_Buhid[] = {
-	1,
-	0x1740, 0x1753,
+        1,
+        0x1740, 0x1753,
 }; /* CR_Buhid */
 
 /* 'Tagbanwa': Script */
 static const OnigCodePoint CR_Tagbanwa[] = {
-	3,
-	0x1760, 0x176c,
-	0x176e, 0x1770,
-	0x1772, 0x1773,
+        3,
+        0x1760, 0x176c,
+        0x176e, 0x1770,
+        0x1772, 0x1773,
 }; /* CR_Tagbanwa */
 
 /* 'Limbu': Script */
 static const OnigCodePoint CR_Limbu[] = {
-	5,
-	0x1900, 0x191c,
-	0x1920, 0x192b,
-	0x1930, 0x193b,
-	0x1940, 0x1940,
-	0x1944, 0x194f,
+        5,
+        0x1900, 0x191c,
+        0x1920, 0x192b,
+        0x1930, 0x193b,
+        0x1940, 0x1940,
+        0x1944, 0x194f,
 }; /* CR_Limbu */
 
 /* 'Tai_Le': Script */
 static const OnigCodePoint CR_Tai_Le[] = {
-	2,
-	0x1950, 0x196d,
-	0x1970, 0x1974,
+        2,
+        0x1950, 0x196d,
+        0x1970, 0x1974,
 }; /* CR_Tai_Le */
 
 /* 'Linear_B': Script */
 static const OnigCodePoint CR_Linear_B[] = {
-	7,
-	0x10000, 0x1000b,
-	0x1000d, 0x10026,
-	0x10028, 0x1003a,
-	0x1003c, 0x1003d,
-	0x1003f, 0x1004d,
-	0x10050, 0x1005d,
-	0x10080, 0x100fa,
+        7,
+        0x10000, 0x1000b,
+        0x1000d, 0x10026,
+        0x10028, 0x1003a,
+        0x1003c, 0x1003d,
+        0x1003f, 0x1004d,
+        0x10050, 0x1005d,
+        0x10080, 0x100fa,
 }; /* CR_Linear_B */
 
 /* 'Ugaritic': Script */
 static const OnigCodePoint CR_Ugaritic[] = {
-	2,
-	0x10380, 0x1039d,
-	0x1039f, 0x1039f,
+        2,
+        0x10380, 0x1039d,
+        0x1039f, 0x1039f,
 }; /* CR_Ugaritic */
 
 /* 'Shavian': Script */
 static const OnigCodePoint CR_Shavian[] = {
-	1,
-	0x10450, 0x1047f,
+        1,
+        0x10450, 0x1047f,
 }; /* CR_Shavian */
 
 /* 'Osmanya': Script */
 static const OnigCodePoint CR_Osmanya[] = {
-	2,
-	0x10480, 0x1049d,
-	0x104a0, 0x104a9,
+        2,
+        0x10480, 0x1049d,
+        0x104a0, 0x104a9,
 }; /* CR_Osmanya */
 
 /* 'Cypriot': Script */
 static const OnigCodePoint CR_Cypriot[] = {
-	6,
-	0x10800, 0x10805,
-	0x10808, 0x10808,
-	0x1080a, 0x10835,
-	0x10837, 0x10838,
-	0x1083c, 0x1083c,
-	0x1083f, 0x1083f,
+        6,
+        0x10800, 0x10805,
+        0x10808, 0x10808,
+        0x1080a, 0x10835,
+        0x10837, 0x10838,
+        0x1083c, 0x1083c,
+        0x1083f, 0x1083f,
 }; /* CR_Cypriot */
 
 /* 'Braille': Script */
 static const OnigCodePoint CR_Braille[] = {
-	1,
-	0x2800, 0x28ff,
+        1,
+        0x2800, 0x28ff,
 }; /* CR_Braille */
 
 /* 'Buginese': Script */
 static const OnigCodePoint CR_Buginese[] = {
-	2,
-	0x1a00, 0x1a1b,
-	0x1a1e, 0x1a1f,
+        2,
+        0x1a00, 0x1a1b,
+        0x1a1e, 0x1a1f,
 }; /* CR_Buginese */
 
 /* 'Coptic': Script */
 static const OnigCodePoint CR_Coptic[] = {
-	3,
-	0x03e2, 0x03ef,
-	0x2c80, 0x2cf1,
-	0x2cf9, 0x2cff,
+        3,
+        0x03e2, 0x03ef,
+        0x2c80, 0x2cf1,
+        0x2cf9, 0x2cff,
 }; /* CR_Coptic */
 
 /* 'New_Tai_Lue': Script */
 static const OnigCodePoint CR_New_Tai_Lue[] = {
-	4,
-	0x1980, 0x19ab,
-	0x19b0, 0x19c9,
-	0x19d0, 0x19da,
-	0x19de, 0x19df,
+        4,
+        0x1980, 0x19ab,
+        0x19b0, 0x19c9,
+        0x19d0, 0x19da,
+        0x19de, 0x19df,
 }; /* CR_New_Tai_Lue */
 
 /* 'Glagolitic': Script */
 static const OnigCodePoint CR_Glagolitic[] = {
-	2,
-	0x2c00, 0x2c2e,
-	0x2c30, 0x2c5e,
+        2,
+        0x2c00, 0x2c2e,
+        0x2c30, 0x2c5e,
 }; /* CR_Glagolitic */
 
 /* 'Tifinagh': Script */
 static const OnigCodePoint CR_Tifinagh[] = {
-	2,
-	0x2d30, 0x2d65,
-	0x2d6f, 0x2d6f,
+        2,
+        0x2d30, 0x2d65,
+        0x2d6f, 0x2d6f,
 }; /* CR_Tifinagh */
 
 /* 'Syloti_Nagri': Script */
 static const OnigCodePoint CR_Syloti_Nagri[] = {
-	1,
-	0xa800, 0xa82b,
+        1,
+        0xa800, 0xa82b,
 }; /* CR_Syloti_Nagri */
 
 /* 'Old_Persian': Script */
 static const OnigCodePoint CR_Old_Persian[] = {
-	2,
-	0x103a0, 0x103c3,
-	0x103c8, 0x103d5,
+        2,
+        0x103a0, 0x103c3,
+        0x103c8, 0x103d5,
 }; /* CR_Old_Persian */
 
 /* 'Kharoshthi': Script */
 static const OnigCodePoint CR_Kharoshthi[] = {
-	8,
-	0x10a00, 0x10a03,
-	0x10a05, 0x10a06,
-	0x10a0c, 0x10a13,
-	0x10a15, 0x10a17,
-	0x10a19, 0x10a33,
-	0x10a38, 0x10a3a,
-	0x10a3f, 0x10a47,
-	0x10a50, 0x10a58,
+        8,
+        0x10a00, 0x10a03,
+        0x10a05, 0x10a06,
+        0x10a0c, 0x10a13,
+        0x10a15, 0x10a17,
+        0x10a19, 0x10a33,
+        0x10a38, 0x10a3a,
+        0x10a3f, 0x10a47,
+        0x10a50, 0x10a58,
 }; /* CR_Kharoshthi */
 
 /* 'Balinese': Script */
 static const OnigCodePoint CR_Balinese[] = {
-	2,
-	0x1b00, 0x1b4b,
-	0x1b50, 0x1b7c,
+        2,
+        0x1b00, 0x1b4b,
+        0x1b50, 0x1b7c,
 }; /* CR_Balinese */
 
 /* 'Cuneiform': Script */
 static const OnigCodePoint CR_Cuneiform[] = {
-	3,
-	0x12000, 0x1236e,
-	0x12400, 0x12462,
-	0x12470, 0x12473,
+        3,
+        0x12000, 0x1236e,
+        0x12400, 0x12462,
+        0x12470, 0x12473,
 }; /* CR_Cuneiform */
 
 /* 'Phoenician': Script */
 static const OnigCodePoint CR_Phoenician[] = {
-	2,
-	0x10900, 0x1091b,
-	0x1091f, 0x1091f,
+        2,
+        0x10900, 0x1091b,
+        0x1091f, 0x1091f,
 }; /* CR_Phoenician */
 
 /* 'Phags_Pa': Script */
 static const OnigCodePoint CR_Phags_Pa[] = {
-	1,
-	0xa840, 0xa877,
+        1,
+        0xa840, 0xa877,
 }; /* CR_Phags_Pa */
 
 /* 'Nko': Script */
 static const OnigCodePoint CR_Nko[] = {
-	1,
-	0x07c0, 0x07fa,
+        1,
+        0x07c0, 0x07fa,
 }; /* CR_Nko */
 
 /* 'Sundanese': Script */
 static const OnigCodePoint CR_Sundanese[] = {
-	2,
-	0x1b80, 0x1baa,
-	0x1bae, 0x1bb9,
+        2,
+        0x1b80, 0x1baa,
+        0x1bae, 0x1bb9,
 }; /* CR_Sundanese */
 
 /* 'Lepcha': Script */
 static const OnigCodePoint CR_Lepcha[] = {
-	3,
-	0x1c00, 0x1c37,
-	0x1c3b, 0x1c49,
-	0x1c4d, 0x1c4f,
+        3,
+        0x1c00, 0x1c37,
+        0x1c3b, 0x1c49,
+        0x1c4d, 0x1c4f,
 }; /* CR_Lepcha */
 
 /* 'Ol_Chiki': Script */
 static const OnigCodePoint CR_Ol_Chiki[] = {
-	1,
-	0x1c50, 0x1c7f,
+        1,
+        0x1c50, 0x1c7f,
 }; /* CR_Ol_Chiki */
 
 /* 'Vai': Script */
 static const OnigCodePoint CR_Vai[] = {
-	1,
-	0xa500, 0xa62b,
+        1,
+        0xa500, 0xa62b,
 }; /* CR_Vai */
 
 /* 'Saurashtra': Script */
 static const OnigCodePoint CR_Saurashtra[] = {
-	2,
-	0xa880, 0xa8c4,
-	0xa8ce, 0xa8d9,
+        2,
+        0xa880, 0xa8c4,
+        0xa8ce, 0xa8d9,
 }; /* CR_Saurashtra */
 
 /* 'Kayah_Li': Script */
 static const OnigCodePoint CR_Kayah_Li[] = {
-	1,
-	0xa900, 0xa92f,
+        1,
+        0xa900, 0xa92f,
 }; /* CR_Kayah_Li */
 
 /* 'Rejang': Script */
 static const OnigCodePoint CR_Rejang[] = {
-	2,
-	0xa930, 0xa953,
-	0xa95f, 0xa95f,
+        2,
+        0xa930, 0xa953,
+        0xa95f, 0xa95f,
 }; /* CR_Rejang */
 
 /* 'Lycian': Script */
 static const OnigCodePoint CR_Lycian[] = {
-	1,
-	0x10280, 0x1029c,
+        1,
+        0x10280, 0x1029c,
 }; /* CR_Lycian */
 
 /* 'Carian': Script */
 static const OnigCodePoint CR_Carian[] = {
-	1,
-	0x102a0, 0x102d0,
+        1,
+        0x102a0, 0x102d0,
 }; /* CR_Carian */
 
 /* 'Lydian': Script */
 static const OnigCodePoint CR_Lydian[] = {
-	2,
-	0x10920, 0x10939,
-	0x1093f, 0x1093f,
+        2,
+        0x10920, 0x10939,
+        0x1093f, 0x1093f,
 }; /* CR_Lydian */
 
 /* 'Cham': Script */
 static const OnigCodePoint CR_Cham[] = {
-	4,
-	0xaa00, 0xaa36,
-	0xaa40, 0xaa4d,
-	0xaa50, 0xaa59,
-	0xaa5c, 0xaa5f,
+        4,
+        0xaa00, 0xaa36,
+        0xaa40, 0xaa4d,
+        0xaa50, 0xaa59,
+        0xaa5c, 0xaa5f,
 }; /* CR_Cham */
 
 /* 'Tai_Tham': Script */
 static const OnigCodePoint CR_Tai_Tham[] = {
-	5,
-	0x1a20, 0x1a5e,
-	0x1a60, 0x1a7c,
-	0x1a7f, 0x1a89,
-	0x1a90, 0x1a99,
-	0x1aa0, 0x1aad,
+        5,
+        0x1a20, 0x1a5e,
+        0x1a60, 0x1a7c,
+        0x1a7f, 0x1a89,
+        0x1a90, 0x1a99,
+        0x1aa0, 0x1aad,
 }; /* CR_Tai_Tham */
 
 /* 'Tai_Viet': Script */
 static const OnigCodePoint CR_Tai_Viet[] = {
-	2,
-	0xaa80, 0xaac2,
-	0xaadb, 0xaadf,
+        2,
+        0xaa80, 0xaac2,
+        0xaadb, 0xaadf,
 }; /* CR_Tai_Viet */
 
 /* 'Avestan': Script */
 static const OnigCodePoint CR_Avestan[] = {
-	2,
-	0x10b00, 0x10b35,
-	0x10b39, 0x10b3f,
+        2,
+        0x10b00, 0x10b35,
+        0x10b39, 0x10b3f,
 }; /* CR_Avestan */
 
 /* 'Egyptian_Hieroglyphs': Script */
 static const OnigCodePoint CR_Egyptian_Hieroglyphs[] = {
-	1,
-	0x13000, 0x1342e,
+        1,
+        0x13000, 0x1342e,
 }; /* CR_Egyptian_Hieroglyphs */
 
 /* 'Samaritan': Script */
 static const OnigCodePoint CR_Samaritan[] = {
-	2,
-	0x0800, 0x082d,
-	0x0830, 0x083e,
+        2,
+        0x0800, 0x082d,
+        0x0830, 0x083e,
 }; /* CR_Samaritan */
 
 /* 'Lisu': Script */
 static const OnigCodePoint CR_Lisu[] = {
-	1,
-	0xa4d0, 0xa4ff,
+        1,
+        0xa4d0, 0xa4ff,
 }; /* CR_Lisu */
 
 /* 'Bamum': Script */
 static const OnigCodePoint CR_Bamum[] = {
-	1,
-	0xa6a0, 0xa6f7,
+        1,
+        0xa6a0, 0xa6f7,
 }; /* CR_Bamum */
 
 /* 'Javanese': Script */
 static const OnigCodePoint CR_Javanese[] = {
-	3,
-	0xa980, 0xa9cd,
-	0xa9cf, 0xa9d9,
-	0xa9de, 0xa9df,
+        3,
+        0xa980, 0xa9cd,
+        0xa9cf, 0xa9d9,
+        0xa9de, 0xa9df,
 }; /* CR_Javanese */
 
 /* 'Meetei_Mayek': Script */
 static const OnigCodePoint CR_Meetei_Mayek[] = {
-	2,
-	0xabc0, 0xabed,
-	0xabf0, 0xabf9,
+        2,
+        0xabc0, 0xabed,
+        0xabf0, 0xabf9,
 }; /* CR_Meetei_Mayek */
 
 /* 'Imperial_Aramaic': Script */
 static const OnigCodePoint CR_Imperial_Aramaic[] = {
-	2,
-	0x10840, 0x10855,
-	0x10857, 0x1085f,
+        2,
+        0x10840, 0x10855,
+        0x10857, 0x1085f,
 }; /* CR_Imperial_Aramaic */
 
 /* 'Old_South_Arabian': Script */
 static const OnigCodePoint CR_Old_South_Arabian[] = {
-	1,
-	0x10a60, 0x10a7f,
+        1,
+        0x10a60, 0x10a7f,
 }; /* CR_Old_South_Arabian */
 
 /* 'Inscriptional_Parthian': Script */
 static const OnigCodePoint CR_Inscriptional_Parthian[] = {
-	2,
-	0x10b40, 0x10b55,
-	0x10b58, 0x10b5f,
+        2,
+        0x10b40, 0x10b55,
+        0x10b58, 0x10b5f,
 }; /* CR_Inscriptional_Parthian */
 
 /* 'Inscriptional_Pahlavi': Script */
 static const OnigCodePoint CR_Inscriptional_Pahlavi[] = {
-	2,
-	0x10b60, 0x10b72,
-	0x10b78, 0x10b7f,
+        2,
+        0x10b60, 0x10b72,
+        0x10b78, 0x10b7f,
 }; /* CR_Inscriptional_Pahlavi */
 
 /* 'Old_Turkic': Script */
 static const OnigCodePoint CR_Old_Turkic[] = {
-	1,
-	0x10c00, 0x10c48,
+        1,
+        0x10c00, 0x10c48,
 }; /* CR_Old_Turkic */
 
 /* 'Kaithi': Script */
 static const OnigCodePoint CR_Kaithi[] = {
-	1,
-	0x11080, 0x110c1,
+        1,
+        0x11080, 0x110c1,
 }; /* CR_Kaithi */
 
 /* 'White_Space': Binary Property */
 static const OnigCodePoint CR_White_Space[] = {
-	11,
-	0x0009, 0x000d,
-	0x0020, 0x0020,
-	0x0085, 0x0085,
-	0x00a0, 0x00a0,
-	0x1680, 0x1680,
-	0x180e, 0x180e,
-	0x2000, 0x200a,
-	0x2028, 0x2029,
-	0x202f, 0x202f,
-	0x205f, 0x205f,
-	0x3000, 0x3000,
+        11,
+        0x0009, 0x000d,
+        0x0020, 0x0020,
+        0x0085, 0x0085,
+        0x00a0, 0x00a0,
+        0x1680, 0x1680,
+        0x180e, 0x180e,
+        0x2000, 0x200a,
+        0x2028, 0x2029,
+        0x202f, 0x202f,
+        0x205f, 0x205f,
+        0x3000, 0x3000,
 }; /* CR_White_Space */
 
 /* 'Bidi_Control': Binary Property */
 static const OnigCodePoint CR_Bidi_Control[] = {
-	2,
-	0x200e, 0x200f,
-	0x202a, 0x202e,
+        2,
+        0x200e, 0x200f,
+        0x202a, 0x202e,
 }; /* CR_Bidi_Control */
 
 /* 'Join_Control': Binary Property */
 static const OnigCodePoint CR_Join_Control[] = {
-	1,
-	0x200c, 0x200d,
+        1,
+        0x200c, 0x200d,
 }; /* CR_Join_Control */
 
 /* 'Dash': Binary Property */
 static const OnigCodePoint CR_Dash[] = {
-	19,
-	0x002d, 0x002d,
-	0x058a, 0x058a,
-	0x05be, 0x05be,
-	0x1400, 0x1400,
-	0x1806, 0x1806,
-	0x2010, 0x2015,
-	0x2053, 0x2053,
-	0x207b, 0x207b,
-	0x208b, 0x208b,
-	0x2212, 0x2212,
-	0x2e17, 0x2e17,
-	0x2e1a, 0x2e1a,
-	0x301c, 0x301c,
-	0x3030, 0x3030,
-	0x30a0, 0x30a0,
-	0xfe31, 0xfe32,
-	0xfe58, 0xfe58,
-	0xfe63, 0xfe63,
-	0xff0d, 0xff0d,
+        19,
+        0x002d, 0x002d,
+        0x058a, 0x058a,
+        0x05be, 0x05be,
+        0x1400, 0x1400,
+        0x1806, 0x1806,
+        0x2010, 0x2015,
+        0x2053, 0x2053,
+        0x207b, 0x207b,
+        0x208b, 0x208b,
+        0x2212, 0x2212,
+        0x2e17, 0x2e17,
+        0x2e1a, 0x2e1a,
+        0x301c, 0x301c,
+        0x3030, 0x3030,
+        0x30a0, 0x30a0,
+        0xfe31, 0xfe32,
+        0xfe58, 0xfe58,
+        0xfe63, 0xfe63,
+        0xff0d, 0xff0d,
 }; /* CR_Dash */
 
 /* 'Hyphen': Binary Property */
 static const OnigCodePoint CR_Hyphen[] = {
-	10,
-	0x002d, 0x002d,
-	0x00ad, 0x00ad,
-	0x058a, 0x058a,
-	0x1806, 0x1806,
-	0x2010, 0x2011,
-	0x2e17, 0x2e17,
-	0x30fb, 0x30fb,
-	0xfe63, 0xfe63,
-	0xff0d, 0xff0d,
-	0xff65, 0xff65,
+        10,
+        0x002d, 0x002d,
+        0x00ad, 0x00ad,
+        0x058a, 0x058a,
+        0x1806, 0x1806,
+        0x2010, 0x2011,
+        0x2e17, 0x2e17,
+        0x30fb, 0x30fb,
+        0xfe63, 0xfe63,
+        0xff0d, 0xff0d,
+        0xff65, 0xff65,
 }; /* CR_Hyphen */
 
 /* 'Quotation_Mark': Binary Property */
 static const OnigCodePoint CR_Quotation_Mark[] = {
-	12,
-	0x0022, 0x0022,
-	0x0027, 0x0027,
-	0x00ab, 0x00ab,
-	0x00bb, 0x00bb,
-	0x2018, 0x201f,
-	0x2039, 0x203a,
-	0x300c, 0x300f,
-	0x301d, 0x301f,
-	0xfe41, 0xfe44,
-	0xff02, 0xff02,
-	0xff07, 0xff07,
-	0xff62, 0xff63,
+        12,
+        0x0022, 0x0022,
+        0x0027, 0x0027,
+        0x00ab, 0x00ab,
+        0x00bb, 0x00bb,
+        0x2018, 0x201f,
+        0x2039, 0x203a,
+        0x300c, 0x300f,
+        0x301d, 0x301f,
+        0xfe41, 0xfe44,
+        0xff02, 0xff02,
+        0xff07, 0xff07,
+        0xff62, 0xff63,
 }; /* CR_Quotation_Mark */
 
 /* 'Terminal_Punctuation': Binary Property */
 static const OnigCodePoint CR_Terminal_Punctuation[] = {
-	65,
-	0x0021, 0x0021,
-	0x002c, 0x002c,
-	0x002e, 0x002e,
-	0x003a, 0x003b,
-	0x003f, 0x003f,
-	0x037e, 0x037e,
-	0x0387, 0x0387,
-	0x0589, 0x0589,
-	0x05c3, 0x05c3,
-	0x060c, 0x060c,
-	0x061b, 0x061b,
-	0x061f, 0x061f,
-	0x06d4, 0x06d4,
-	0x0700, 0x070a,
-	0x070c, 0x070c,
-	0x07f8, 0x07f9,
-	0x0830, 0x083e,
-	0x0964, 0x0965,
-	0x0e5a, 0x0e5b,
-	0x0f08, 0x0f08,
-	0x0f0d, 0x0f12,
-	0x104a, 0x104b,
-	0x1361, 0x1368,
-	0x166d, 0x166e,
-	0x16eb, 0x16ed,
-	0x17d4, 0x17d6,
-	0x17da, 0x17da,
-	0x1802, 0x1805,
-	0x1808, 0x1809,
-	0x1944, 0x1945,
-	0x1aa8, 0x1aab,
-	0x1b5a, 0x1b5b,
-	0x1b5d, 0x1b5f,
-	0x1c3b, 0x1c3f,
-	0x1c7e, 0x1c7f,
-	0x203c, 0x203d,
-	0x2047, 0x2049,
-	0x2e2e, 0x2e2e,
-	0x3001, 0x3002,
-	0xa4fe, 0xa4ff,
-	0xa60d, 0xa60f,
-	0xa6f3, 0xa6f7,
-	0xa876, 0xa877,
-	0xa8ce, 0xa8cf,
-	0xa92f, 0xa92f,
-	0xa9c7, 0xa9c9,
-	0xaa5d, 0xaa5f,
-	0xaadf, 0xaadf,
-	0xabeb, 0xabeb,
-	0xfe50, 0xfe52,
-	0xfe54, 0xfe57,
-	0xff01, 0xff01,
-	0xff0c, 0xff0c,
-	0xff0e, 0xff0e,
-	0xff1a, 0xff1b,
-	0xff1f, 0xff1f,
-	0xff61, 0xff61,
-	0xff64, 0xff64,
-	0x1039f, 0x1039f,
-	0x103d0, 0x103d0,
-	0x10857, 0x10857,
-	0x1091f, 0x1091f,
-	0x10b3a, 0x10b3f,
-	0x110be, 0x110c1,
-	0x12470, 0x12473,
+        65,
+        0x0021, 0x0021,
+        0x002c, 0x002c,
+        0x002e, 0x002e,
+        0x003a, 0x003b,
+        0x003f, 0x003f,
+        0x037e, 0x037e,
+        0x0387, 0x0387,
+        0x0589, 0x0589,
+        0x05c3, 0x05c3,
+        0x060c, 0x060c,
+        0x061b, 0x061b,
+        0x061f, 0x061f,
+        0x06d4, 0x06d4,
+        0x0700, 0x070a,
+        0x070c, 0x070c,
+        0x07f8, 0x07f9,
+        0x0830, 0x083e,
+        0x0964, 0x0965,
+        0x0e5a, 0x0e5b,
+        0x0f08, 0x0f08,
+        0x0f0d, 0x0f12,
+        0x104a, 0x104b,
+        0x1361, 0x1368,
+        0x166d, 0x166e,
+        0x16eb, 0x16ed,
+        0x17d4, 0x17d6,
+        0x17da, 0x17da,
+        0x1802, 0x1805,
+        0x1808, 0x1809,
+        0x1944, 0x1945,
+        0x1aa8, 0x1aab,
+        0x1b5a, 0x1b5b,
+        0x1b5d, 0x1b5f,
+        0x1c3b, 0x1c3f,
+        0x1c7e, 0x1c7f,
+        0x203c, 0x203d,
+        0x2047, 0x2049,
+        0x2e2e, 0x2e2e,
+        0x3001, 0x3002,
+        0xa4fe, 0xa4ff,
+        0xa60d, 0xa60f,
+        0xa6f3, 0xa6f7,
+        0xa876, 0xa877,
+        0xa8ce, 0xa8cf,
+        0xa92f, 0xa92f,
+        0xa9c7, 0xa9c9,
+        0xaa5d, 0xaa5f,
+        0xaadf, 0xaadf,
+        0xabeb, 0xabeb,
+        0xfe50, 0xfe52,
+        0xfe54, 0xfe57,
+        0xff01, 0xff01,
+        0xff0c, 0xff0c,
+        0xff0e, 0xff0e,
+        0xff1a, 0xff1b,
+        0xff1f, 0xff1f,
+        0xff61, 0xff61,
+        0xff64, 0xff64,
+        0x1039f, 0x1039f,
+        0x103d0, 0x103d0,
+        0x10857, 0x10857,
+        0x1091f, 0x1091f,
+        0x10b3a, 0x10b3f,
+        0x110be, 0x110c1,
+        0x12470, 0x12473,
 }; /* CR_Terminal_Punctuation */
 
 /* 'Other_Math': Binary Property */
 static const OnigCodePoint CR_Other_Math[] = {
-	99,
-	0x005e, 0x005e,
-	0x03d0, 0x03d2,
-	0x03d5, 0x03d5,
-	0x03f0, 0x03f1,
-	0x03f4, 0x03f5,
-	0x2016, 0x2016,
-	0x2032, 0x2034,
-	0x2040, 0x2040,
-	0x2061, 0x2064,
-	0x207d, 0x207e,
-	0x208d, 0x208e,
-	0x20d0, 0x20dc,
-	0x20e1, 0x20e1,
-	0x20e5, 0x20e6,
-	0x20eb, 0x20ef,
-	0x2102, 0x2102,
-	0x210a, 0x2113,
-	0x2115, 0x2115,
-	0x2119, 0x211d,
-	0x2124, 0x2124,
-	0x2128, 0x2129,
-	0x212c, 0x212d,
-	0x212f, 0x2131,
-	0x2133, 0x2138,
-	0x213c, 0x213f,
-	0x2145, 0x2149,
-	0x2195, 0x2199,
-	0x219c, 0x219f,
-	0x21a1, 0x21a2,
-	0x21a4, 0x21a5,
-	0x21a7, 0x21a7,
-	0x21a9, 0x21ad,
-	0x21b0, 0x21b1,
-	0x21b6, 0x21b7,
-	0x21bc, 0x21cd,
-	0x21d0, 0x21d1,
-	0x21d3, 0x21d3,
-	0x21d5, 0x21db,
-	0x21dd, 0x21dd,
-	0x21e4, 0x21e5,
-	0x23b4, 0x23b5,
-	0x23b7, 0x23b7,
-	0x23d0, 0x23d0,
-	0x23e2, 0x23e2,
-	0x25a0, 0x25a1,
-	0x25ae, 0x25b6,
-	0x25bc, 0x25c0,
-	0x25c6, 0x25c7,
-	0x25ca, 0x25cb,
-	0x25cf, 0x25d3,
-	0x25e2, 0x25e2,
-	0x25e4, 0x25e4,
-	0x25e7, 0x25ec,
-	0x2605, 0x2606,
-	0x2640, 0x2640,
-	0x2642, 0x2642,
-	0x2660, 0x2663,
-	0x266d, 0x266e,
-	0x27c5, 0x27c6,
-	0x27e6, 0x27ef,
-	0x2983, 0x2998,
-	0x29d8, 0x29db,
-	0x29fc, 0x29fd,
-	0xfe61, 0xfe61,
-	0xfe63, 0xfe63,
-	0xfe68, 0xfe68,
-	0xff3c, 0xff3c,
-	0xff3e, 0xff3e,
-	0x1d400, 0x1d454,
-	0x1d456, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d51e, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d552, 0x1d6a5,
-	0x1d6a8, 0x1d6c0,
-	0x1d6c2, 0x1d6da,
-	0x1d6dc, 0x1d6fa,
-	0x1d6fc, 0x1d714,
-	0x1d716, 0x1d734,
-	0x1d736, 0x1d74e,
-	0x1d750, 0x1d76e,
-	0x1d770, 0x1d788,
-	0x1d78a, 0x1d7a8,
-	0x1d7aa, 0x1d7c2,
-	0x1d7c4, 0x1d7cb,
-	0x1d7ce, 0x1d7ff,
+        99,
+        0x005e, 0x005e,
+        0x03d0, 0x03d2,
+        0x03d5, 0x03d5,
+        0x03f0, 0x03f1,
+        0x03f4, 0x03f5,
+        0x2016, 0x2016,
+        0x2032, 0x2034,
+        0x2040, 0x2040,
+        0x2061, 0x2064,
+        0x207d, 0x207e,
+        0x208d, 0x208e,
+        0x20d0, 0x20dc,
+        0x20e1, 0x20e1,
+        0x20e5, 0x20e6,
+        0x20eb, 0x20ef,
+        0x2102, 0x2102,
+        0x210a, 0x2113,
+        0x2115, 0x2115,
+        0x2119, 0x211d,
+        0x2124, 0x2124,
+        0x2128, 0x2129,
+        0x212c, 0x212d,
+        0x212f, 0x2131,
+        0x2133, 0x2138,
+        0x213c, 0x213f,
+        0x2145, 0x2149,
+        0x2195, 0x2199,
+        0x219c, 0x219f,
+        0x21a1, 0x21a2,
+        0x21a4, 0x21a5,
+        0x21a7, 0x21a7,
+        0x21a9, 0x21ad,
+        0x21b0, 0x21b1,
+        0x21b6, 0x21b7,
+        0x21bc, 0x21cd,
+        0x21d0, 0x21d1,
+        0x21d3, 0x21d3,
+        0x21d5, 0x21db,
+        0x21dd, 0x21dd,
+        0x21e4, 0x21e5,
+        0x23b4, 0x23b5,
+        0x23b7, 0x23b7,
+        0x23d0, 0x23d0,
+        0x23e2, 0x23e2,
+        0x25a0, 0x25a1,
+        0x25ae, 0x25b6,
+        0x25bc, 0x25c0,
+        0x25c6, 0x25c7,
+        0x25ca, 0x25cb,
+        0x25cf, 0x25d3,
+        0x25e2, 0x25e2,
+        0x25e4, 0x25e4,
+        0x25e7, 0x25ec,
+        0x2605, 0x2606,
+        0x2640, 0x2640,
+        0x2642, 0x2642,
+        0x2660, 0x2663,
+        0x266d, 0x266e,
+        0x27c5, 0x27c6,
+        0x27e6, 0x27ef,
+        0x2983, 0x2998,
+        0x29d8, 0x29db,
+        0x29fc, 0x29fd,
+        0xfe61, 0xfe61,
+        0xfe63, 0xfe63,
+        0xfe68, 0xfe68,
+        0xff3c, 0xff3c,
+        0xff3e, 0xff3e,
+        0x1d400, 0x1d454,
+        0x1d456, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d51e, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d552, 0x1d6a5,
+        0x1d6a8, 0x1d6c0,
+        0x1d6c2, 0x1d6da,
+        0x1d6dc, 0x1d6fa,
+        0x1d6fc, 0x1d714,
+        0x1d716, 0x1d734,
+        0x1d736, 0x1d74e,
+        0x1d750, 0x1d76e,
+        0x1d770, 0x1d788,
+        0x1d78a, 0x1d7a8,
+        0x1d7aa, 0x1d7c2,
+        0x1d7c4, 0x1d7cb,
+        0x1d7ce, 0x1d7ff,
 }; /* CR_Other_Math */
 
 /* 'Hex_Digit': Binary Property */
 static const OnigCodePoint CR_Hex_Digit[] = {
-	6,
-	0x0030, 0x0039,
-	0x0041, 0x0046,
-	0x0061, 0x0066,
-	0xff10, 0xff19,
-	0xff21, 0xff26,
-	0xff41, 0xff46,
+        6,
+        0x0030, 0x0039,
+        0x0041, 0x0046,
+        0x0061, 0x0066,
+        0xff10, 0xff19,
+        0xff21, 0xff26,
+        0xff41, 0xff46,
 }; /* CR_Hex_Digit */
 
 /* 'ASCII_Hex_Digit': Binary Property */
 static const OnigCodePoint CR_ASCII_Hex_Digit[] = {
-	3,
-	0x0030, 0x0039,
-	0x0041, 0x0046,
-	0x0061, 0x0066,
+        3,
+        0x0030, 0x0039,
+        0x0041, 0x0046,
+        0x0061, 0x0066,
 }; /* CR_ASCII_Hex_Digit */
 
 /* 'Other_Alphabetic': Binary Property */
 static const OnigCodePoint CR_Other_Alphabetic[] = {
-	141,
-	0x0345, 0x0345,
-	0x05b0, 0x05bd,
-	0x05bf, 0x05bf,
-	0x05c1, 0x05c2,
-	0x05c4, 0x05c5,
-	0x05c7, 0x05c7,
-	0x0610, 0x061a,
-	0x064b, 0x0657,
-	0x0659, 0x065e,
-	0x0670, 0x0670,
-	0x06d6, 0x06dc,
-	0x06e1, 0x06e4,
-	0x06e7, 0x06e8,
-	0x06ed, 0x06ed,
-	0x0711, 0x0711,
-	0x0730, 0x073f,
-	0x07a6, 0x07b0,
-	0x0816, 0x0817,
-	0x081b, 0x0823,
-	0x0825, 0x0827,
-	0x0829, 0x082c,
-	0x0900, 0x0903,
-	0x093e, 0x094c,
-	0x094e, 0x094e,
-	0x0955, 0x0955,
-	0x0962, 0x0963,
-	0x0981, 0x0983,
-	0x09be, 0x09c4,
-	0x09c7, 0x09c8,
-	0x09cb, 0x09cc,
-	0x09d7, 0x09d7,
-	0x09e2, 0x09e3,
-	0x0a01, 0x0a03,
-	0x0a3e, 0x0a42,
-	0x0a47, 0x0a48,
-	0x0a4b, 0x0a4c,
-	0x0a51, 0x0a51,
-	0x0a70, 0x0a71,
-	0x0a75, 0x0a75,
-	0x0a81, 0x0a83,
-	0x0abe, 0x0ac5,
-	0x0ac7, 0x0ac9,
-	0x0acb, 0x0acc,
-	0x0ae2, 0x0ae3,
-	0x0b01, 0x0b03,
-	0x0b3e, 0x0b44,
-	0x0b47, 0x0b48,
-	0x0b4b, 0x0b4c,
-	0x0b56, 0x0b57,
-	0x0b62, 0x0b63,
-	0x0b82, 0x0b82,
-	0x0bbe, 0x0bc2,
-	0x0bc6, 0x0bc8,
-	0x0bca, 0x0bcc,
-	0x0bd7, 0x0bd7,
-	0x0c01, 0x0c03,
-	0x0c3e, 0x0c44,
-	0x0c46, 0x0c48,
-	0x0c4a, 0x0c4c,
-	0x0c55, 0x0c56,
-	0x0c62, 0x0c63,
-	0x0c82, 0x0c83,
-	0x0cbe, 0x0cc4,
-	0x0cc6, 0x0cc8,
-	0x0cca, 0x0ccc,
-	0x0cd5, 0x0cd6,
-	0x0ce2, 0x0ce3,
-	0x0d02, 0x0d03,
-	0x0d3e, 0x0d44,
-	0x0d46, 0x0d48,
-	0x0d4a, 0x0d4c,
-	0x0d57, 0x0d57,
-	0x0d62, 0x0d63,
-	0x0d82, 0x0d83,
-	0x0dcf, 0x0dd4,
-	0x0dd6, 0x0dd6,
-	0x0dd8, 0x0ddf,
-	0x0df2, 0x0df3,
-	0x0e31, 0x0e31,
-	0x0e34, 0x0e3a,
-	0x0e4d, 0x0e4d,
-	0x0eb1, 0x0eb1,
-	0x0eb4, 0x0eb9,
-	0x0ebb, 0x0ebc,
-	0x0ecd, 0x0ecd,
-	0x0f71, 0x0f81,
-	0x0f90, 0x0f97,
-	0x0f99, 0x0fbc,
-	0x102b, 0x1036,
-	0x1038, 0x1038,
-	0x103b, 0x103e,
-	0x1056, 0x1059,
-	0x105e, 0x1060,
-	0x1062, 0x1062,
-	0x1067, 0x1068,
-	0x1071, 0x1074,
-	0x1082, 0x1086,
-	0x109c, 0x109d,
-	0x135f, 0x135f,
-	0x1712, 0x1713,
-	0x1732, 0x1733,
-	0x1752, 0x1753,
-	0x1772, 0x1773,
-	0x17b6, 0x17c8,
-	0x18a9, 0x18a9,
-	0x1920, 0x192b,
-	0x1930, 0x1938,
-	0x19b0, 0x19c0,
-	0x19c8, 0x19c9,
-	0x1a17, 0x1a1b,
-	0x1a55, 0x1a5e,
-	0x1a61, 0x1a74,
-	0x1b00, 0x1b04,
-	0x1b35, 0x1b43,
-	0x1b80, 0x1b82,
-	0x1ba1, 0x1ba9,
-	0x1c24, 0x1c35,
-	0x1cf2, 0x1cf2,
-	0x24b6, 0x24e9,
-	0x2de0, 0x2dff,
-	0xa823, 0xa827,
-	0xa880, 0xa881,
-	0xa8b4, 0xa8c3,
-	0xa926, 0xa92a,
-	0xa947, 0xa952,
-	0xa980, 0xa983,
-	0xa9b3, 0xa9bf,
-	0xaa29, 0xaa36,
-	0xaa43, 0xaa43,
-	0xaa4c, 0xaa4d,
-	0xaab0, 0xaab0,
-	0xaab2, 0xaab4,
-	0xaab7, 0xaab8,
-	0xaabe, 0xaabe,
-	0xabe3, 0xabea,
-	0xfb1e, 0xfb1e,
-	0x10a01, 0x10a03,
-	0x10a05, 0x10a06,
-	0x10a0c, 0x10a0f,
-	0x11082, 0x11082,
-	0x110b0, 0x110b8,
+        141,
+        0x0345, 0x0345,
+        0x05b0, 0x05bd,
+        0x05bf, 0x05bf,
+        0x05c1, 0x05c2,
+        0x05c4, 0x05c5,
+        0x05c7, 0x05c7,
+        0x0610, 0x061a,
+        0x064b, 0x0657,
+        0x0659, 0x065e,
+        0x0670, 0x0670,
+        0x06d6, 0x06dc,
+        0x06e1, 0x06e4,
+        0x06e7, 0x06e8,
+        0x06ed, 0x06ed,
+        0x0711, 0x0711,
+        0x0730, 0x073f,
+        0x07a6, 0x07b0,
+        0x0816, 0x0817,
+        0x081b, 0x0823,
+        0x0825, 0x0827,
+        0x0829, 0x082c,
+        0x0900, 0x0903,
+        0x093e, 0x094c,
+        0x094e, 0x094e,
+        0x0955, 0x0955,
+        0x0962, 0x0963,
+        0x0981, 0x0983,
+        0x09be, 0x09c4,
+        0x09c7, 0x09c8,
+        0x09cb, 0x09cc,
+        0x09d7, 0x09d7,
+        0x09e2, 0x09e3,
+        0x0a01, 0x0a03,
+        0x0a3e, 0x0a42,
+        0x0a47, 0x0a48,
+        0x0a4b, 0x0a4c,
+        0x0a51, 0x0a51,
+        0x0a70, 0x0a71,
+        0x0a75, 0x0a75,
+        0x0a81, 0x0a83,
+        0x0abe, 0x0ac5,
+        0x0ac7, 0x0ac9,
+        0x0acb, 0x0acc,
+        0x0ae2, 0x0ae3,
+        0x0b01, 0x0b03,
+        0x0b3e, 0x0b44,
+        0x0b47, 0x0b48,
+        0x0b4b, 0x0b4c,
+        0x0b56, 0x0b57,
+        0x0b62, 0x0b63,
+        0x0b82, 0x0b82,
+        0x0bbe, 0x0bc2,
+        0x0bc6, 0x0bc8,
+        0x0bca, 0x0bcc,
+        0x0bd7, 0x0bd7,
+        0x0c01, 0x0c03,
+        0x0c3e, 0x0c44,
+        0x0c46, 0x0c48,
+        0x0c4a, 0x0c4c,
+        0x0c55, 0x0c56,
+        0x0c62, 0x0c63,
+        0x0c82, 0x0c83,
+        0x0cbe, 0x0cc4,
+        0x0cc6, 0x0cc8,
+        0x0cca, 0x0ccc,
+        0x0cd5, 0x0cd6,
+        0x0ce2, 0x0ce3,
+        0x0d02, 0x0d03,
+        0x0d3e, 0x0d44,
+        0x0d46, 0x0d48,
+        0x0d4a, 0x0d4c,
+        0x0d57, 0x0d57,
+        0x0d62, 0x0d63,
+        0x0d82, 0x0d83,
+        0x0dcf, 0x0dd4,
+        0x0dd6, 0x0dd6,
+        0x0dd8, 0x0ddf,
+        0x0df2, 0x0df3,
+        0x0e31, 0x0e31,
+        0x0e34, 0x0e3a,
+        0x0e4d, 0x0e4d,
+        0x0eb1, 0x0eb1,
+        0x0eb4, 0x0eb9,
+        0x0ebb, 0x0ebc,
+        0x0ecd, 0x0ecd,
+        0x0f71, 0x0f81,
+        0x0f90, 0x0f97,
+        0x0f99, 0x0fbc,
+        0x102b, 0x1036,
+        0x1038, 0x1038,
+        0x103b, 0x103e,
+        0x1056, 0x1059,
+        0x105e, 0x1060,
+        0x1062, 0x1062,
+        0x1067, 0x1068,
+        0x1071, 0x1074,
+        0x1082, 0x1086,
+        0x109c, 0x109d,
+        0x135f, 0x135f,
+        0x1712, 0x1713,
+        0x1732, 0x1733,
+        0x1752, 0x1753,
+        0x1772, 0x1773,
+        0x17b6, 0x17c8,
+        0x18a9, 0x18a9,
+        0x1920, 0x192b,
+        0x1930, 0x1938,
+        0x19b0, 0x19c0,
+        0x19c8, 0x19c9,
+        0x1a17, 0x1a1b,
+        0x1a55, 0x1a5e,
+        0x1a61, 0x1a74,
+        0x1b00, 0x1b04,
+        0x1b35, 0x1b43,
+        0x1b80, 0x1b82,
+        0x1ba1, 0x1ba9,
+        0x1c24, 0x1c35,
+        0x1cf2, 0x1cf2,
+        0x24b6, 0x24e9,
+        0x2de0, 0x2dff,
+        0xa823, 0xa827,
+        0xa880, 0xa881,
+        0xa8b4, 0xa8c3,
+        0xa926, 0xa92a,
+        0xa947, 0xa952,
+        0xa980, 0xa983,
+        0xa9b3, 0xa9bf,
+        0xaa29, 0xaa36,
+        0xaa43, 0xaa43,
+        0xaa4c, 0xaa4d,
+        0xaab0, 0xaab0,
+        0xaab2, 0xaab4,
+        0xaab7, 0xaab8,
+        0xaabe, 0xaabe,
+        0xabe3, 0xabea,
+        0xfb1e, 0xfb1e,
+        0x10a01, 0x10a03,
+        0x10a05, 0x10a06,
+        0x10a0c, 0x10a0f,
+        0x11082, 0x11082,
+        0x110b0, 0x110b8,
 }; /* CR_Other_Alphabetic */
 
 /* 'Ideographic': Binary Property */
 static const OnigCodePoint CR_Ideographic[] = {
-	11,
-	0x3006, 0x3007,
-	0x3021, 0x3029,
-	0x3038, 0x303a,
-	0x3400, 0x4db5,
-	0x4e00, 0x9fcb,
-	0xf900, 0xfa2d,
-	0xfa30, 0xfa6d,
-	0xfa70, 0xfad9,
-	0x20000, 0x2a6d6,
-	0x2a700, 0x2b734,
-	0x2f800, 0x2fa1d,
+        11,
+        0x3006, 0x3007,
+        0x3021, 0x3029,
+        0x3038, 0x303a,
+        0x3400, 0x4db5,
+        0x4e00, 0x9fcb,
+        0xf900, 0xfa2d,
+        0xfa30, 0xfa6d,
+        0xfa70, 0xfad9,
+        0x20000, 0x2a6d6,
+        0x2a700, 0x2b734,
+        0x2f800, 0x2fa1d,
 }; /* CR_Ideographic */
 
 /* 'Diacritic': Binary Property */
 static const OnigCodePoint CR_Diacritic[] = {
-	117,
-	0x005e, 0x005e,
-	0x0060, 0x0060,
-	0x00a8, 0x00a8,
-	0x00af, 0x00af,
-	0x00b4, 0x00b4,
-	0x00b7, 0x00b8,
-	0x02b0, 0x034e,
-	0x0350, 0x0357,
-	0x035d, 0x0362,
-	0x0374, 0x0375,
-	0x037a, 0x037a,
-	0x0384, 0x0385,
-	0x0483, 0x0487,
-	0x0559, 0x0559,
-	0x0591, 0x05a1,
-	0x05a3, 0x05bd,
-	0x05bf, 0x05bf,
-	0x05c1, 0x05c2,
-	0x05c4, 0x05c4,
-	0x064b, 0x0652,
-	0x0657, 0x0658,
-	0x06df, 0x06e0,
-	0x06e5, 0x06e6,
-	0x06ea, 0x06ec,
-	0x0730, 0x074a,
-	0x07a6, 0x07b0,
-	0x07eb, 0x07f5,
-	0x0818, 0x0819,
-	0x093c, 0x093c,
-	0x094d, 0x094d,
-	0x0951, 0x0954,
-	0x0971, 0x0971,
-	0x09bc, 0x09bc,
-	0x09cd, 0x09cd,
-	0x0a3c, 0x0a3c,
-	0x0a4d, 0x0a4d,
-	0x0abc, 0x0abc,
-	0x0acd, 0x0acd,
-	0x0b3c, 0x0b3c,
-	0x0b4d, 0x0b4d,
-	0x0bcd, 0x0bcd,
-	0x0c4d, 0x0c4d,
-	0x0cbc, 0x0cbc,
-	0x0ccd, 0x0ccd,
-	0x0d4d, 0x0d4d,
-	0x0dca, 0x0dca,
-	0x0e47, 0x0e4c,
-	0x0e4e, 0x0e4e,
-	0x0ec8, 0x0ecc,
-	0x0f18, 0x0f19,
-	0x0f35, 0x0f35,
-	0x0f37, 0x0f37,
-	0x0f39, 0x0f39,
-	0x0f3e, 0x0f3f,
-	0x0f82, 0x0f84,
-	0x0f86, 0x0f87,
-	0x0fc6, 0x0fc6,
-	0x1037, 0x1037,
-	0x1039, 0x103a,
-	0x1087, 0x108d,
-	0x108f, 0x108f,
-	0x109a, 0x109b,
-	0x17c9, 0x17d3,
-	0x17dd, 0x17dd,
-	0x1939, 0x193b,
-	0x1a75, 0x1a7c,
-	0x1a7f, 0x1a7f,
-	0x1b34, 0x1b34,
-	0x1b44, 0x1b44,
-	0x1b6b, 0x1b73,
-	0x1baa, 0x1baa,
-	0x1c36, 0x1c37,
-	0x1c78, 0x1c7d,
-	0x1cd0, 0x1ce8,
-	0x1ced, 0x1ced,
-	0x1d2c, 0x1d6a,
-	0x1dc4, 0x1dcf,
-	0x1dfd, 0x1dff,
-	0x1fbd, 0x1fbd,
-	0x1fbf, 0x1fc1,
-	0x1fcd, 0x1fcf,
-	0x1fdd, 0x1fdf,
-	0x1fed, 0x1fef,
-	0x1ffd, 0x1ffe,
-	0x2cef, 0x2cf1,
-	0x2e2f, 0x2e2f,
-	0x302a, 0x302f,
-	0x3099, 0x309c,
-	0x30fc, 0x30fc,
-	0xa66f, 0xa66f,
-	0xa67c, 0xa67d,
-	0xa67f, 0xa67f,
-	0xa6f0, 0xa6f1,
-	0xa717, 0xa721,
-	0xa788, 0xa788,
-	0xa8c4, 0xa8c4,
-	0xa8e0, 0xa8f1,
-	0xa92b, 0xa92e,
-	0xa953, 0xa953,
-	0xa9b3, 0xa9b3,
-	0xa9c0, 0xa9c0,
-	0xaa7b, 0xaa7b,
-	0xaabf, 0xaac2,
-	0xabec, 0xabed,
-	0xfb1e, 0xfb1e,
-	0xfe20, 0xfe26,
-	0xff3e, 0xff3e,
-	0xff40, 0xff40,
-	0xff70, 0xff70,
-	0xff9e, 0xff9f,
-	0xffe3, 0xffe3,
-	0x110b9, 0x110ba,
-	0x1d167, 0x1d169,
-	0x1d16d, 0x1d172,
-	0x1d17b, 0x1d182,
-	0x1d185, 0x1d18b,
-	0x1d1aa, 0x1d1ad,
+        117,
+        0x005e, 0x005e,
+        0x0060, 0x0060,
+        0x00a8, 0x00a8,
+        0x00af, 0x00af,
+        0x00b4, 0x00b4,
+        0x00b7, 0x00b8,
+        0x02b0, 0x034e,
+        0x0350, 0x0357,
+        0x035d, 0x0362,
+        0x0374, 0x0375,
+        0x037a, 0x037a,
+        0x0384, 0x0385,
+        0x0483, 0x0487,
+        0x0559, 0x0559,
+        0x0591, 0x05a1,
+        0x05a3, 0x05bd,
+        0x05bf, 0x05bf,
+        0x05c1, 0x05c2,
+        0x05c4, 0x05c4,
+        0x064b, 0x0652,
+        0x0657, 0x0658,
+        0x06df, 0x06e0,
+        0x06e5, 0x06e6,
+        0x06ea, 0x06ec,
+        0x0730, 0x074a,
+        0x07a6, 0x07b0,
+        0x07eb, 0x07f5,
+        0x0818, 0x0819,
+        0x093c, 0x093c,
+        0x094d, 0x094d,
+        0x0951, 0x0954,
+        0x0971, 0x0971,
+        0x09bc, 0x09bc,
+        0x09cd, 0x09cd,
+        0x0a3c, 0x0a3c,
+        0x0a4d, 0x0a4d,
+        0x0abc, 0x0abc,
+        0x0acd, 0x0acd,
+        0x0b3c, 0x0b3c,
+        0x0b4d, 0x0b4d,
+        0x0bcd, 0x0bcd,
+        0x0c4d, 0x0c4d,
+        0x0cbc, 0x0cbc,
+        0x0ccd, 0x0ccd,
+        0x0d4d, 0x0d4d,
+        0x0dca, 0x0dca,
+        0x0e47, 0x0e4c,
+        0x0e4e, 0x0e4e,
+        0x0ec8, 0x0ecc,
+        0x0f18, 0x0f19,
+        0x0f35, 0x0f35,
+        0x0f37, 0x0f37,
+        0x0f39, 0x0f39,
+        0x0f3e, 0x0f3f,
+        0x0f82, 0x0f84,
+        0x0f86, 0x0f87,
+        0x0fc6, 0x0fc6,
+        0x1037, 0x1037,
+        0x1039, 0x103a,
+        0x1087, 0x108d,
+        0x108f, 0x108f,
+        0x109a, 0x109b,
+        0x17c9, 0x17d3,
+        0x17dd, 0x17dd,
+        0x1939, 0x193b,
+        0x1a75, 0x1a7c,
+        0x1a7f, 0x1a7f,
+        0x1b34, 0x1b34,
+        0x1b44, 0x1b44,
+        0x1b6b, 0x1b73,
+        0x1baa, 0x1baa,
+        0x1c36, 0x1c37,
+        0x1c78, 0x1c7d,
+        0x1cd0, 0x1ce8,
+        0x1ced, 0x1ced,
+        0x1d2c, 0x1d6a,
+        0x1dc4, 0x1dcf,
+        0x1dfd, 0x1dff,
+        0x1fbd, 0x1fbd,
+        0x1fbf, 0x1fc1,
+        0x1fcd, 0x1fcf,
+        0x1fdd, 0x1fdf,
+        0x1fed, 0x1fef,
+        0x1ffd, 0x1ffe,
+        0x2cef, 0x2cf1,
+        0x2e2f, 0x2e2f,
+        0x302a, 0x302f,
+        0x3099, 0x309c,
+        0x30fc, 0x30fc,
+        0xa66f, 0xa66f,
+        0xa67c, 0xa67d,
+        0xa67f, 0xa67f,
+        0xa6f0, 0xa6f1,
+        0xa717, 0xa721,
+        0xa788, 0xa788,
+        0xa8c4, 0xa8c4,
+        0xa8e0, 0xa8f1,
+        0xa92b, 0xa92e,
+        0xa953, 0xa953,
+        0xa9b3, 0xa9b3,
+        0xa9c0, 0xa9c0,
+        0xaa7b, 0xaa7b,
+        0xaabf, 0xaac2,
+        0xabec, 0xabed,
+        0xfb1e, 0xfb1e,
+        0xfe20, 0xfe26,
+        0xff3e, 0xff3e,
+        0xff40, 0xff40,
+        0xff70, 0xff70,
+        0xff9e, 0xff9f,
+        0xffe3, 0xffe3,
+        0x110b9, 0x110ba,
+        0x1d167, 0x1d169,
+        0x1d16d, 0x1d172,
+        0x1d17b, 0x1d182,
+        0x1d185, 0x1d18b,
+        0x1d1aa, 0x1d1ad,
 }; /* CR_Diacritic */
 
 /* 'Extender': Binary Property */
 static const OnigCodePoint CR_Extender[] = {
-	20,
-	0x00b7, 0x00b7,
-	0x02d0, 0x02d1,
-	0x0640, 0x0640,
-	0x07fa, 0x07fa,
-	0x0e46, 0x0e46,
-	0x0ec6, 0x0ec6,
-	0x1843, 0x1843,
-	0x1aa7, 0x1aa7,
-	0x1c36, 0x1c36,
-	0x1c7b, 0x1c7b,
-	0x3005, 0x3005,
-	0x3031, 0x3035,
-	0x309d, 0x309e,
-	0x30fc, 0x30fe,
-	0xa015, 0xa015,
-	0xa60c, 0xa60c,
-	0xa9cf, 0xa9cf,
-	0xaa70, 0xaa70,
-	0xaadd, 0xaadd,
-	0xff70, 0xff70,
+        20,
+        0x00b7, 0x00b7,
+        0x02d0, 0x02d1,
+        0x0640, 0x0640,
+        0x07fa, 0x07fa,
+        0x0e46, 0x0e46,
+        0x0ec6, 0x0ec6,
+        0x1843, 0x1843,
+        0x1aa7, 0x1aa7,
+        0x1c36, 0x1c36,
+        0x1c7b, 0x1c7b,
+        0x3005, 0x3005,
+        0x3031, 0x3035,
+        0x309d, 0x309e,
+        0x30fc, 0x30fe,
+        0xa015, 0xa015,
+        0xa60c, 0xa60c,
+        0xa9cf, 0xa9cf,
+        0xaa70, 0xaa70,
+        0xaadd, 0xaadd,
+        0xff70, 0xff70,
 }; /* CR_Extender */
 
 /* 'Other_Lowercase': Binary Property */
 static const OnigCodePoint CR_Other_Lowercase[] = {
-	13,
-	0x02b0, 0x02b8,
-	0x02c0, 0x02c1,
-	0x02e0, 0x02e4,
-	0x0345, 0x0345,
-	0x037a, 0x037a,
-	0x1d2c, 0x1d61,
-	0x1d78, 0x1d78,
-	0x1d9b, 0x1dbf,
-	0x2090, 0x2094,
-	0x2170, 0x217f,
-	0x24d0, 0x24e9,
-	0x2c7d, 0x2c7d,
-	0xa770, 0xa770,
+        13,
+        0x02b0, 0x02b8,
+        0x02c0, 0x02c1,
+        0x02e0, 0x02e4,
+        0x0345, 0x0345,
+        0x037a, 0x037a,
+        0x1d2c, 0x1d61,
+        0x1d78, 0x1d78,
+        0x1d9b, 0x1dbf,
+        0x2090, 0x2094,
+        0x2170, 0x217f,
+        0x24d0, 0x24e9,
+        0x2c7d, 0x2c7d,
+        0xa770, 0xa770,
 }; /* CR_Other_Lowercase */
 
 /* 'Other_Uppercase': Binary Property */
 static const OnigCodePoint CR_Other_Uppercase[] = {
-	2,
-	0x2160, 0x216f,
-	0x24b6, 0x24cf,
+        2,
+        0x2160, 0x216f,
+        0x24b6, 0x24cf,
 }; /* CR_Other_Uppercase */
 
 /* 'Noncharacter_Code_Point': Binary Property */
 static const OnigCodePoint CR_Noncharacter_Code_Point[] = {
-	18,
-	0xfdd0, 0xfdef,
-	0xfffe, 0xffff,
-	0x1fffe, 0x1ffff,
-	0x2fffe, 0x2ffff,
-	0x3fffe, 0x3ffff,
-	0x4fffe, 0x4ffff,
-	0x5fffe, 0x5ffff,
-	0x6fffe, 0x6ffff,
-	0x7fffe, 0x7ffff,
-	0x8fffe, 0x8ffff,
-	0x9fffe, 0x9ffff,
-	0xafffe, 0xaffff,
-	0xbfffe, 0xbffff,
-	0xcfffe, 0xcffff,
-	0xdfffe, 0xdffff,
-	0xefffe, 0xeffff,
-	0xffffe, 0xfffff,
-	0x10fffe, 0x10ffff,
+        18,
+        0xfdd0, 0xfdef,
+        0xfffe, 0xffff,
+        0x1fffe, 0x1ffff,
+        0x2fffe, 0x2ffff,
+        0x3fffe, 0x3ffff,
+        0x4fffe, 0x4ffff,
+        0x5fffe, 0x5ffff,
+        0x6fffe, 0x6ffff,
+        0x7fffe, 0x7ffff,
+        0x8fffe, 0x8ffff,
+        0x9fffe, 0x9ffff,
+        0xafffe, 0xaffff,
+        0xbfffe, 0xbffff,
+        0xcfffe, 0xcffff,
+        0xdfffe, 0xdffff,
+        0xefffe, 0xeffff,
+        0xffffe, 0xfffff,
+        0x10fffe, 0x10ffff,
 }; /* CR_Noncharacter_Code_Point */
 
 /* 'Other_Grapheme_Extend': Binary Property */
 static const OnigCodePoint CR_Other_Grapheme_Extend[] = {
-	16,
-	0x09be, 0x09be,
-	0x09d7, 0x09d7,
-	0x0b3e, 0x0b3e,
-	0x0b57, 0x0b57,
-	0x0bbe, 0x0bbe,
-	0x0bd7, 0x0bd7,
-	0x0cc2, 0x0cc2,
-	0x0cd5, 0x0cd6,
-	0x0d3e, 0x0d3e,
-	0x0d57, 0x0d57,
-	0x0dcf, 0x0dcf,
-	0x0ddf, 0x0ddf,
-	0x200c, 0x200d,
-	0xff9e, 0xff9f,
-	0x1d165, 0x1d165,
-	0x1d16e, 0x1d172,
+        16,
+        0x09be, 0x09be,
+        0x09d7, 0x09d7,
+        0x0b3e, 0x0b3e,
+        0x0b57, 0x0b57,
+        0x0bbe, 0x0bbe,
+        0x0bd7, 0x0bd7,
+        0x0cc2, 0x0cc2,
+        0x0cd5, 0x0cd6,
+        0x0d3e, 0x0d3e,
+        0x0d57, 0x0d57,
+        0x0dcf, 0x0dcf,
+        0x0ddf, 0x0ddf,
+        0x200c, 0x200d,
+        0xff9e, 0xff9f,
+        0x1d165, 0x1d165,
+        0x1d16e, 0x1d172,
 }; /* CR_Other_Grapheme_Extend */
 
 /* 'IDS_Binary_Operator': Binary Property */
 static const OnigCodePoint CR_IDS_Binary_Operator[] = {
-	2,
-	0x2ff0, 0x2ff1,
-	0x2ff4, 0x2ffb,
+        2,
+        0x2ff0, 0x2ff1,
+        0x2ff4, 0x2ffb,
 }; /* CR_IDS_Binary_Operator */
 
 /* 'IDS_Trinary_Operator': Binary Property */
 static const OnigCodePoint CR_IDS_Trinary_Operator[] = {
-	1,
-	0x2ff2, 0x2ff3,
+        1,
+        0x2ff2, 0x2ff3,
 }; /* CR_IDS_Trinary_Operator */
 
 /* 'Radical': Binary Property */
 static const OnigCodePoint CR_Radical[] = {
-	3,
-	0x2e80, 0x2e99,
-	0x2e9b, 0x2ef3,
-	0x2f00, 0x2fd5,
+        3,
+        0x2e80, 0x2e99,
+        0x2e9b, 0x2ef3,
+        0x2f00, 0x2fd5,
 }; /* CR_Radical */
 
 /* 'Unified_Ideograph': Binary Property */
 static const OnigCodePoint CR_Unified_Ideograph[] = {
-	11,
-	0x3400, 0x4db5,
-	0x4e00, 0x9fcb,
-	0xfa0e, 0xfa0f,
-	0xfa11, 0xfa11,
-	0xfa13, 0xfa14,
-	0xfa1f, 0xfa1f,
-	0xfa21, 0xfa21,
-	0xfa23, 0xfa24,
-	0xfa27, 0xfa29,
-	0x20000, 0x2a6d6,
-	0x2a700, 0x2b734,
+        11,
+        0x3400, 0x4db5,
+        0x4e00, 0x9fcb,
+        0xfa0e, 0xfa0f,
+        0xfa11, 0xfa11,
+        0xfa13, 0xfa14,
+        0xfa1f, 0xfa1f,
+        0xfa21, 0xfa21,
+        0xfa23, 0xfa24,
+        0xfa27, 0xfa29,
+        0x20000, 0x2a6d6,
+        0x2a700, 0x2b734,
 }; /* CR_Unified_Ideograph */
 
 /* 'Other_Default_Ignorable_Code_Point': Binary Property */
 static const OnigCodePoint CR_Other_Default_Ignorable_Code_Point[] = {
-	10,
-	0x034f, 0x034f,
-	0x115f, 0x1160,
-	0x2065, 0x2069,
-	0x3164, 0x3164,
-	0xffa0, 0xffa0,
-	0xfff0, 0xfff8,
-	0xe0000, 0xe0000,
-	0xe0002, 0xe001f,
-	0xe0080, 0xe00ff,
-	0xe01f0, 0xe0fff,
+        10,
+        0x034f, 0x034f,
+        0x115f, 0x1160,
+        0x2065, 0x2069,
+        0x3164, 0x3164,
+        0xffa0, 0xffa0,
+        0xfff0, 0xfff8,
+        0xe0000, 0xe0000,
+        0xe0002, 0xe001f,
+        0xe0080, 0xe00ff,
+        0xe01f0, 0xe0fff,
 }; /* CR_Other_Default_Ignorable_Code_Point */
 
 /* 'Deprecated': Binary Property */
 static const OnigCodePoint CR_Deprecated[] = {
-	8,
-	0x0149, 0x0149,
-	0x0f77, 0x0f77,
-	0x0f79, 0x0f79,
-	0x17a3, 0x17a4,
-	0x206a, 0x206f,
-	0x2329, 0x232a,
-	0xe0001, 0xe0001,
-	0xe0020, 0xe007f,
+        8,
+        0x0149, 0x0149,
+        0x0f77, 0x0f77,
+        0x0f79, 0x0f79,
+        0x17a3, 0x17a4,
+        0x206a, 0x206f,
+        0x2329, 0x232a,
+        0xe0001, 0xe0001,
+        0xe0020, 0xe007f,
 }; /* CR_Deprecated */
 
 /* 'Soft_Dotted': Binary Property */
 static const OnigCodePoint CR_Soft_Dotted[] = {
-	31,
-	0x0069, 0x006a,
-	0x012f, 0x012f,
-	0x0249, 0x0249,
-	0x0268, 0x0268,
-	0x029d, 0x029d,
-	0x02b2, 0x02b2,
-	0x03f3, 0x03f3,
-	0x0456, 0x0456,
-	0x0458, 0x0458,
-	0x1d62, 0x1d62,
-	0x1d96, 0x1d96,
-	0x1da4, 0x1da4,
-	0x1da8, 0x1da8,
-	0x1e2d, 0x1e2d,
-	0x1ecb, 0x1ecb,
-	0x2071, 0x2071,
-	0x2148, 0x2149,
-	0x2c7c, 0x2c7c,
-	0x1d422, 0x1d423,
-	0x1d456, 0x1d457,
-	0x1d48a, 0x1d48b,
-	0x1d4be, 0x1d4bf,
-	0x1d4f2, 0x1d4f3,
-	0x1d526, 0x1d527,
-	0x1d55a, 0x1d55b,
-	0x1d58e, 0x1d58f,
-	0x1d5c2, 0x1d5c3,
-	0x1d5f6, 0x1d5f7,
-	0x1d62a, 0x1d62b,
-	0x1d65e, 0x1d65f,
-	0x1d692, 0x1d693,
+        31,
+        0x0069, 0x006a,
+        0x012f, 0x012f,
+        0x0249, 0x0249,
+        0x0268, 0x0268,
+        0x029d, 0x029d,
+        0x02b2, 0x02b2,
+        0x03f3, 0x03f3,
+        0x0456, 0x0456,
+        0x0458, 0x0458,
+        0x1d62, 0x1d62,
+        0x1d96, 0x1d96,
+        0x1da4, 0x1da4,
+        0x1da8, 0x1da8,
+        0x1e2d, 0x1e2d,
+        0x1ecb, 0x1ecb,
+        0x2071, 0x2071,
+        0x2148, 0x2149,
+        0x2c7c, 0x2c7c,
+        0x1d422, 0x1d423,
+        0x1d456, 0x1d457,
+        0x1d48a, 0x1d48b,
+        0x1d4be, 0x1d4bf,
+        0x1d4f2, 0x1d4f3,
+        0x1d526, 0x1d527,
+        0x1d55a, 0x1d55b,
+        0x1d58e, 0x1d58f,
+        0x1d5c2, 0x1d5c3,
+        0x1d5f6, 0x1d5f7,
+        0x1d62a, 0x1d62b,
+        0x1d65e, 0x1d65f,
+        0x1d692, 0x1d693,
 }; /* CR_Soft_Dotted */
 
 /* 'Logical_Order_Exception': Binary Property */
 static const OnigCodePoint CR_Logical_Order_Exception[] = {
-	5,
-	0x0e40, 0x0e44,
-	0x0ec0, 0x0ec4,
-	0xaab5, 0xaab6,
-	0xaab9, 0xaab9,
-	0xaabb, 0xaabc,
+        5,
+        0x0e40, 0x0e44,
+        0x0ec0, 0x0ec4,
+        0xaab5, 0xaab6,
+        0xaab9, 0xaab9,
+        0xaabb, 0xaabc,
 }; /* CR_Logical_Order_Exception */
 
 /* 'Other_ID_Start': Binary Property */
 static const OnigCodePoint CR_Other_ID_Start[] = {
-	3,
-	0x2118, 0x2118,
-	0x212e, 0x212e,
-	0x309b, 0x309c,
+        3,
+        0x2118, 0x2118,
+        0x212e, 0x212e,
+        0x309b, 0x309c,
 }; /* CR_Other_ID_Start */
 
 /* 'Other_ID_Continue': Binary Property */
 static const OnigCodePoint CR_Other_ID_Continue[] = {
-	3,
-	0x00b7, 0x00b7,
-	0x0387, 0x0387,
-	0x1369, 0x1371,
+        3,
+        0x00b7, 0x00b7,
+        0x0387, 0x0387,
+        0x1369, 0x1371,
 }; /* CR_Other_ID_Continue */
 
 /* 'STerm': Binary Property */
 static const OnigCodePoint CR_STerm[] = {
-	43,
-	0x0021, 0x0021,
-	0x002e, 0x002e,
-	0x003f, 0x003f,
-	0x055c, 0x055c,
-	0x055e, 0x055e,
-	0x0589, 0x0589,
-	0x061f, 0x061f,
-	0x06d4, 0x06d4,
-	0x0700, 0x0702,
-	0x07f9, 0x07f9,
-	0x0964, 0x0965,
-	0x104a, 0x104b,
-	0x1362, 0x1362,
-	0x1367, 0x1368,
-	0x166e, 0x166e,
-	0x1803, 0x1803,
-	0x1809, 0x1809,
-	0x1944, 0x1945,
-	0x1b5a, 0x1b5b,
-	0x1b5e, 0x1b5f,
-	0x1c3b, 0x1c3c,
-	0x1c7e, 0x1c7f,
-	0x203c, 0x203d,
-	0x2047, 0x2049,
-	0x2e2e, 0x2e2e,
-	0x3002, 0x3002,
-	0xa4ff, 0xa4ff,
-	0xa60e, 0xa60f,
-	0xa6f3, 0xa6f3,
-	0xa6f7, 0xa6f7,
-	0xa876, 0xa877,
-	0xa8ce, 0xa8cf,
-	0xa92f, 0xa92f,
-	0xa9c8, 0xa9c9,
-	0xaa5d, 0xaa5f,
-	0xabeb, 0xabeb,
-	0xfe52, 0xfe52,
-	0xfe56, 0xfe57,
-	0xff01, 0xff01,
-	0xff0e, 0xff0e,
-	0xff1f, 0xff1f,
-	0xff61, 0xff61,
-	0x110be, 0x110c1,
+        43,
+        0x0021, 0x0021,
+        0x002e, 0x002e,
+        0x003f, 0x003f,
+        0x055c, 0x055c,
+        0x055e, 0x055e,
+        0x0589, 0x0589,
+        0x061f, 0x061f,
+        0x06d4, 0x06d4,
+        0x0700, 0x0702,
+        0x07f9, 0x07f9,
+        0x0964, 0x0965,
+        0x104a, 0x104b,
+        0x1362, 0x1362,
+        0x1367, 0x1368,
+        0x166e, 0x166e,
+        0x1803, 0x1803,
+        0x1809, 0x1809,
+        0x1944, 0x1945,
+        0x1b5a, 0x1b5b,
+        0x1b5e, 0x1b5f,
+        0x1c3b, 0x1c3c,
+        0x1c7e, 0x1c7f,
+        0x203c, 0x203d,
+        0x2047, 0x2049,
+        0x2e2e, 0x2e2e,
+        0x3002, 0x3002,
+        0xa4ff, 0xa4ff,
+        0xa60e, 0xa60f,
+        0xa6f3, 0xa6f3,
+        0xa6f7, 0xa6f7,
+        0xa876, 0xa877,
+        0xa8ce, 0xa8cf,
+        0xa92f, 0xa92f,
+        0xa9c8, 0xa9c9,
+        0xaa5d, 0xaa5f,
+        0xabeb, 0xabeb,
+        0xfe52, 0xfe52,
+        0xfe56, 0xfe57,
+        0xff01, 0xff01,
+        0xff0e, 0xff0e,
+        0xff1f, 0xff1f,
+        0xff61, 0xff61,
+        0x110be, 0x110c1,
 }; /* CR_STerm */
 
 /* 'Variation_Selector': Binary Property */
 static const OnigCodePoint CR_Variation_Selector[] = {
-	3,
-	0x180b, 0x180d,
-	0xfe00, 0xfe0f,
-	0xe0100, 0xe01ef,
+        3,
+        0x180b, 0x180d,
+        0xfe00, 0xfe0f,
+        0xe0100, 0xe01ef,
 }; /* CR_Variation_Selector */
 
 /* 'Pattern_White_Space': Binary Property */
 static const OnigCodePoint CR_Pattern_White_Space[] = {
-	5,
-	0x0009, 0x000d,
-	0x0020, 0x0020,
-	0x0085, 0x0085,
-	0x200e, 0x200f,
-	0x2028, 0x2029,
+        5,
+        0x0009, 0x000d,
+        0x0020, 0x0020,
+        0x0085, 0x0085,
+        0x200e, 0x200f,
+        0x2028, 0x2029,
 }; /* CR_Pattern_White_Space */
 
 /* 'Pattern_Syntax': Binary Property */
 static const OnigCodePoint CR_Pattern_Syntax[] = {
-	28,
-	0x0021, 0x002f,
-	0x003a, 0x0040,
-	0x005b, 0x005e,
-	0x0060, 0x0060,
-	0x007b, 0x007e,
-	0x00a1, 0x00a7,
-	0x00a9, 0x00a9,
-	0x00ab, 0x00ac,
-	0x00ae, 0x00ae,
-	0x00b0, 0x00b1,
-	0x00b6, 0x00b6,
-	0x00bb, 0x00bb,
-	0x00bf, 0x00bf,
-	0x00d7, 0x00d7,
-	0x00f7, 0x00f7,
-	0x2010, 0x2027,
-	0x2030, 0x203e,
-	0x2041, 0x2053,
-	0x2055, 0x205e,
-	0x2190, 0x245f,
-	0x2500, 0x2775,
-	0x2794, 0x2bff,
-	0x2e00, 0x2e7f,
-	0x3001, 0x3003,
-	0x3008, 0x3020,
-	0x3030, 0x3030,
-	0xfd3e, 0xfd3f,
-	0xfe45, 0xfe46,
+        28,
+        0x0021, 0x002f,
+        0x003a, 0x0040,
+        0x005b, 0x005e,
+        0x0060, 0x0060,
+        0x007b, 0x007e,
+        0x00a1, 0x00a7,
+        0x00a9, 0x00a9,
+        0x00ab, 0x00ac,
+        0x00ae, 0x00ae,
+        0x00b0, 0x00b1,
+        0x00b6, 0x00b6,
+        0x00bb, 0x00bb,
+        0x00bf, 0x00bf,
+        0x00d7, 0x00d7,
+        0x00f7, 0x00f7,
+        0x2010, 0x2027,
+        0x2030, 0x203e,
+        0x2041, 0x2053,
+        0x2055, 0x205e,
+        0x2190, 0x245f,
+        0x2500, 0x2775,
+        0x2794, 0x2bff,
+        0x2e00, 0x2e7f,
+        0x3001, 0x3003,
+        0x3008, 0x3020,
+        0x3030, 0x3030,
+        0xfd3e, 0xfd3f,
+        0xfe45, 0xfe46,
 }; /* CR_Pattern_Syntax */
 #endif /* USE_UNICODE_PROPERTIES */
 #endif /* USE_UNICODE_PROPERTIES */
 
 /* 'NEWLINE': [[:NEWLINE:]] */
 static const OnigCodePoint CR_NEWLINE[] = {
-	1,
-	0x000a, 0x000a,
+        1,
+        0x000a, 0x000a,
 }; /* CR_NEWLINE */
 
 /* 'Alpha': [[:Alpha:]] */
@@ -14121,16 +14121,16 @@ static const OnigCodePoint CR_NEWLINE[] = {
 
 /* 'Blank': [[:Blank:]] */
 static const OnigCodePoint CR_Blank[] = {
-	9,
-	0x0009, 0x0009,
-	0x0020, 0x0020,
-	0x00a0, 0x00a0,
-	0x1680, 0x1680,
-	0x180e, 0x180e,
-	0x2000, 0x200a,
-	0x202f, 0x202f,
-	0x205f, 0x205f,
-	0x3000, 0x3000,
+        9,
+        0x0009, 0x0009,
+        0x0020, 0x0020,
+        0x00a0, 0x00a0,
+        0x1680, 0x1680,
+        0x180e, 0x180e,
+        0x2000, 0x200a,
+        0x202f, 0x202f,
+        0x205f, 0x205f,
+        0x3000, 0x3000,
 }; /* CR_Blank */
 
 /* 'Cntrl': [[:Cntrl:]] */
@@ -14141,497 +14141,497 @@ static const OnigCodePoint CR_Blank[] = {
 
 /* 'Graph': [[:Graph:]] */
 static const OnigCodePoint CR_Graph[] = {
-	490,
-	0x0021, 0x007e,
-	0x00a1, 0x0377,
-	0x037a, 0x037e,
-	0x0384, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x03a1,
-	0x03a3, 0x0525,
-	0x0531, 0x0556,
-	0x0559, 0x055f,
-	0x0561, 0x0587,
-	0x0589, 0x058a,
-	0x0591, 0x05c7,
-	0x05d0, 0x05ea,
-	0x05f0, 0x05f4,
-	0x0600, 0x0603,
-	0x0606, 0x061b,
-	0x061e, 0x061f,
-	0x0621, 0x065e,
-	0x0660, 0x070d,
-	0x070f, 0x074a,
-	0x074d, 0x07b1,
-	0x07c0, 0x07fa,
-	0x0800, 0x082d,
-	0x0830, 0x083e,
-	0x0900, 0x0939,
-	0x093c, 0x094e,
-	0x0950, 0x0955,
-	0x0958, 0x0972,
-	0x0979, 0x097f,
-	0x0981, 0x0983,
-	0x0985, 0x098c,
-	0x098f, 0x0990,
-	0x0993, 0x09a8,
-	0x09aa, 0x09b0,
-	0x09b2, 0x09b2,
-	0x09b6, 0x09b9,
-	0x09bc, 0x09c4,
-	0x09c7, 0x09c8,
-	0x09cb, 0x09ce,
-	0x09d7, 0x09d7,
-	0x09dc, 0x09dd,
-	0x09df, 0x09e3,
-	0x09e6, 0x09fb,
-	0x0a01, 0x0a03,
-	0x0a05, 0x0a0a,
-	0x0a0f, 0x0a10,
-	0x0a13, 0x0a28,
-	0x0a2a, 0x0a30,
-	0x0a32, 0x0a33,
-	0x0a35, 0x0a36,
-	0x0a38, 0x0a39,
-	0x0a3c, 0x0a3c,
-	0x0a3e, 0x0a42,
-	0x0a47, 0x0a48,
-	0x0a4b, 0x0a4d,
-	0x0a51, 0x0a51,
-	0x0a59, 0x0a5c,
-	0x0a5e, 0x0a5e,
-	0x0a66, 0x0a75,
-	0x0a81, 0x0a83,
-	0x0a85, 0x0a8d,
-	0x0a8f, 0x0a91,
-	0x0a93, 0x0aa8,
-	0x0aaa, 0x0ab0,
-	0x0ab2, 0x0ab3,
-	0x0ab5, 0x0ab9,
-	0x0abc, 0x0ac5,
-	0x0ac7, 0x0ac9,
-	0x0acb, 0x0acd,
-	0x0ad0, 0x0ad0,
-	0x0ae0, 0x0ae3,
-	0x0ae6, 0x0aef,
-	0x0af1, 0x0af1,
-	0x0b01, 0x0b03,
-	0x0b05, 0x0b0c,
-	0x0b0f, 0x0b10,
-	0x0b13, 0x0b28,
-	0x0b2a, 0x0b30,
-	0x0b32, 0x0b33,
-	0x0b35, 0x0b39,
-	0x0b3c, 0x0b44,
-	0x0b47, 0x0b48,
-	0x0b4b, 0x0b4d,
-	0x0b56, 0x0b57,
-	0x0b5c, 0x0b5d,
-	0x0b5f, 0x0b63,
-	0x0b66, 0x0b71,
-	0x0b82, 0x0b83,
-	0x0b85, 0x0b8a,
-	0x0b8e, 0x0b90,
-	0x0b92, 0x0b95,
-	0x0b99, 0x0b9a,
-	0x0b9c, 0x0b9c,
-	0x0b9e, 0x0b9f,
-	0x0ba3, 0x0ba4,
-	0x0ba8, 0x0baa,
-	0x0bae, 0x0bb9,
-	0x0bbe, 0x0bc2,
-	0x0bc6, 0x0bc8,
-	0x0bca, 0x0bcd,
-	0x0bd0, 0x0bd0,
-	0x0bd7, 0x0bd7,
-	0x0be6, 0x0bfa,
-	0x0c01, 0x0c03,
-	0x0c05, 0x0c0c,
-	0x0c0e, 0x0c10,
-	0x0c12, 0x0c28,
-	0x0c2a, 0x0c33,
-	0x0c35, 0x0c39,
-	0x0c3d, 0x0c44,
-	0x0c46, 0x0c48,
-	0x0c4a, 0x0c4d,
-	0x0c55, 0x0c56,
-	0x0c58, 0x0c59,
-	0x0c60, 0x0c63,
-	0x0c66, 0x0c6f,
-	0x0c78, 0x0c7f,
-	0x0c82, 0x0c83,
-	0x0c85, 0x0c8c,
-	0x0c8e, 0x0c90,
-	0x0c92, 0x0ca8,
-	0x0caa, 0x0cb3,
-	0x0cb5, 0x0cb9,
-	0x0cbc, 0x0cc4,
-	0x0cc6, 0x0cc8,
-	0x0cca, 0x0ccd,
-	0x0cd5, 0x0cd6,
-	0x0cde, 0x0cde,
-	0x0ce0, 0x0ce3,
-	0x0ce6, 0x0cef,
-	0x0cf1, 0x0cf2,
-	0x0d02, 0x0d03,
-	0x0d05, 0x0d0c,
-	0x0d0e, 0x0d10,
-	0x0d12, 0x0d28,
-	0x0d2a, 0x0d39,
-	0x0d3d, 0x0d44,
-	0x0d46, 0x0d48,
-	0x0d4a, 0x0d4d,
-	0x0d57, 0x0d57,
-	0x0d60, 0x0d63,
-	0x0d66, 0x0d75,
-	0x0d79, 0x0d7f,
-	0x0d82, 0x0d83,
-	0x0d85, 0x0d96,
-	0x0d9a, 0x0db1,
-	0x0db3, 0x0dbb,
-	0x0dbd, 0x0dbd,
-	0x0dc0, 0x0dc6,
-	0x0dca, 0x0dca,
-	0x0dcf, 0x0dd4,
-	0x0dd6, 0x0dd6,
-	0x0dd8, 0x0ddf,
-	0x0df2, 0x0df4,
-	0x0e01, 0x0e3a,
-	0x0e3f, 0x0e5b,
-	0x0e81, 0x0e82,
-	0x0e84, 0x0e84,
-	0x0e87, 0x0e88,
-	0x0e8a, 0x0e8a,
-	0x0e8d, 0x0e8d,
-	0x0e94, 0x0e97,
-	0x0e99, 0x0e9f,
-	0x0ea1, 0x0ea3,
-	0x0ea5, 0x0ea5,
-	0x0ea7, 0x0ea7,
-	0x0eaa, 0x0eab,
-	0x0ead, 0x0eb9,
-	0x0ebb, 0x0ebd,
-	0x0ec0, 0x0ec4,
-	0x0ec6, 0x0ec6,
-	0x0ec8, 0x0ecd,
-	0x0ed0, 0x0ed9,
-	0x0edc, 0x0edd,
-	0x0f00, 0x0f47,
-	0x0f49, 0x0f6c,
-	0x0f71, 0x0f8b,
-	0x0f90, 0x0f97,
-	0x0f99, 0x0fbc,
-	0x0fbe, 0x0fcc,
-	0x0fce, 0x0fd8,
-	0x1000, 0x10c5,
-	0x10d0, 0x10fc,
-	0x1100, 0x1248,
-	0x124a, 0x124d,
-	0x1250, 0x1256,
-	0x1258, 0x1258,
-	0x125a, 0x125d,
-	0x1260, 0x1288,
-	0x128a, 0x128d,
-	0x1290, 0x12b0,
-	0x12b2, 0x12b5,
-	0x12b8, 0x12be,
-	0x12c0, 0x12c0,
-	0x12c2, 0x12c5,
-	0x12c8, 0x12d6,
-	0x12d8, 0x1310,
-	0x1312, 0x1315,
-	0x1318, 0x135a,
-	0x135f, 0x137c,
-	0x1380, 0x1399,
-	0x13a0, 0x13f4,
-	0x1400, 0x167f,
-	0x1681, 0x169c,
-	0x16a0, 0x16f0,
-	0x1700, 0x170c,
-	0x170e, 0x1714,
-	0x1720, 0x1736,
-	0x1740, 0x1753,
-	0x1760, 0x176c,
-	0x176e, 0x1770,
-	0x1772, 0x1773,
-	0x1780, 0x17dd,
-	0x17e0, 0x17e9,
-	0x17f0, 0x17f9,
-	0x1800, 0x180d,
-	0x1810, 0x1819,
-	0x1820, 0x1877,
-	0x1880, 0x18aa,
-	0x18b0, 0x18f5,
-	0x1900, 0x191c,
-	0x1920, 0x192b,
-	0x1930, 0x193b,
-	0x1940, 0x1940,
-	0x1944, 0x196d,
-	0x1970, 0x1974,
-	0x1980, 0x19ab,
-	0x19b0, 0x19c9,
-	0x19d0, 0x19da,
-	0x19de, 0x1a1b,
-	0x1a1e, 0x1a5e,
-	0x1a60, 0x1a7c,
-	0x1a7f, 0x1a89,
-	0x1a90, 0x1a99,
-	0x1aa0, 0x1aad,
-	0x1b00, 0x1b4b,
-	0x1b50, 0x1b7c,
-	0x1b80, 0x1baa,
-	0x1bae, 0x1bb9,
-	0x1c00, 0x1c37,
-	0x1c3b, 0x1c49,
-	0x1c4d, 0x1c7f,
-	0x1cd0, 0x1cf2,
-	0x1d00, 0x1de6,
-	0x1dfd, 0x1f15,
-	0x1f18, 0x1f1d,
-	0x1f20, 0x1f45,
-	0x1f48, 0x1f4d,
-	0x1f50, 0x1f57,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f7d,
-	0x1f80, 0x1fb4,
-	0x1fb6, 0x1fc4,
-	0x1fc6, 0x1fd3,
-	0x1fd6, 0x1fdb,
-	0x1fdd, 0x1fef,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ffe,
-	0x200b, 0x2027,
-	0x202a, 0x202e,
-	0x2030, 0x205e,
-	0x2060, 0x2064,
-	0x206a, 0x2071,
-	0x2074, 0x208e,
-	0x2090, 0x2094,
-	0x20a0, 0x20b8,
-	0x20d0, 0x20f0,
-	0x2100, 0x2189,
-	0x2190, 0x23e8,
-	0x2400, 0x2426,
-	0x2440, 0x244a,
-	0x2460, 0x26cd,
-	0x26cf, 0x26e1,
-	0x26e3, 0x26e3,
-	0x26e8, 0x26ff,
-	0x2701, 0x2704,
-	0x2706, 0x2709,
-	0x270c, 0x2727,
-	0x2729, 0x274b,
-	0x274d, 0x274d,
-	0x274f, 0x2752,
-	0x2756, 0x275e,
-	0x2761, 0x2794,
-	0x2798, 0x27af,
-	0x27b1, 0x27be,
-	0x27c0, 0x27ca,
-	0x27cc, 0x27cc,
-	0x27d0, 0x2b4c,
-	0x2b50, 0x2b59,
-	0x2c00, 0x2c2e,
-	0x2c30, 0x2c5e,
-	0x2c60, 0x2cf1,
-	0x2cf9, 0x2d25,
-	0x2d30, 0x2d65,
-	0x2d6f, 0x2d6f,
-	0x2d80, 0x2d96,
-	0x2da0, 0x2da6,
-	0x2da8, 0x2dae,
-	0x2db0, 0x2db6,
-	0x2db8, 0x2dbe,
-	0x2dc0, 0x2dc6,
-	0x2dc8, 0x2dce,
-	0x2dd0, 0x2dd6,
-	0x2dd8, 0x2dde,
-	0x2de0, 0x2e31,
-	0x2e80, 0x2e99,
-	0x2e9b, 0x2ef3,
-	0x2f00, 0x2fd5,
-	0x2ff0, 0x2ffb,
-	0x3001, 0x303f,
-	0x3041, 0x3096,
-	0x3099, 0x30ff,
-	0x3105, 0x312d,
-	0x3131, 0x318e,
-	0x3190, 0x31b7,
-	0x31c0, 0x31e3,
-	0x31f0, 0x321e,
-	0x3220, 0x32fe,
-	0x3300, 0x4db5,
-	0x4dc0, 0x9fcb,
-	0xa000, 0xa48c,
-	0xa490, 0xa4c6,
-	0xa4d0, 0xa62b,
-	0xa640, 0xa65f,
-	0xa662, 0xa673,
-	0xa67c, 0xa697,
-	0xa6a0, 0xa6f7,
-	0xa700, 0xa78c,
-	0xa7fb, 0xa82b,
-	0xa830, 0xa839,
-	0xa840, 0xa877,
-	0xa880, 0xa8c4,
-	0xa8ce, 0xa8d9,
-	0xa8e0, 0xa8fb,
-	0xa900, 0xa953,
-	0xa95f, 0xa97c,
-	0xa980, 0xa9cd,
-	0xa9cf, 0xa9d9,
-	0xa9de, 0xa9df,
-	0xaa00, 0xaa36,
-	0xaa40, 0xaa4d,
-	0xaa50, 0xaa59,
-	0xaa5c, 0xaa7b,
-	0xaa80, 0xaac2,
-	0xaadb, 0xaadf,
-	0xabc0, 0xabed,
-	0xabf0, 0xabf9,
-	0xac00, 0xd7a3,
-	0xd7b0, 0xd7c6,
-	0xd7cb, 0xd7fb,
-	0xe000, 0xfa2d,
-	0xfa30, 0xfa6d,
-	0xfa70, 0xfad9,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xfb1d, 0xfb36,
-	0xfb38, 0xfb3c,
-	0xfb3e, 0xfb3e,
-	0xfb40, 0xfb41,
-	0xfb43, 0xfb44,
-	0xfb46, 0xfbb1,
-	0xfbd3, 0xfd3f,
-	0xfd50, 0xfd8f,
-	0xfd92, 0xfdc7,
-	0xfdf0, 0xfdfd,
-	0xfe00, 0xfe19,
-	0xfe20, 0xfe26,
-	0xfe30, 0xfe52,
-	0xfe54, 0xfe66,
-	0xfe68, 0xfe6b,
-	0xfe70, 0xfe74,
-	0xfe76, 0xfefc,
-	0xfeff, 0xfeff,
-	0xff01, 0xffbe,
-	0xffc2, 0xffc7,
-	0xffca, 0xffcf,
-	0xffd2, 0xffd7,
-	0xffda, 0xffdc,
-	0xffe0, 0xffe6,
-	0xffe8, 0xffee,
-	0xfff9, 0xfffd,
-	0x10000, 0x1000b,
-	0x1000d, 0x10026,
-	0x10028, 0x1003a,
-	0x1003c, 0x1003d,
-	0x1003f, 0x1004d,
-	0x10050, 0x1005d,
-	0x10080, 0x100fa,
-	0x10100, 0x10102,
-	0x10107, 0x10133,
-	0x10137, 0x1018a,
-	0x10190, 0x1019b,
-	0x101d0, 0x101fd,
-	0x10280, 0x1029c,
-	0x102a0, 0x102d0,
-	0x10300, 0x1031e,
-	0x10320, 0x10323,
-	0x10330, 0x1034a,
-	0x10380, 0x1039d,
-	0x1039f, 0x103c3,
-	0x103c8, 0x103d5,
-	0x10400, 0x1049d,
-	0x104a0, 0x104a9,
-	0x10800, 0x10805,
-	0x10808, 0x10808,
-	0x1080a, 0x10835,
-	0x10837, 0x10838,
-	0x1083c, 0x1083c,
-	0x1083f, 0x10855,
-	0x10857, 0x1085f,
-	0x10900, 0x1091b,
-	0x1091f, 0x10939,
-	0x1093f, 0x1093f,
-	0x10a00, 0x10a03,
-	0x10a05, 0x10a06,
-	0x10a0c, 0x10a13,
-	0x10a15, 0x10a17,
-	0x10a19, 0x10a33,
-	0x10a38, 0x10a3a,
-	0x10a3f, 0x10a47,
-	0x10a50, 0x10a58,
-	0x10a60, 0x10a7f,
-	0x10b00, 0x10b35,
-	0x10b39, 0x10b55,
-	0x10b58, 0x10b72,
-	0x10b78, 0x10b7f,
-	0x10c00, 0x10c48,
-	0x10e60, 0x10e7e,
-	0x11080, 0x110c1,
-	0x12000, 0x1236e,
-	0x12400, 0x12462,
-	0x12470, 0x12473,
-	0x13000, 0x1342e,
-	0x1d000, 0x1d0f5,
-	0x1d100, 0x1d126,
-	0x1d129, 0x1d1dd,
-	0x1d200, 0x1d245,
-	0x1d300, 0x1d356,
-	0x1d360, 0x1d371,
-	0x1d400, 0x1d454,
-	0x1d456, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d51e, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d552, 0x1d6a5,
-	0x1d6a8, 0x1d7cb,
-	0x1d7ce, 0x1d7ff,
-	0x1f000, 0x1f02b,
-	0x1f030, 0x1f093,
-	0x1f100, 0x1f10a,
-	0x1f110, 0x1f12e,
-	0x1f131, 0x1f131,
-	0x1f13d, 0x1f13d,
-	0x1f13f, 0x1f13f,
-	0x1f142, 0x1f142,
-	0x1f146, 0x1f146,
-	0x1f14a, 0x1f14e,
-	0x1f157, 0x1f157,
-	0x1f15f, 0x1f15f,
-	0x1f179, 0x1f179,
-	0x1f17b, 0x1f17c,
-	0x1f17f, 0x1f17f,
-	0x1f18a, 0x1f18d,
-	0x1f190, 0x1f190,
-	0x1f200, 0x1f200,
-	0x1f210, 0x1f231,
-	0x1f240, 0x1f248,
-	0x20000, 0x2a6d6,
-	0x2a700, 0x2b734,
-	0x2f800, 0x2fa1d,
-	0xe0001, 0xe0001,
-	0xe0020, 0xe007f,
-	0xe0100, 0xe01ef,
-	0xf0000, 0xffffd,
-	0x100000, 0x10fffd,
+        490,
+        0x0021, 0x007e,
+        0x00a1, 0x0377,
+        0x037a, 0x037e,
+        0x0384, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x03a1,
+        0x03a3, 0x0525,
+        0x0531, 0x0556,
+        0x0559, 0x055f,
+        0x0561, 0x0587,
+        0x0589, 0x058a,
+        0x0591, 0x05c7,
+        0x05d0, 0x05ea,
+        0x05f0, 0x05f4,
+        0x0600, 0x0603,
+        0x0606, 0x061b,
+        0x061e, 0x061f,
+        0x0621, 0x065e,
+        0x0660, 0x070d,
+        0x070f, 0x074a,
+        0x074d, 0x07b1,
+        0x07c0, 0x07fa,
+        0x0800, 0x082d,
+        0x0830, 0x083e,
+        0x0900, 0x0939,
+        0x093c, 0x094e,
+        0x0950, 0x0955,
+        0x0958, 0x0972,
+        0x0979, 0x097f,
+        0x0981, 0x0983,
+        0x0985, 0x098c,
+        0x098f, 0x0990,
+        0x0993, 0x09a8,
+        0x09aa, 0x09b0,
+        0x09b2, 0x09b2,
+        0x09b6, 0x09b9,
+        0x09bc, 0x09c4,
+        0x09c7, 0x09c8,
+        0x09cb, 0x09ce,
+        0x09d7, 0x09d7,
+        0x09dc, 0x09dd,
+        0x09df, 0x09e3,
+        0x09e6, 0x09fb,
+        0x0a01, 0x0a03,
+        0x0a05, 0x0a0a,
+        0x0a0f, 0x0a10,
+        0x0a13, 0x0a28,
+        0x0a2a, 0x0a30,
+        0x0a32, 0x0a33,
+        0x0a35, 0x0a36,
+        0x0a38, 0x0a39,
+        0x0a3c, 0x0a3c,
+        0x0a3e, 0x0a42,
+        0x0a47, 0x0a48,
+        0x0a4b, 0x0a4d,
+        0x0a51, 0x0a51,
+        0x0a59, 0x0a5c,
+        0x0a5e, 0x0a5e,
+        0x0a66, 0x0a75,
+        0x0a81, 0x0a83,
+        0x0a85, 0x0a8d,
+        0x0a8f, 0x0a91,
+        0x0a93, 0x0aa8,
+        0x0aaa, 0x0ab0,
+        0x0ab2, 0x0ab3,
+        0x0ab5, 0x0ab9,
+        0x0abc, 0x0ac5,
+        0x0ac7, 0x0ac9,
+        0x0acb, 0x0acd,
+        0x0ad0, 0x0ad0,
+        0x0ae0, 0x0ae3,
+        0x0ae6, 0x0aef,
+        0x0af1, 0x0af1,
+        0x0b01, 0x0b03,
+        0x0b05, 0x0b0c,
+        0x0b0f, 0x0b10,
+        0x0b13, 0x0b28,
+        0x0b2a, 0x0b30,
+        0x0b32, 0x0b33,
+        0x0b35, 0x0b39,
+        0x0b3c, 0x0b44,
+        0x0b47, 0x0b48,
+        0x0b4b, 0x0b4d,
+        0x0b56, 0x0b57,
+        0x0b5c, 0x0b5d,
+        0x0b5f, 0x0b63,
+        0x0b66, 0x0b71,
+        0x0b82, 0x0b83,
+        0x0b85, 0x0b8a,
+        0x0b8e, 0x0b90,
+        0x0b92, 0x0b95,
+        0x0b99, 0x0b9a,
+        0x0b9c, 0x0b9c,
+        0x0b9e, 0x0b9f,
+        0x0ba3, 0x0ba4,
+        0x0ba8, 0x0baa,
+        0x0bae, 0x0bb9,
+        0x0bbe, 0x0bc2,
+        0x0bc6, 0x0bc8,
+        0x0bca, 0x0bcd,
+        0x0bd0, 0x0bd0,
+        0x0bd7, 0x0bd7,
+        0x0be6, 0x0bfa,
+        0x0c01, 0x0c03,
+        0x0c05, 0x0c0c,
+        0x0c0e, 0x0c10,
+        0x0c12, 0x0c28,
+        0x0c2a, 0x0c33,
+        0x0c35, 0x0c39,
+        0x0c3d, 0x0c44,
+        0x0c46, 0x0c48,
+        0x0c4a, 0x0c4d,
+        0x0c55, 0x0c56,
+        0x0c58, 0x0c59,
+        0x0c60, 0x0c63,
+        0x0c66, 0x0c6f,
+        0x0c78, 0x0c7f,
+        0x0c82, 0x0c83,
+        0x0c85, 0x0c8c,
+        0x0c8e, 0x0c90,
+        0x0c92, 0x0ca8,
+        0x0caa, 0x0cb3,
+        0x0cb5, 0x0cb9,
+        0x0cbc, 0x0cc4,
+        0x0cc6, 0x0cc8,
+        0x0cca, 0x0ccd,
+        0x0cd5, 0x0cd6,
+        0x0cde, 0x0cde,
+        0x0ce0, 0x0ce3,
+        0x0ce6, 0x0cef,
+        0x0cf1, 0x0cf2,
+        0x0d02, 0x0d03,
+        0x0d05, 0x0d0c,
+        0x0d0e, 0x0d10,
+        0x0d12, 0x0d28,
+        0x0d2a, 0x0d39,
+        0x0d3d, 0x0d44,
+        0x0d46, 0x0d48,
+        0x0d4a, 0x0d4d,
+        0x0d57, 0x0d57,
+        0x0d60, 0x0d63,
+        0x0d66, 0x0d75,
+        0x0d79, 0x0d7f,
+        0x0d82, 0x0d83,
+        0x0d85, 0x0d96,
+        0x0d9a, 0x0db1,
+        0x0db3, 0x0dbb,
+        0x0dbd, 0x0dbd,
+        0x0dc0, 0x0dc6,
+        0x0dca, 0x0dca,
+        0x0dcf, 0x0dd4,
+        0x0dd6, 0x0dd6,
+        0x0dd8, 0x0ddf,
+        0x0df2, 0x0df4,
+        0x0e01, 0x0e3a,
+        0x0e3f, 0x0e5b,
+        0x0e81, 0x0e82,
+        0x0e84, 0x0e84,
+        0x0e87, 0x0e88,
+        0x0e8a, 0x0e8a,
+        0x0e8d, 0x0e8d,
+        0x0e94, 0x0e97,
+        0x0e99, 0x0e9f,
+        0x0ea1, 0x0ea3,
+        0x0ea5, 0x0ea5,
+        0x0ea7, 0x0ea7,
+        0x0eaa, 0x0eab,
+        0x0ead, 0x0eb9,
+        0x0ebb, 0x0ebd,
+        0x0ec0, 0x0ec4,
+        0x0ec6, 0x0ec6,
+        0x0ec8, 0x0ecd,
+        0x0ed0, 0x0ed9,
+        0x0edc, 0x0edd,
+        0x0f00, 0x0f47,
+        0x0f49, 0x0f6c,
+        0x0f71, 0x0f8b,
+        0x0f90, 0x0f97,
+        0x0f99, 0x0fbc,
+        0x0fbe, 0x0fcc,
+        0x0fce, 0x0fd8,
+        0x1000, 0x10c5,
+        0x10d0, 0x10fc,
+        0x1100, 0x1248,
+        0x124a, 0x124d,
+        0x1250, 0x1256,
+        0x1258, 0x1258,
+        0x125a, 0x125d,
+        0x1260, 0x1288,
+        0x128a, 0x128d,
+        0x1290, 0x12b0,
+        0x12b2, 0x12b5,
+        0x12b8, 0x12be,
+        0x12c0, 0x12c0,
+        0x12c2, 0x12c5,
+        0x12c8, 0x12d6,
+        0x12d8, 0x1310,
+        0x1312, 0x1315,
+        0x1318, 0x135a,
+        0x135f, 0x137c,
+        0x1380, 0x1399,
+        0x13a0, 0x13f4,
+        0x1400, 0x167f,
+        0x1681, 0x169c,
+        0x16a0, 0x16f0,
+        0x1700, 0x170c,
+        0x170e, 0x1714,
+        0x1720, 0x1736,
+        0x1740, 0x1753,
+        0x1760, 0x176c,
+        0x176e, 0x1770,
+        0x1772, 0x1773,
+        0x1780, 0x17dd,
+        0x17e0, 0x17e9,
+        0x17f0, 0x17f9,
+        0x1800, 0x180d,
+        0x1810, 0x1819,
+        0x1820, 0x1877,
+        0x1880, 0x18aa,
+        0x18b0, 0x18f5,
+        0x1900, 0x191c,
+        0x1920, 0x192b,
+        0x1930, 0x193b,
+        0x1940, 0x1940,
+        0x1944, 0x196d,
+        0x1970, 0x1974,
+        0x1980, 0x19ab,
+        0x19b0, 0x19c9,
+        0x19d0, 0x19da,
+        0x19de, 0x1a1b,
+        0x1a1e, 0x1a5e,
+        0x1a60, 0x1a7c,
+        0x1a7f, 0x1a89,
+        0x1a90, 0x1a99,
+        0x1aa0, 0x1aad,
+        0x1b00, 0x1b4b,
+        0x1b50, 0x1b7c,
+        0x1b80, 0x1baa,
+        0x1bae, 0x1bb9,
+        0x1c00, 0x1c37,
+        0x1c3b, 0x1c49,
+        0x1c4d, 0x1c7f,
+        0x1cd0, 0x1cf2,
+        0x1d00, 0x1de6,
+        0x1dfd, 0x1f15,
+        0x1f18, 0x1f1d,
+        0x1f20, 0x1f45,
+        0x1f48, 0x1f4d,
+        0x1f50, 0x1f57,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f7d,
+        0x1f80, 0x1fb4,
+        0x1fb6, 0x1fc4,
+        0x1fc6, 0x1fd3,
+        0x1fd6, 0x1fdb,
+        0x1fdd, 0x1fef,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ffe,
+        0x200b, 0x2027,
+        0x202a, 0x202e,
+        0x2030, 0x205e,
+        0x2060, 0x2064,
+        0x206a, 0x2071,
+        0x2074, 0x208e,
+        0x2090, 0x2094,
+        0x20a0, 0x20b8,
+        0x20d0, 0x20f0,
+        0x2100, 0x2189,
+        0x2190, 0x23e8,
+        0x2400, 0x2426,
+        0x2440, 0x244a,
+        0x2460, 0x26cd,
+        0x26cf, 0x26e1,
+        0x26e3, 0x26e3,
+        0x26e8, 0x26ff,
+        0x2701, 0x2704,
+        0x2706, 0x2709,
+        0x270c, 0x2727,
+        0x2729, 0x274b,
+        0x274d, 0x274d,
+        0x274f, 0x2752,
+        0x2756, 0x275e,
+        0x2761, 0x2794,
+        0x2798, 0x27af,
+        0x27b1, 0x27be,
+        0x27c0, 0x27ca,
+        0x27cc, 0x27cc,
+        0x27d0, 0x2b4c,
+        0x2b50, 0x2b59,
+        0x2c00, 0x2c2e,
+        0x2c30, 0x2c5e,
+        0x2c60, 0x2cf1,
+        0x2cf9, 0x2d25,
+        0x2d30, 0x2d65,
+        0x2d6f, 0x2d6f,
+        0x2d80, 0x2d96,
+        0x2da0, 0x2da6,
+        0x2da8, 0x2dae,
+        0x2db0, 0x2db6,
+        0x2db8, 0x2dbe,
+        0x2dc0, 0x2dc6,
+        0x2dc8, 0x2dce,
+        0x2dd0, 0x2dd6,
+        0x2dd8, 0x2dde,
+        0x2de0, 0x2e31,
+        0x2e80, 0x2e99,
+        0x2e9b, 0x2ef3,
+        0x2f00, 0x2fd5,
+        0x2ff0, 0x2ffb,
+        0x3001, 0x303f,
+        0x3041, 0x3096,
+        0x3099, 0x30ff,
+        0x3105, 0x312d,
+        0x3131, 0x318e,
+        0x3190, 0x31b7,
+        0x31c0, 0x31e3,
+        0x31f0, 0x321e,
+        0x3220, 0x32fe,
+        0x3300, 0x4db5,
+        0x4dc0, 0x9fcb,
+        0xa000, 0xa48c,
+        0xa490, 0xa4c6,
+        0xa4d0, 0xa62b,
+        0xa640, 0xa65f,
+        0xa662, 0xa673,
+        0xa67c, 0xa697,
+        0xa6a0, 0xa6f7,
+        0xa700, 0xa78c,
+        0xa7fb, 0xa82b,
+        0xa830, 0xa839,
+        0xa840, 0xa877,
+        0xa880, 0xa8c4,
+        0xa8ce, 0xa8d9,
+        0xa8e0, 0xa8fb,
+        0xa900, 0xa953,
+        0xa95f, 0xa97c,
+        0xa980, 0xa9cd,
+        0xa9cf, 0xa9d9,
+        0xa9de, 0xa9df,
+        0xaa00, 0xaa36,
+        0xaa40, 0xaa4d,
+        0xaa50, 0xaa59,
+        0xaa5c, 0xaa7b,
+        0xaa80, 0xaac2,
+        0xaadb, 0xaadf,
+        0xabc0, 0xabed,
+        0xabf0, 0xabf9,
+        0xac00, 0xd7a3,
+        0xd7b0, 0xd7c6,
+        0xd7cb, 0xd7fb,
+        0xe000, 0xfa2d,
+        0xfa30, 0xfa6d,
+        0xfa70, 0xfad9,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xfb1d, 0xfb36,
+        0xfb38, 0xfb3c,
+        0xfb3e, 0xfb3e,
+        0xfb40, 0xfb41,
+        0xfb43, 0xfb44,
+        0xfb46, 0xfbb1,
+        0xfbd3, 0xfd3f,
+        0xfd50, 0xfd8f,
+        0xfd92, 0xfdc7,
+        0xfdf0, 0xfdfd,
+        0xfe00, 0xfe19,
+        0xfe20, 0xfe26,
+        0xfe30, 0xfe52,
+        0xfe54, 0xfe66,
+        0xfe68, 0xfe6b,
+        0xfe70, 0xfe74,
+        0xfe76, 0xfefc,
+        0xfeff, 0xfeff,
+        0xff01, 0xffbe,
+        0xffc2, 0xffc7,
+        0xffca, 0xffcf,
+        0xffd2, 0xffd7,
+        0xffda, 0xffdc,
+        0xffe0, 0xffe6,
+        0xffe8, 0xffee,
+        0xfff9, 0xfffd,
+        0x10000, 0x1000b,
+        0x1000d, 0x10026,
+        0x10028, 0x1003a,
+        0x1003c, 0x1003d,
+        0x1003f, 0x1004d,
+        0x10050, 0x1005d,
+        0x10080, 0x100fa,
+        0x10100, 0x10102,
+        0x10107, 0x10133,
+        0x10137, 0x1018a,
+        0x10190, 0x1019b,
+        0x101d0, 0x101fd,
+        0x10280, 0x1029c,
+        0x102a0, 0x102d0,
+        0x10300, 0x1031e,
+        0x10320, 0x10323,
+        0x10330, 0x1034a,
+        0x10380, 0x1039d,
+        0x1039f, 0x103c3,
+        0x103c8, 0x103d5,
+        0x10400, 0x1049d,
+        0x104a0, 0x104a9,
+        0x10800, 0x10805,
+        0x10808, 0x10808,
+        0x1080a, 0x10835,
+        0x10837, 0x10838,
+        0x1083c, 0x1083c,
+        0x1083f, 0x10855,
+        0x10857, 0x1085f,
+        0x10900, 0x1091b,
+        0x1091f, 0x10939,
+        0x1093f, 0x1093f,
+        0x10a00, 0x10a03,
+        0x10a05, 0x10a06,
+        0x10a0c, 0x10a13,
+        0x10a15, 0x10a17,
+        0x10a19, 0x10a33,
+        0x10a38, 0x10a3a,
+        0x10a3f, 0x10a47,
+        0x10a50, 0x10a58,
+        0x10a60, 0x10a7f,
+        0x10b00, 0x10b35,
+        0x10b39, 0x10b55,
+        0x10b58, 0x10b72,
+        0x10b78, 0x10b7f,
+        0x10c00, 0x10c48,
+        0x10e60, 0x10e7e,
+        0x11080, 0x110c1,
+        0x12000, 0x1236e,
+        0x12400, 0x12462,
+        0x12470, 0x12473,
+        0x13000, 0x1342e,
+        0x1d000, 0x1d0f5,
+        0x1d100, 0x1d126,
+        0x1d129, 0x1d1dd,
+        0x1d200, 0x1d245,
+        0x1d300, 0x1d356,
+        0x1d360, 0x1d371,
+        0x1d400, 0x1d454,
+        0x1d456, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d51e, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d552, 0x1d6a5,
+        0x1d6a8, 0x1d7cb,
+        0x1d7ce, 0x1d7ff,
+        0x1f000, 0x1f02b,
+        0x1f030, 0x1f093,
+        0x1f100, 0x1f10a,
+        0x1f110, 0x1f12e,
+        0x1f131, 0x1f131,
+        0x1f13d, 0x1f13d,
+        0x1f13f, 0x1f13f,
+        0x1f142, 0x1f142,
+        0x1f146, 0x1f146,
+        0x1f14a, 0x1f14e,
+        0x1f157, 0x1f157,
+        0x1f15f, 0x1f15f,
+        0x1f179, 0x1f179,
+        0x1f17b, 0x1f17c,
+        0x1f17f, 0x1f17f,
+        0x1f18a, 0x1f18d,
+        0x1f190, 0x1f190,
+        0x1f200, 0x1f200,
+        0x1f210, 0x1f231,
+        0x1f240, 0x1f248,
+        0x20000, 0x2a6d6,
+        0x2a700, 0x2b734,
+        0x2f800, 0x2fa1d,
+        0xe0001, 0xe0001,
+        0xe0020, 0xe007f,
+        0xe0100, 0xe01ef,
+        0xf0000, 0xffffd,
+        0x100000, 0x10fffd,
 }; /* CR_Graph */
 
 /* 'Lower': [[:Lower:]] */
@@ -14639,494 +14639,494 @@ static const OnigCodePoint CR_Graph[] = {
 
 /* 'Print': [[:Print:]] */
 static const OnigCodePoint CR_Print[] = {
-	487,
-	0x0020, 0x007e,
-	0x00a0, 0x0377,
-	0x037a, 0x037e,
-	0x0384, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x03a1,
-	0x03a3, 0x0525,
-	0x0531, 0x0556,
-	0x0559, 0x055f,
-	0x0561, 0x0587,
-	0x0589, 0x058a,
-	0x0591, 0x05c7,
-	0x05d0, 0x05ea,
-	0x05f0, 0x05f4,
-	0x0600, 0x0603,
-	0x0606, 0x061b,
-	0x061e, 0x061f,
-	0x0621, 0x065e,
-	0x0660, 0x070d,
-	0x070f, 0x074a,
-	0x074d, 0x07b1,
-	0x07c0, 0x07fa,
-	0x0800, 0x082d,
-	0x0830, 0x083e,
-	0x0900, 0x0939,
-	0x093c, 0x094e,
-	0x0950, 0x0955,
-	0x0958, 0x0972,
-	0x0979, 0x097f,
-	0x0981, 0x0983,
-	0x0985, 0x098c,
-	0x098f, 0x0990,
-	0x0993, 0x09a8,
-	0x09aa, 0x09b0,
-	0x09b2, 0x09b2,
-	0x09b6, 0x09b9,
-	0x09bc, 0x09c4,
-	0x09c7, 0x09c8,
-	0x09cb, 0x09ce,
-	0x09d7, 0x09d7,
-	0x09dc, 0x09dd,
-	0x09df, 0x09e3,
-	0x09e6, 0x09fb,
-	0x0a01, 0x0a03,
-	0x0a05, 0x0a0a,
-	0x0a0f, 0x0a10,
-	0x0a13, 0x0a28,
-	0x0a2a, 0x0a30,
-	0x0a32, 0x0a33,
-	0x0a35, 0x0a36,
-	0x0a38, 0x0a39,
-	0x0a3c, 0x0a3c,
-	0x0a3e, 0x0a42,
-	0x0a47, 0x0a48,
-	0x0a4b, 0x0a4d,
-	0x0a51, 0x0a51,
-	0x0a59, 0x0a5c,
-	0x0a5e, 0x0a5e,
-	0x0a66, 0x0a75,
-	0x0a81, 0x0a83,
-	0x0a85, 0x0a8d,
-	0x0a8f, 0x0a91,
-	0x0a93, 0x0aa8,
-	0x0aaa, 0x0ab0,
-	0x0ab2, 0x0ab3,
-	0x0ab5, 0x0ab9,
-	0x0abc, 0x0ac5,
-	0x0ac7, 0x0ac9,
-	0x0acb, 0x0acd,
-	0x0ad0, 0x0ad0,
-	0x0ae0, 0x0ae3,
-	0x0ae6, 0x0aef,
-	0x0af1, 0x0af1,
-	0x0b01, 0x0b03,
-	0x0b05, 0x0b0c,
-	0x0b0f, 0x0b10,
-	0x0b13, 0x0b28,
-	0x0b2a, 0x0b30,
-	0x0b32, 0x0b33,
-	0x0b35, 0x0b39,
-	0x0b3c, 0x0b44,
-	0x0b47, 0x0b48,
-	0x0b4b, 0x0b4d,
-	0x0b56, 0x0b57,
-	0x0b5c, 0x0b5d,
-	0x0b5f, 0x0b63,
-	0x0b66, 0x0b71,
-	0x0b82, 0x0b83,
-	0x0b85, 0x0b8a,
-	0x0b8e, 0x0b90,
-	0x0b92, 0x0b95,
-	0x0b99, 0x0b9a,
-	0x0b9c, 0x0b9c,
-	0x0b9e, 0x0b9f,
-	0x0ba3, 0x0ba4,
-	0x0ba8, 0x0baa,
-	0x0bae, 0x0bb9,
-	0x0bbe, 0x0bc2,
-	0x0bc6, 0x0bc8,
-	0x0bca, 0x0bcd,
-	0x0bd0, 0x0bd0,
-	0x0bd7, 0x0bd7,
-	0x0be6, 0x0bfa,
-	0x0c01, 0x0c03,
-	0x0c05, 0x0c0c,
-	0x0c0e, 0x0c10,
-	0x0c12, 0x0c28,
-	0x0c2a, 0x0c33,
-	0x0c35, 0x0c39,
-	0x0c3d, 0x0c44,
-	0x0c46, 0x0c48,
-	0x0c4a, 0x0c4d,
-	0x0c55, 0x0c56,
-	0x0c58, 0x0c59,
-	0x0c60, 0x0c63,
-	0x0c66, 0x0c6f,
-	0x0c78, 0x0c7f,
-	0x0c82, 0x0c83,
-	0x0c85, 0x0c8c,
-	0x0c8e, 0x0c90,
-	0x0c92, 0x0ca8,
-	0x0caa, 0x0cb3,
-	0x0cb5, 0x0cb9,
-	0x0cbc, 0x0cc4,
-	0x0cc6, 0x0cc8,
-	0x0cca, 0x0ccd,
-	0x0cd5, 0x0cd6,
-	0x0cde, 0x0cde,
-	0x0ce0, 0x0ce3,
-	0x0ce6, 0x0cef,
-	0x0cf1, 0x0cf2,
-	0x0d02, 0x0d03,
-	0x0d05, 0x0d0c,
-	0x0d0e, 0x0d10,
-	0x0d12, 0x0d28,
-	0x0d2a, 0x0d39,
-	0x0d3d, 0x0d44,
-	0x0d46, 0x0d48,
-	0x0d4a, 0x0d4d,
-	0x0d57, 0x0d57,
-	0x0d60, 0x0d63,
-	0x0d66, 0x0d75,
-	0x0d79, 0x0d7f,
-	0x0d82, 0x0d83,
-	0x0d85, 0x0d96,
-	0x0d9a, 0x0db1,
-	0x0db3, 0x0dbb,
-	0x0dbd, 0x0dbd,
-	0x0dc0, 0x0dc6,
-	0x0dca, 0x0dca,
-	0x0dcf, 0x0dd4,
-	0x0dd6, 0x0dd6,
-	0x0dd8, 0x0ddf,
-	0x0df2, 0x0df4,
-	0x0e01, 0x0e3a,
-	0x0e3f, 0x0e5b,
-	0x0e81, 0x0e82,
-	0x0e84, 0x0e84,
-	0x0e87, 0x0e88,
-	0x0e8a, 0x0e8a,
-	0x0e8d, 0x0e8d,
-	0x0e94, 0x0e97,
-	0x0e99, 0x0e9f,
-	0x0ea1, 0x0ea3,
-	0x0ea5, 0x0ea5,
-	0x0ea7, 0x0ea7,
-	0x0eaa, 0x0eab,
-	0x0ead, 0x0eb9,
-	0x0ebb, 0x0ebd,
-	0x0ec0, 0x0ec4,
-	0x0ec6, 0x0ec6,
-	0x0ec8, 0x0ecd,
-	0x0ed0, 0x0ed9,
-	0x0edc, 0x0edd,
-	0x0f00, 0x0f47,
-	0x0f49, 0x0f6c,
-	0x0f71, 0x0f8b,
-	0x0f90, 0x0f97,
-	0x0f99, 0x0fbc,
-	0x0fbe, 0x0fcc,
-	0x0fce, 0x0fd8,
-	0x1000, 0x10c5,
-	0x10d0, 0x10fc,
-	0x1100, 0x1248,
-	0x124a, 0x124d,
-	0x1250, 0x1256,
-	0x1258, 0x1258,
-	0x125a, 0x125d,
-	0x1260, 0x1288,
-	0x128a, 0x128d,
-	0x1290, 0x12b0,
-	0x12b2, 0x12b5,
-	0x12b8, 0x12be,
-	0x12c0, 0x12c0,
-	0x12c2, 0x12c5,
-	0x12c8, 0x12d6,
-	0x12d8, 0x1310,
-	0x1312, 0x1315,
-	0x1318, 0x135a,
-	0x135f, 0x137c,
-	0x1380, 0x1399,
-	0x13a0, 0x13f4,
-	0x1400, 0x169c,
-	0x16a0, 0x16f0,
-	0x1700, 0x170c,
-	0x170e, 0x1714,
-	0x1720, 0x1736,
-	0x1740, 0x1753,
-	0x1760, 0x176c,
-	0x176e, 0x1770,
-	0x1772, 0x1773,
-	0x1780, 0x17dd,
-	0x17e0, 0x17e9,
-	0x17f0, 0x17f9,
-	0x1800, 0x180e,
-	0x1810, 0x1819,
-	0x1820, 0x1877,
-	0x1880, 0x18aa,
-	0x18b0, 0x18f5,
-	0x1900, 0x191c,
-	0x1920, 0x192b,
-	0x1930, 0x193b,
-	0x1940, 0x1940,
-	0x1944, 0x196d,
-	0x1970, 0x1974,
-	0x1980, 0x19ab,
-	0x19b0, 0x19c9,
-	0x19d0, 0x19da,
-	0x19de, 0x1a1b,
-	0x1a1e, 0x1a5e,
-	0x1a60, 0x1a7c,
-	0x1a7f, 0x1a89,
-	0x1a90, 0x1a99,
-	0x1aa0, 0x1aad,
-	0x1b00, 0x1b4b,
-	0x1b50, 0x1b7c,
-	0x1b80, 0x1baa,
-	0x1bae, 0x1bb9,
-	0x1c00, 0x1c37,
-	0x1c3b, 0x1c49,
-	0x1c4d, 0x1c7f,
-	0x1cd0, 0x1cf2,
-	0x1d00, 0x1de6,
-	0x1dfd, 0x1f15,
-	0x1f18, 0x1f1d,
-	0x1f20, 0x1f45,
-	0x1f48, 0x1f4d,
-	0x1f50, 0x1f57,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f7d,
-	0x1f80, 0x1fb4,
-	0x1fb6, 0x1fc4,
-	0x1fc6, 0x1fd3,
-	0x1fd6, 0x1fdb,
-	0x1fdd, 0x1fef,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ffe,
-	0x2000, 0x2027,
-	0x202a, 0x2064,
-	0x206a, 0x2071,
-	0x2074, 0x208e,
-	0x2090, 0x2094,
-	0x20a0, 0x20b8,
-	0x20d0, 0x20f0,
-	0x2100, 0x2189,
-	0x2190, 0x23e8,
-	0x2400, 0x2426,
-	0x2440, 0x244a,
-	0x2460, 0x26cd,
-	0x26cf, 0x26e1,
-	0x26e3, 0x26e3,
-	0x26e8, 0x26ff,
-	0x2701, 0x2704,
-	0x2706, 0x2709,
-	0x270c, 0x2727,
-	0x2729, 0x274b,
-	0x274d, 0x274d,
-	0x274f, 0x2752,
-	0x2756, 0x275e,
-	0x2761, 0x2794,
-	0x2798, 0x27af,
-	0x27b1, 0x27be,
-	0x27c0, 0x27ca,
-	0x27cc, 0x27cc,
-	0x27d0, 0x2b4c,
-	0x2b50, 0x2b59,
-	0x2c00, 0x2c2e,
-	0x2c30, 0x2c5e,
-	0x2c60, 0x2cf1,
-	0x2cf9, 0x2d25,
-	0x2d30, 0x2d65,
-	0x2d6f, 0x2d6f,
-	0x2d80, 0x2d96,
-	0x2da0, 0x2da6,
-	0x2da8, 0x2dae,
-	0x2db0, 0x2db6,
-	0x2db8, 0x2dbe,
-	0x2dc0, 0x2dc6,
-	0x2dc8, 0x2dce,
-	0x2dd0, 0x2dd6,
-	0x2dd8, 0x2dde,
-	0x2de0, 0x2e31,
-	0x2e80, 0x2e99,
-	0x2e9b, 0x2ef3,
-	0x2f00, 0x2fd5,
-	0x2ff0, 0x2ffb,
-	0x3000, 0x303f,
-	0x3041, 0x3096,
-	0x3099, 0x30ff,
-	0x3105, 0x312d,
-	0x3131, 0x318e,
-	0x3190, 0x31b7,
-	0x31c0, 0x31e3,
-	0x31f0, 0x321e,
-	0x3220, 0x32fe,
-	0x3300, 0x4db5,
-	0x4dc0, 0x9fcb,
-	0xa000, 0xa48c,
-	0xa490, 0xa4c6,
-	0xa4d0, 0xa62b,
-	0xa640, 0xa65f,
-	0xa662, 0xa673,
-	0xa67c, 0xa697,
-	0xa6a0, 0xa6f7,
-	0xa700, 0xa78c,
-	0xa7fb, 0xa82b,
-	0xa830, 0xa839,
-	0xa840, 0xa877,
-	0xa880, 0xa8c4,
-	0xa8ce, 0xa8d9,
-	0xa8e0, 0xa8fb,
-	0xa900, 0xa953,
-	0xa95f, 0xa97c,
-	0xa980, 0xa9cd,
-	0xa9cf, 0xa9d9,
-	0xa9de, 0xa9df,
-	0xaa00, 0xaa36,
-	0xaa40, 0xaa4d,
-	0xaa50, 0xaa59,
-	0xaa5c, 0xaa7b,
-	0xaa80, 0xaac2,
-	0xaadb, 0xaadf,
-	0xabc0, 0xabed,
-	0xabf0, 0xabf9,
-	0xac00, 0xd7a3,
-	0xd7b0, 0xd7c6,
-	0xd7cb, 0xd7fb,
-	0xe000, 0xfa2d,
-	0xfa30, 0xfa6d,
-	0xfa70, 0xfad9,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xfb1d, 0xfb36,
-	0xfb38, 0xfb3c,
-	0xfb3e, 0xfb3e,
-	0xfb40, 0xfb41,
-	0xfb43, 0xfb44,
-	0xfb46, 0xfbb1,
-	0xfbd3, 0xfd3f,
-	0xfd50, 0xfd8f,
-	0xfd92, 0xfdc7,
-	0xfdf0, 0xfdfd,
-	0xfe00, 0xfe19,
-	0xfe20, 0xfe26,
-	0xfe30, 0xfe52,
-	0xfe54, 0xfe66,
-	0xfe68, 0xfe6b,
-	0xfe70, 0xfe74,
-	0xfe76, 0xfefc,
-	0xfeff, 0xfeff,
-	0xff01, 0xffbe,
-	0xffc2, 0xffc7,
-	0xffca, 0xffcf,
-	0xffd2, 0xffd7,
-	0xffda, 0xffdc,
-	0xffe0, 0xffe6,
-	0xffe8, 0xffee,
-	0xfff9, 0xfffd,
-	0x10000, 0x1000b,
-	0x1000d, 0x10026,
-	0x10028, 0x1003a,
-	0x1003c, 0x1003d,
-	0x1003f, 0x1004d,
-	0x10050, 0x1005d,
-	0x10080, 0x100fa,
-	0x10100, 0x10102,
-	0x10107, 0x10133,
-	0x10137, 0x1018a,
-	0x10190, 0x1019b,
-	0x101d0, 0x101fd,
-	0x10280, 0x1029c,
-	0x102a0, 0x102d0,
-	0x10300, 0x1031e,
-	0x10320, 0x10323,
-	0x10330, 0x1034a,
-	0x10380, 0x1039d,
-	0x1039f, 0x103c3,
-	0x103c8, 0x103d5,
-	0x10400, 0x1049d,
-	0x104a0, 0x104a9,
-	0x10800, 0x10805,
-	0x10808, 0x10808,
-	0x1080a, 0x10835,
-	0x10837, 0x10838,
-	0x1083c, 0x1083c,
-	0x1083f, 0x10855,
-	0x10857, 0x1085f,
-	0x10900, 0x1091b,
-	0x1091f, 0x10939,
-	0x1093f, 0x1093f,
-	0x10a00, 0x10a03,
-	0x10a05, 0x10a06,
-	0x10a0c, 0x10a13,
-	0x10a15, 0x10a17,
-	0x10a19, 0x10a33,
-	0x10a38, 0x10a3a,
-	0x10a3f, 0x10a47,
-	0x10a50, 0x10a58,
-	0x10a60, 0x10a7f,
-	0x10b00, 0x10b35,
-	0x10b39, 0x10b55,
-	0x10b58, 0x10b72,
-	0x10b78, 0x10b7f,
-	0x10c00, 0x10c48,
-	0x10e60, 0x10e7e,
-	0x11080, 0x110c1,
-	0x12000, 0x1236e,
-	0x12400, 0x12462,
-	0x12470, 0x12473,
-	0x13000, 0x1342e,
-	0x1d000, 0x1d0f5,
-	0x1d100, 0x1d126,
-	0x1d129, 0x1d1dd,
-	0x1d200, 0x1d245,
-	0x1d300, 0x1d356,
-	0x1d360, 0x1d371,
-	0x1d400, 0x1d454,
-	0x1d456, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d51e, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d552, 0x1d6a5,
-	0x1d6a8, 0x1d7cb,
-	0x1d7ce, 0x1d7ff,
-	0x1f000, 0x1f02b,
-	0x1f030, 0x1f093,
-	0x1f100, 0x1f10a,
-	0x1f110, 0x1f12e,
-	0x1f131, 0x1f131,
-	0x1f13d, 0x1f13d,
-	0x1f13f, 0x1f13f,
-	0x1f142, 0x1f142,
-	0x1f146, 0x1f146,
-	0x1f14a, 0x1f14e,
-	0x1f157, 0x1f157,
-	0x1f15f, 0x1f15f,
-	0x1f179, 0x1f179,
-	0x1f17b, 0x1f17c,
-	0x1f17f, 0x1f17f,
-	0x1f18a, 0x1f18d,
-	0x1f190, 0x1f190,
-	0x1f200, 0x1f200,
-	0x1f210, 0x1f231,
-	0x1f240, 0x1f248,
-	0x20000, 0x2a6d6,
-	0x2a700, 0x2b734,
-	0x2f800, 0x2fa1d,
-	0xe0001, 0xe0001,
-	0xe0020, 0xe007f,
-	0xe0100, 0xe01ef,
-	0xf0000, 0xffffd,
-	0x100000, 0x10fffd,
+        487,
+        0x0020, 0x007e,
+        0x00a0, 0x0377,
+        0x037a, 0x037e,
+        0x0384, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x03a1,
+        0x03a3, 0x0525,
+        0x0531, 0x0556,
+        0x0559, 0x055f,
+        0x0561, 0x0587,
+        0x0589, 0x058a,
+        0x0591, 0x05c7,
+        0x05d0, 0x05ea,
+        0x05f0, 0x05f4,
+        0x0600, 0x0603,
+        0x0606, 0x061b,
+        0x061e, 0x061f,
+        0x0621, 0x065e,
+        0x0660, 0x070d,
+        0x070f, 0x074a,
+        0x074d, 0x07b1,
+        0x07c0, 0x07fa,
+        0x0800, 0x082d,
+        0x0830, 0x083e,
+        0x0900, 0x0939,
+        0x093c, 0x094e,
+        0x0950, 0x0955,
+        0x0958, 0x0972,
+        0x0979, 0x097f,
+        0x0981, 0x0983,
+        0x0985, 0x098c,
+        0x098f, 0x0990,
+        0x0993, 0x09a8,
+        0x09aa, 0x09b0,
+        0x09b2, 0x09b2,
+        0x09b6, 0x09b9,
+        0x09bc, 0x09c4,
+        0x09c7, 0x09c8,
+        0x09cb, 0x09ce,
+        0x09d7, 0x09d7,
+        0x09dc, 0x09dd,
+        0x09df, 0x09e3,
+        0x09e6, 0x09fb,
+        0x0a01, 0x0a03,
+        0x0a05, 0x0a0a,
+        0x0a0f, 0x0a10,
+        0x0a13, 0x0a28,
+        0x0a2a, 0x0a30,
+        0x0a32, 0x0a33,
+        0x0a35, 0x0a36,
+        0x0a38, 0x0a39,
+        0x0a3c, 0x0a3c,
+        0x0a3e, 0x0a42,
+        0x0a47, 0x0a48,
+        0x0a4b, 0x0a4d,
+        0x0a51, 0x0a51,
+        0x0a59, 0x0a5c,
+        0x0a5e, 0x0a5e,
+        0x0a66, 0x0a75,
+        0x0a81, 0x0a83,
+        0x0a85, 0x0a8d,
+        0x0a8f, 0x0a91,
+        0x0a93, 0x0aa8,
+        0x0aaa, 0x0ab0,
+        0x0ab2, 0x0ab3,
+        0x0ab5, 0x0ab9,
+        0x0abc, 0x0ac5,
+        0x0ac7, 0x0ac9,
+        0x0acb, 0x0acd,
+        0x0ad0, 0x0ad0,
+        0x0ae0, 0x0ae3,
+        0x0ae6, 0x0aef,
+        0x0af1, 0x0af1,
+        0x0b01, 0x0b03,
+        0x0b05, 0x0b0c,
+        0x0b0f, 0x0b10,
+        0x0b13, 0x0b28,
+        0x0b2a, 0x0b30,
+        0x0b32, 0x0b33,
+        0x0b35, 0x0b39,
+        0x0b3c, 0x0b44,
+        0x0b47, 0x0b48,
+        0x0b4b, 0x0b4d,
+        0x0b56, 0x0b57,
+        0x0b5c, 0x0b5d,
+        0x0b5f, 0x0b63,
+        0x0b66, 0x0b71,
+        0x0b82, 0x0b83,
+        0x0b85, 0x0b8a,
+        0x0b8e, 0x0b90,
+        0x0b92, 0x0b95,
+        0x0b99, 0x0b9a,
+        0x0b9c, 0x0b9c,
+        0x0b9e, 0x0b9f,
+        0x0ba3, 0x0ba4,
+        0x0ba8, 0x0baa,
+        0x0bae, 0x0bb9,
+        0x0bbe, 0x0bc2,
+        0x0bc6, 0x0bc8,
+        0x0bca, 0x0bcd,
+        0x0bd0, 0x0bd0,
+        0x0bd7, 0x0bd7,
+        0x0be6, 0x0bfa,
+        0x0c01, 0x0c03,
+        0x0c05, 0x0c0c,
+        0x0c0e, 0x0c10,
+        0x0c12, 0x0c28,
+        0x0c2a, 0x0c33,
+        0x0c35, 0x0c39,
+        0x0c3d, 0x0c44,
+        0x0c46, 0x0c48,
+        0x0c4a, 0x0c4d,
+        0x0c55, 0x0c56,
+        0x0c58, 0x0c59,
+        0x0c60, 0x0c63,
+        0x0c66, 0x0c6f,
+        0x0c78, 0x0c7f,
+        0x0c82, 0x0c83,
+        0x0c85, 0x0c8c,
+        0x0c8e, 0x0c90,
+        0x0c92, 0x0ca8,
+        0x0caa, 0x0cb3,
+        0x0cb5, 0x0cb9,
+        0x0cbc, 0x0cc4,
+        0x0cc6, 0x0cc8,
+        0x0cca, 0x0ccd,
+        0x0cd5, 0x0cd6,
+        0x0cde, 0x0cde,
+        0x0ce0, 0x0ce3,
+        0x0ce6, 0x0cef,
+        0x0cf1, 0x0cf2,
+        0x0d02, 0x0d03,
+        0x0d05, 0x0d0c,
+        0x0d0e, 0x0d10,
+        0x0d12, 0x0d28,
+        0x0d2a, 0x0d39,
+        0x0d3d, 0x0d44,
+        0x0d46, 0x0d48,
+        0x0d4a, 0x0d4d,
+        0x0d57, 0x0d57,
+        0x0d60, 0x0d63,
+        0x0d66, 0x0d75,
+        0x0d79, 0x0d7f,
+        0x0d82, 0x0d83,
+        0x0d85, 0x0d96,
+        0x0d9a, 0x0db1,
+        0x0db3, 0x0dbb,
+        0x0dbd, 0x0dbd,
+        0x0dc0, 0x0dc6,
+        0x0dca, 0x0dca,
+        0x0dcf, 0x0dd4,
+        0x0dd6, 0x0dd6,
+        0x0dd8, 0x0ddf,
+        0x0df2, 0x0df4,
+        0x0e01, 0x0e3a,
+        0x0e3f, 0x0e5b,
+        0x0e81, 0x0e82,
+        0x0e84, 0x0e84,
+        0x0e87, 0x0e88,
+        0x0e8a, 0x0e8a,
+        0x0e8d, 0x0e8d,
+        0x0e94, 0x0e97,
+        0x0e99, 0x0e9f,
+        0x0ea1, 0x0ea3,
+        0x0ea5, 0x0ea5,
+        0x0ea7, 0x0ea7,
+        0x0eaa, 0x0eab,
+        0x0ead, 0x0eb9,
+        0x0ebb, 0x0ebd,
+        0x0ec0, 0x0ec4,
+        0x0ec6, 0x0ec6,
+        0x0ec8, 0x0ecd,
+        0x0ed0, 0x0ed9,
+        0x0edc, 0x0edd,
+        0x0f00, 0x0f47,
+        0x0f49, 0x0f6c,
+        0x0f71, 0x0f8b,
+        0x0f90, 0x0f97,
+        0x0f99, 0x0fbc,
+        0x0fbe, 0x0fcc,
+        0x0fce, 0x0fd8,
+        0x1000, 0x10c5,
+        0x10d0, 0x10fc,
+        0x1100, 0x1248,
+        0x124a, 0x124d,
+        0x1250, 0x1256,
+        0x1258, 0x1258,
+        0x125a, 0x125d,
+        0x1260, 0x1288,
+        0x128a, 0x128d,
+        0x1290, 0x12b0,
+        0x12b2, 0x12b5,
+        0x12b8, 0x12be,
+        0x12c0, 0x12c0,
+        0x12c2, 0x12c5,
+        0x12c8, 0x12d6,
+        0x12d8, 0x1310,
+        0x1312, 0x1315,
+        0x1318, 0x135a,
+        0x135f, 0x137c,
+        0x1380, 0x1399,
+        0x13a0, 0x13f4,
+        0x1400, 0x169c,
+        0x16a0, 0x16f0,
+        0x1700, 0x170c,
+        0x170e, 0x1714,
+        0x1720, 0x1736,
+        0x1740, 0x1753,
+        0x1760, 0x176c,
+        0x176e, 0x1770,
+        0x1772, 0x1773,
+        0x1780, 0x17dd,
+        0x17e0, 0x17e9,
+        0x17f0, 0x17f9,
+        0x1800, 0x180e,
+        0x1810, 0x1819,
+        0x1820, 0x1877,
+        0x1880, 0x18aa,
+        0x18b0, 0x18f5,
+        0x1900, 0x191c,
+        0x1920, 0x192b,
+        0x1930, 0x193b,
+        0x1940, 0x1940,
+        0x1944, 0x196d,
+        0x1970, 0x1974,
+        0x1980, 0x19ab,
+        0x19b0, 0x19c9,
+        0x19d0, 0x19da,
+        0x19de, 0x1a1b,
+        0x1a1e, 0x1a5e,
+        0x1a60, 0x1a7c,
+        0x1a7f, 0x1a89,
+        0x1a90, 0x1a99,
+        0x1aa0, 0x1aad,
+        0x1b00, 0x1b4b,
+        0x1b50, 0x1b7c,
+        0x1b80, 0x1baa,
+        0x1bae, 0x1bb9,
+        0x1c00, 0x1c37,
+        0x1c3b, 0x1c49,
+        0x1c4d, 0x1c7f,
+        0x1cd0, 0x1cf2,
+        0x1d00, 0x1de6,
+        0x1dfd, 0x1f15,
+        0x1f18, 0x1f1d,
+        0x1f20, 0x1f45,
+        0x1f48, 0x1f4d,
+        0x1f50, 0x1f57,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f7d,
+        0x1f80, 0x1fb4,
+        0x1fb6, 0x1fc4,
+        0x1fc6, 0x1fd3,
+        0x1fd6, 0x1fdb,
+        0x1fdd, 0x1fef,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ffe,
+        0x2000, 0x2027,
+        0x202a, 0x2064,
+        0x206a, 0x2071,
+        0x2074, 0x208e,
+        0x2090, 0x2094,
+        0x20a0, 0x20b8,
+        0x20d0, 0x20f0,
+        0x2100, 0x2189,
+        0x2190, 0x23e8,
+        0x2400, 0x2426,
+        0x2440, 0x244a,
+        0x2460, 0x26cd,
+        0x26cf, 0x26e1,
+        0x26e3, 0x26e3,
+        0x26e8, 0x26ff,
+        0x2701, 0x2704,
+        0x2706, 0x2709,
+        0x270c, 0x2727,
+        0x2729, 0x274b,
+        0x274d, 0x274d,
+        0x274f, 0x2752,
+        0x2756, 0x275e,
+        0x2761, 0x2794,
+        0x2798, 0x27af,
+        0x27b1, 0x27be,
+        0x27c0, 0x27ca,
+        0x27cc, 0x27cc,
+        0x27d0, 0x2b4c,
+        0x2b50, 0x2b59,
+        0x2c00, 0x2c2e,
+        0x2c30, 0x2c5e,
+        0x2c60, 0x2cf1,
+        0x2cf9, 0x2d25,
+        0x2d30, 0x2d65,
+        0x2d6f, 0x2d6f,
+        0x2d80, 0x2d96,
+        0x2da0, 0x2da6,
+        0x2da8, 0x2dae,
+        0x2db0, 0x2db6,
+        0x2db8, 0x2dbe,
+        0x2dc0, 0x2dc6,
+        0x2dc8, 0x2dce,
+        0x2dd0, 0x2dd6,
+        0x2dd8, 0x2dde,
+        0x2de0, 0x2e31,
+        0x2e80, 0x2e99,
+        0x2e9b, 0x2ef3,
+        0x2f00, 0x2fd5,
+        0x2ff0, 0x2ffb,
+        0x3000, 0x303f,
+        0x3041, 0x3096,
+        0x3099, 0x30ff,
+        0x3105, 0x312d,
+        0x3131, 0x318e,
+        0x3190, 0x31b7,
+        0x31c0, 0x31e3,
+        0x31f0, 0x321e,
+        0x3220, 0x32fe,
+        0x3300, 0x4db5,
+        0x4dc0, 0x9fcb,
+        0xa000, 0xa48c,
+        0xa490, 0xa4c6,
+        0xa4d0, 0xa62b,
+        0xa640, 0xa65f,
+        0xa662, 0xa673,
+        0xa67c, 0xa697,
+        0xa6a0, 0xa6f7,
+        0xa700, 0xa78c,
+        0xa7fb, 0xa82b,
+        0xa830, 0xa839,
+        0xa840, 0xa877,
+        0xa880, 0xa8c4,
+        0xa8ce, 0xa8d9,
+        0xa8e0, 0xa8fb,
+        0xa900, 0xa953,
+        0xa95f, 0xa97c,
+        0xa980, 0xa9cd,
+        0xa9cf, 0xa9d9,
+        0xa9de, 0xa9df,
+        0xaa00, 0xaa36,
+        0xaa40, 0xaa4d,
+        0xaa50, 0xaa59,
+        0xaa5c, 0xaa7b,
+        0xaa80, 0xaac2,
+        0xaadb, 0xaadf,
+        0xabc0, 0xabed,
+        0xabf0, 0xabf9,
+        0xac00, 0xd7a3,
+        0xd7b0, 0xd7c6,
+        0xd7cb, 0xd7fb,
+        0xe000, 0xfa2d,
+        0xfa30, 0xfa6d,
+        0xfa70, 0xfad9,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xfb1d, 0xfb36,
+        0xfb38, 0xfb3c,
+        0xfb3e, 0xfb3e,
+        0xfb40, 0xfb41,
+        0xfb43, 0xfb44,
+        0xfb46, 0xfbb1,
+        0xfbd3, 0xfd3f,
+        0xfd50, 0xfd8f,
+        0xfd92, 0xfdc7,
+        0xfdf0, 0xfdfd,
+        0xfe00, 0xfe19,
+        0xfe20, 0xfe26,
+        0xfe30, 0xfe52,
+        0xfe54, 0xfe66,
+        0xfe68, 0xfe6b,
+        0xfe70, 0xfe74,
+        0xfe76, 0xfefc,
+        0xfeff, 0xfeff,
+        0xff01, 0xffbe,
+        0xffc2, 0xffc7,
+        0xffca, 0xffcf,
+        0xffd2, 0xffd7,
+        0xffda, 0xffdc,
+        0xffe0, 0xffe6,
+        0xffe8, 0xffee,
+        0xfff9, 0xfffd,
+        0x10000, 0x1000b,
+        0x1000d, 0x10026,
+        0x10028, 0x1003a,
+        0x1003c, 0x1003d,
+        0x1003f, 0x1004d,
+        0x10050, 0x1005d,
+        0x10080, 0x100fa,
+        0x10100, 0x10102,
+        0x10107, 0x10133,
+        0x10137, 0x1018a,
+        0x10190, 0x1019b,
+        0x101d0, 0x101fd,
+        0x10280, 0x1029c,
+        0x102a0, 0x102d0,
+        0x10300, 0x1031e,
+        0x10320, 0x10323,
+        0x10330, 0x1034a,
+        0x10380, 0x1039d,
+        0x1039f, 0x103c3,
+        0x103c8, 0x103d5,
+        0x10400, 0x1049d,
+        0x104a0, 0x104a9,
+        0x10800, 0x10805,
+        0x10808, 0x10808,
+        0x1080a, 0x10835,
+        0x10837, 0x10838,
+        0x1083c, 0x1083c,
+        0x1083f, 0x10855,
+        0x10857, 0x1085f,
+        0x10900, 0x1091b,
+        0x1091f, 0x10939,
+        0x1093f, 0x1093f,
+        0x10a00, 0x10a03,
+        0x10a05, 0x10a06,
+        0x10a0c, 0x10a13,
+        0x10a15, 0x10a17,
+        0x10a19, 0x10a33,
+        0x10a38, 0x10a3a,
+        0x10a3f, 0x10a47,
+        0x10a50, 0x10a58,
+        0x10a60, 0x10a7f,
+        0x10b00, 0x10b35,
+        0x10b39, 0x10b55,
+        0x10b58, 0x10b72,
+        0x10b78, 0x10b7f,
+        0x10c00, 0x10c48,
+        0x10e60, 0x10e7e,
+        0x11080, 0x110c1,
+        0x12000, 0x1236e,
+        0x12400, 0x12462,
+        0x12470, 0x12473,
+        0x13000, 0x1342e,
+        0x1d000, 0x1d0f5,
+        0x1d100, 0x1d126,
+        0x1d129, 0x1d1dd,
+        0x1d200, 0x1d245,
+        0x1d300, 0x1d356,
+        0x1d360, 0x1d371,
+        0x1d400, 0x1d454,
+        0x1d456, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d51e, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d552, 0x1d6a5,
+        0x1d6a8, 0x1d7cb,
+        0x1d7ce, 0x1d7ff,
+        0x1f000, 0x1f02b,
+        0x1f030, 0x1f093,
+        0x1f100, 0x1f10a,
+        0x1f110, 0x1f12e,
+        0x1f131, 0x1f131,
+        0x1f13d, 0x1f13d,
+        0x1f13f, 0x1f13f,
+        0x1f142, 0x1f142,
+        0x1f146, 0x1f146,
+        0x1f14a, 0x1f14e,
+        0x1f157, 0x1f157,
+        0x1f15f, 0x1f15f,
+        0x1f179, 0x1f179,
+        0x1f17b, 0x1f17c,
+        0x1f17f, 0x1f17f,
+        0x1f18a, 0x1f18d,
+        0x1f190, 0x1f190,
+        0x1f200, 0x1f200,
+        0x1f210, 0x1f231,
+        0x1f240, 0x1f248,
+        0x20000, 0x2a6d6,
+        0x2a700, 0x2b734,
+        0x2f800, 0x2fa1d,
+        0xe0001, 0xe0001,
+        0xe0020, 0xe007f,
+        0xe0100, 0xe01ef,
+        0xf0000, 0xffffd,
+        0x100000, 0x10fffd,
 }; /* CR_Print */
 
 /* 'Punct': [[:Punct:]] */
@@ -15143,1021 +15143,1021 @@ static const OnigCodePoint CR_Print[] = {
 
 /* 'Word': [[:Word:]] */
 static const OnigCodePoint CR_Word[] = {
-	506,
-	0x0030, 0x0039,
-	0x0041, 0x005a,
-	0x005f, 0x005f,
-	0x0061, 0x007a,
-	0x00aa, 0x00aa,
-	0x00b5, 0x00b5,
-	0x00ba, 0x00ba,
-	0x00c0, 0x00d6,
-	0x00d8, 0x00f6,
-	0x00f8, 0x02c1,
-	0x02c6, 0x02d1,
-	0x02e0, 0x02e4,
-	0x02ec, 0x02ec,
-	0x02ee, 0x02ee,
-	0x0300, 0x0374,
-	0x0376, 0x0377,
-	0x037a, 0x037d,
-	0x0386, 0x0386,
-	0x0388, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x03a1,
-	0x03a3, 0x03f5,
-	0x03f7, 0x0481,
-	0x0483, 0x0525,
-	0x0531, 0x0556,
-	0x0559, 0x0559,
-	0x0561, 0x0587,
-	0x0591, 0x05bd,
-	0x05bf, 0x05bf,
-	0x05c1, 0x05c2,
-	0x05c4, 0x05c5,
-	0x05c7, 0x05c7,
-	0x05d0, 0x05ea,
-	0x05f0, 0x05f2,
-	0x0610, 0x061a,
-	0x0621, 0x065e,
-	0x0660, 0x0669,
-	0x066e, 0x06d3,
-	0x06d5, 0x06dc,
-	0x06de, 0x06e8,
-	0x06ea, 0x06fc,
-	0x06ff, 0x06ff,
-	0x0710, 0x074a,
-	0x074d, 0x07b1,
-	0x07c0, 0x07f5,
-	0x07fa, 0x07fa,
-	0x0800, 0x082d,
-	0x0900, 0x0939,
-	0x093c, 0x094e,
-	0x0950, 0x0955,
-	0x0958, 0x0963,
-	0x0966, 0x096f,
-	0x0971, 0x0972,
-	0x0979, 0x097f,
-	0x0981, 0x0983,
-	0x0985, 0x098c,
-	0x098f, 0x0990,
-	0x0993, 0x09a8,
-	0x09aa, 0x09b0,
-	0x09b2, 0x09b2,
-	0x09b6, 0x09b9,
-	0x09bc, 0x09c4,
-	0x09c7, 0x09c8,
-	0x09cb, 0x09ce,
-	0x09d7, 0x09d7,
-	0x09dc, 0x09dd,
-	0x09df, 0x09e3,
-	0x09e6, 0x09f1,
-	0x0a01, 0x0a03,
-	0x0a05, 0x0a0a,
-	0x0a0f, 0x0a10,
-	0x0a13, 0x0a28,
-	0x0a2a, 0x0a30,
-	0x0a32, 0x0a33,
-	0x0a35, 0x0a36,
-	0x0a38, 0x0a39,
-	0x0a3c, 0x0a3c,
-	0x0a3e, 0x0a42,
-	0x0a47, 0x0a48,
-	0x0a4b, 0x0a4d,
-	0x0a51, 0x0a51,
-	0x0a59, 0x0a5c,
-	0x0a5e, 0x0a5e,
-	0x0a66, 0x0a75,
-	0x0a81, 0x0a83,
-	0x0a85, 0x0a8d,
-	0x0a8f, 0x0a91,
-	0x0a93, 0x0aa8,
-	0x0aaa, 0x0ab0,
-	0x0ab2, 0x0ab3,
-	0x0ab5, 0x0ab9,
-	0x0abc, 0x0ac5,
-	0x0ac7, 0x0ac9,
-	0x0acb, 0x0acd,
-	0x0ad0, 0x0ad0,
-	0x0ae0, 0x0ae3,
-	0x0ae6, 0x0aef,
-	0x0b01, 0x0b03,
-	0x0b05, 0x0b0c,
-	0x0b0f, 0x0b10,
-	0x0b13, 0x0b28,
-	0x0b2a, 0x0b30,
-	0x0b32, 0x0b33,
-	0x0b35, 0x0b39,
-	0x0b3c, 0x0b44,
-	0x0b47, 0x0b48,
-	0x0b4b, 0x0b4d,
-	0x0b56, 0x0b57,
-	0x0b5c, 0x0b5d,
-	0x0b5f, 0x0b63,
-	0x0b66, 0x0b6f,
-	0x0b71, 0x0b71,
-	0x0b82, 0x0b83,
-	0x0b85, 0x0b8a,
-	0x0b8e, 0x0b90,
-	0x0b92, 0x0b95,
-	0x0b99, 0x0b9a,
-	0x0b9c, 0x0b9c,
-	0x0b9e, 0x0b9f,
-	0x0ba3, 0x0ba4,
-	0x0ba8, 0x0baa,
-	0x0bae, 0x0bb9,
-	0x0bbe, 0x0bc2,
-	0x0bc6, 0x0bc8,
-	0x0bca, 0x0bcd,
-	0x0bd0, 0x0bd0,
-	0x0bd7, 0x0bd7,
-	0x0be6, 0x0bef,
-	0x0c01, 0x0c03,
-	0x0c05, 0x0c0c,
-	0x0c0e, 0x0c10,
-	0x0c12, 0x0c28,
-	0x0c2a, 0x0c33,
-	0x0c35, 0x0c39,
-	0x0c3d, 0x0c44,
-	0x0c46, 0x0c48,
-	0x0c4a, 0x0c4d,
-	0x0c55, 0x0c56,
-	0x0c58, 0x0c59,
-	0x0c60, 0x0c63,
-	0x0c66, 0x0c6f,
-	0x0c82, 0x0c83,
-	0x0c85, 0x0c8c,
-	0x0c8e, 0x0c90,
-	0x0c92, 0x0ca8,
-	0x0caa, 0x0cb3,
-	0x0cb5, 0x0cb9,
-	0x0cbc, 0x0cc4,
-	0x0cc6, 0x0cc8,
-	0x0cca, 0x0ccd,
-	0x0cd5, 0x0cd6,
-	0x0cde, 0x0cde,
-	0x0ce0, 0x0ce3,
-	0x0ce6, 0x0cef,
-	0x0d02, 0x0d03,
-	0x0d05, 0x0d0c,
-	0x0d0e, 0x0d10,
-	0x0d12, 0x0d28,
-	0x0d2a, 0x0d39,
-	0x0d3d, 0x0d44,
-	0x0d46, 0x0d48,
-	0x0d4a, 0x0d4d,
-	0x0d57, 0x0d57,
-	0x0d60, 0x0d63,
-	0x0d66, 0x0d6f,
-	0x0d7a, 0x0d7f,
-	0x0d82, 0x0d83,
-	0x0d85, 0x0d96,
-	0x0d9a, 0x0db1,
-	0x0db3, 0x0dbb,
-	0x0dbd, 0x0dbd,
-	0x0dc0, 0x0dc6,
-	0x0dca, 0x0dca,
-	0x0dcf, 0x0dd4,
-	0x0dd6, 0x0dd6,
-	0x0dd8, 0x0ddf,
-	0x0df2, 0x0df3,
-	0x0e01, 0x0e3a,
-	0x0e40, 0x0e4e,
-	0x0e50, 0x0e59,
-	0x0e81, 0x0e82,
-	0x0e84, 0x0e84,
-	0x0e87, 0x0e88,
-	0x0e8a, 0x0e8a,
-	0x0e8d, 0x0e8d,
-	0x0e94, 0x0e97,
-	0x0e99, 0x0e9f,
-	0x0ea1, 0x0ea3,
-	0x0ea5, 0x0ea5,
-	0x0ea7, 0x0ea7,
-	0x0eaa, 0x0eab,
-	0x0ead, 0x0eb9,
-	0x0ebb, 0x0ebd,
-	0x0ec0, 0x0ec4,
-	0x0ec6, 0x0ec6,
-	0x0ec8, 0x0ecd,
-	0x0ed0, 0x0ed9,
-	0x0edc, 0x0edd,
-	0x0f00, 0x0f00,
-	0x0f18, 0x0f19,
-	0x0f20, 0x0f29,
-	0x0f35, 0x0f35,
-	0x0f37, 0x0f37,
-	0x0f39, 0x0f39,
-	0x0f3e, 0x0f47,
-	0x0f49, 0x0f6c,
-	0x0f71, 0x0f84,
-	0x0f86, 0x0f8b,
-	0x0f90, 0x0f97,
-	0x0f99, 0x0fbc,
-	0x0fc6, 0x0fc6,
-	0x1000, 0x1049,
-	0x1050, 0x109d,
-	0x10a0, 0x10c5,
-	0x10d0, 0x10fa,
-	0x10fc, 0x10fc,
-	0x1100, 0x1248,
-	0x124a, 0x124d,
-	0x1250, 0x1256,
-	0x1258, 0x1258,
-	0x125a, 0x125d,
-	0x1260, 0x1288,
-	0x128a, 0x128d,
-	0x1290, 0x12b0,
-	0x12b2, 0x12b5,
-	0x12b8, 0x12be,
-	0x12c0, 0x12c0,
-	0x12c2, 0x12c5,
-	0x12c8, 0x12d6,
-	0x12d8, 0x1310,
-	0x1312, 0x1315,
-	0x1318, 0x135a,
-	0x135f, 0x135f,
-	0x1380, 0x138f,
-	0x13a0, 0x13f4,
-	0x1401, 0x166c,
-	0x166f, 0x167f,
-	0x1681, 0x169a,
-	0x16a0, 0x16ea,
-	0x16ee, 0x16f0,
-	0x1700, 0x170c,
-	0x170e, 0x1714,
-	0x1720, 0x1734,
-	0x1740, 0x1753,
-	0x1760, 0x176c,
-	0x176e, 0x1770,
-	0x1772, 0x1773,
-	0x1780, 0x17b3,
-	0x17b6, 0x17d3,
-	0x17d7, 0x17d7,
-	0x17dc, 0x17dd,
-	0x17e0, 0x17e9,
-	0x180b, 0x180d,
-	0x1810, 0x1819,
-	0x1820, 0x1877,
-	0x1880, 0x18aa,
-	0x18b0, 0x18f5,
-	0x1900, 0x191c,
-	0x1920, 0x192b,
-	0x1930, 0x193b,
-	0x1946, 0x196d,
-	0x1970, 0x1974,
-	0x1980, 0x19ab,
-	0x19b0, 0x19c9,
-	0x19d0, 0x19da,
-	0x1a00, 0x1a1b,
-	0x1a20, 0x1a5e,
-	0x1a60, 0x1a7c,
-	0x1a7f, 0x1a89,
-	0x1a90, 0x1a99,
-	0x1aa7, 0x1aa7,
-	0x1b00, 0x1b4b,
-	0x1b50, 0x1b59,
-	0x1b6b, 0x1b73,
-	0x1b80, 0x1baa,
-	0x1bae, 0x1bb9,
-	0x1c00, 0x1c37,
-	0x1c40, 0x1c49,
-	0x1c4d, 0x1c7d,
-	0x1cd0, 0x1cd2,
-	0x1cd4, 0x1cf2,
-	0x1d00, 0x1de6,
-	0x1dfd, 0x1f15,
-	0x1f18, 0x1f1d,
-	0x1f20, 0x1f45,
-	0x1f48, 0x1f4d,
-	0x1f50, 0x1f57,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f7d,
-	0x1f80, 0x1fb4,
-	0x1fb6, 0x1fbc,
-	0x1fbe, 0x1fbe,
-	0x1fc2, 0x1fc4,
-	0x1fc6, 0x1fcc,
-	0x1fd0, 0x1fd3,
-	0x1fd6, 0x1fdb,
-	0x1fe0, 0x1fec,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ffc,
-	0x203f, 0x2040,
-	0x2054, 0x2054,
-	0x2071, 0x2071,
-	0x207f, 0x207f,
-	0x2090, 0x2094,
-	0x20d0, 0x20f0,
-	0x2102, 0x2102,
-	0x2107, 0x2107,
-	0x210a, 0x2113,
-	0x2115, 0x2115,
-	0x2119, 0x211d,
-	0x2124, 0x2124,
-	0x2126, 0x2126,
-	0x2128, 0x2128,
-	0x212a, 0x212d,
-	0x212f, 0x2139,
-	0x213c, 0x213f,
-	0x2145, 0x2149,
-	0x214e, 0x214e,
-	0x2160, 0x2188,
-	0x24b6, 0x24e9,
-	0x2c00, 0x2c2e,
-	0x2c30, 0x2c5e,
-	0x2c60, 0x2ce4,
-	0x2ceb, 0x2cf1,
-	0x2d00, 0x2d25,
-	0x2d30, 0x2d65,
-	0x2d6f, 0x2d6f,
-	0x2d80, 0x2d96,
-	0x2da0, 0x2da6,
-	0x2da8, 0x2dae,
-	0x2db0, 0x2db6,
-	0x2db8, 0x2dbe,
-	0x2dc0, 0x2dc6,
-	0x2dc8, 0x2dce,
-	0x2dd0, 0x2dd6,
-	0x2dd8, 0x2dde,
-	0x2de0, 0x2dff,
-	0x2e2f, 0x2e2f,
-	0x3005, 0x3007,
-	0x3021, 0x302f,
-	0x3031, 0x3035,
-	0x3038, 0x303c,
-	0x3041, 0x3096,
-	0x3099, 0x309a,
-	0x309d, 0x309f,
-	0x30a1, 0x30fa,
-	0x30fc, 0x30ff,
-	0x3105, 0x312d,
-	0x3131, 0x318e,
-	0x31a0, 0x31b7,
-	0x31f0, 0x31ff,
-	0x3400, 0x4db5,
-	0x4e00, 0x9fcb,
-	0xa000, 0xa48c,
-	0xa4d0, 0xa4fd,
-	0xa500, 0xa60c,
-	0xa610, 0xa62b,
-	0xa640, 0xa65f,
-	0xa662, 0xa672,
-	0xa67c, 0xa67d,
-	0xa67f, 0xa697,
-	0xa6a0, 0xa6f1,
-	0xa717, 0xa71f,
-	0xa722, 0xa788,
-	0xa78b, 0xa78c,
-	0xa7fb, 0xa827,
-	0xa840, 0xa873,
-	0xa880, 0xa8c4,
-	0xa8d0, 0xa8d9,
-	0xa8e0, 0xa8f7,
-	0xa8fb, 0xa8fb,
-	0xa900, 0xa92d,
-	0xa930, 0xa953,
-	0xa960, 0xa97c,
-	0xa980, 0xa9c0,
-	0xa9cf, 0xa9d9,
-	0xaa00, 0xaa36,
-	0xaa40, 0xaa4d,
-	0xaa50, 0xaa59,
-	0xaa60, 0xaa76,
-	0xaa7a, 0xaa7b,
-	0xaa80, 0xaac2,
-	0xaadb, 0xaadd,
-	0xabc0, 0xabea,
-	0xabec, 0xabed,
-	0xabf0, 0xabf9,
-	0xac00, 0xd7a3,
-	0xd7b0, 0xd7c6,
-	0xd7cb, 0xd7fb,
-	0xf900, 0xfa2d,
-	0xfa30, 0xfa6d,
-	0xfa70, 0xfad9,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xfb1d, 0xfb28,
-	0xfb2a, 0xfb36,
-	0xfb38, 0xfb3c,
-	0xfb3e, 0xfb3e,
-	0xfb40, 0xfb41,
-	0xfb43, 0xfb44,
-	0xfb46, 0xfbb1,
-	0xfbd3, 0xfd3d,
-	0xfd50, 0xfd8f,
-	0xfd92, 0xfdc7,
-	0xfdf0, 0xfdfb,
-	0xfe00, 0xfe0f,
-	0xfe20, 0xfe26,
-	0xfe33, 0xfe34,
-	0xfe4d, 0xfe4f,
-	0xfe70, 0xfe74,
-	0xfe76, 0xfefc,
-	0xff10, 0xff19,
-	0xff21, 0xff3a,
-	0xff3f, 0xff3f,
-	0xff41, 0xff5a,
-	0xff66, 0xffbe,
-	0xffc2, 0xffc7,
-	0xffca, 0xffcf,
-	0xffd2, 0xffd7,
-	0xffda, 0xffdc,
-	0x10000, 0x1000b,
-	0x1000d, 0x10026,
-	0x10028, 0x1003a,
-	0x1003c, 0x1003d,
-	0x1003f, 0x1004d,
-	0x10050, 0x1005d,
-	0x10080, 0x100fa,
-	0x10140, 0x10174,
-	0x101fd, 0x101fd,
-	0x10280, 0x1029c,
-	0x102a0, 0x102d0,
-	0x10300, 0x1031e,
-	0x10330, 0x1034a,
-	0x10380, 0x1039d,
-	0x103a0, 0x103c3,
-	0x103c8, 0x103cf,
-	0x103d1, 0x103d5,
-	0x10400, 0x1049d,
-	0x104a0, 0x104a9,
-	0x10800, 0x10805,
-	0x10808, 0x10808,
-	0x1080a, 0x10835,
-	0x10837, 0x10838,
-	0x1083c, 0x1083c,
-	0x1083f, 0x10855,
-	0x10900, 0x10915,
-	0x10920, 0x10939,
-	0x10a00, 0x10a03,
-	0x10a05, 0x10a06,
-	0x10a0c, 0x10a13,
-	0x10a15, 0x10a17,
-	0x10a19, 0x10a33,
-	0x10a38, 0x10a3a,
-	0x10a3f, 0x10a3f,
-	0x10a60, 0x10a7c,
-	0x10b00, 0x10b35,
-	0x10b40, 0x10b55,
-	0x10b60, 0x10b72,
-	0x10c00, 0x10c48,
-	0x11080, 0x110ba,
-	0x12000, 0x1236e,
-	0x12400, 0x12462,
-	0x13000, 0x1342e,
-	0x1d165, 0x1d169,
-	0x1d16d, 0x1d172,
-	0x1d17b, 0x1d182,
-	0x1d185, 0x1d18b,
-	0x1d1aa, 0x1d1ad,
-	0x1d242, 0x1d244,
-	0x1d400, 0x1d454,
-	0x1d456, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d51e, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d552, 0x1d6a5,
-	0x1d6a8, 0x1d6c0,
-	0x1d6c2, 0x1d6da,
-	0x1d6dc, 0x1d6fa,
-	0x1d6fc, 0x1d714,
-	0x1d716, 0x1d734,
-	0x1d736, 0x1d74e,
-	0x1d750, 0x1d76e,
-	0x1d770, 0x1d788,
-	0x1d78a, 0x1d7a8,
-	0x1d7aa, 0x1d7c2,
-	0x1d7c4, 0x1d7cb,
-	0x1d7ce, 0x1d7ff,
-	0x20000, 0x2a6d6,
-	0x2a700, 0x2b734,
-	0x2f800, 0x2fa1d,
-	0xe0100, 0xe01ef,
+        506,
+        0x0030, 0x0039,
+        0x0041, 0x005a,
+        0x005f, 0x005f,
+        0x0061, 0x007a,
+        0x00aa, 0x00aa,
+        0x00b5, 0x00b5,
+        0x00ba, 0x00ba,
+        0x00c0, 0x00d6,
+        0x00d8, 0x00f6,
+        0x00f8, 0x02c1,
+        0x02c6, 0x02d1,
+        0x02e0, 0x02e4,
+        0x02ec, 0x02ec,
+        0x02ee, 0x02ee,
+        0x0300, 0x0374,
+        0x0376, 0x0377,
+        0x037a, 0x037d,
+        0x0386, 0x0386,
+        0x0388, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x03a1,
+        0x03a3, 0x03f5,
+        0x03f7, 0x0481,
+        0x0483, 0x0525,
+        0x0531, 0x0556,
+        0x0559, 0x0559,
+        0x0561, 0x0587,
+        0x0591, 0x05bd,
+        0x05bf, 0x05bf,
+        0x05c1, 0x05c2,
+        0x05c4, 0x05c5,
+        0x05c7, 0x05c7,
+        0x05d0, 0x05ea,
+        0x05f0, 0x05f2,
+        0x0610, 0x061a,
+        0x0621, 0x065e,
+        0x0660, 0x0669,
+        0x066e, 0x06d3,
+        0x06d5, 0x06dc,
+        0x06de, 0x06e8,
+        0x06ea, 0x06fc,
+        0x06ff, 0x06ff,
+        0x0710, 0x074a,
+        0x074d, 0x07b1,
+        0x07c0, 0x07f5,
+        0x07fa, 0x07fa,
+        0x0800, 0x082d,
+        0x0900, 0x0939,
+        0x093c, 0x094e,
+        0x0950, 0x0955,
+        0x0958, 0x0963,
+        0x0966, 0x096f,
+        0x0971, 0x0972,
+        0x0979, 0x097f,
+        0x0981, 0x0983,
+        0x0985, 0x098c,
+        0x098f, 0x0990,
+        0x0993, 0x09a8,
+        0x09aa, 0x09b0,
+        0x09b2, 0x09b2,
+        0x09b6, 0x09b9,
+        0x09bc, 0x09c4,
+        0x09c7, 0x09c8,
+        0x09cb, 0x09ce,
+        0x09d7, 0x09d7,
+        0x09dc, 0x09dd,
+        0x09df, 0x09e3,
+        0x09e6, 0x09f1,
+        0x0a01, 0x0a03,
+        0x0a05, 0x0a0a,
+        0x0a0f, 0x0a10,
+        0x0a13, 0x0a28,
+        0x0a2a, 0x0a30,
+        0x0a32, 0x0a33,
+        0x0a35, 0x0a36,
+        0x0a38, 0x0a39,
+        0x0a3c, 0x0a3c,
+        0x0a3e, 0x0a42,
+        0x0a47, 0x0a48,
+        0x0a4b, 0x0a4d,
+        0x0a51, 0x0a51,
+        0x0a59, 0x0a5c,
+        0x0a5e, 0x0a5e,
+        0x0a66, 0x0a75,
+        0x0a81, 0x0a83,
+        0x0a85, 0x0a8d,
+        0x0a8f, 0x0a91,
+        0x0a93, 0x0aa8,
+        0x0aaa, 0x0ab0,
+        0x0ab2, 0x0ab3,
+        0x0ab5, 0x0ab9,
+        0x0abc, 0x0ac5,
+        0x0ac7, 0x0ac9,
+        0x0acb, 0x0acd,
+        0x0ad0, 0x0ad0,
+        0x0ae0, 0x0ae3,
+        0x0ae6, 0x0aef,
+        0x0b01, 0x0b03,
+        0x0b05, 0x0b0c,
+        0x0b0f, 0x0b10,
+        0x0b13, 0x0b28,
+        0x0b2a, 0x0b30,
+        0x0b32, 0x0b33,
+        0x0b35, 0x0b39,
+        0x0b3c, 0x0b44,
+        0x0b47, 0x0b48,
+        0x0b4b, 0x0b4d,
+        0x0b56, 0x0b57,
+        0x0b5c, 0x0b5d,
+        0x0b5f, 0x0b63,
+        0x0b66, 0x0b6f,
+        0x0b71, 0x0b71,
+        0x0b82, 0x0b83,
+        0x0b85, 0x0b8a,
+        0x0b8e, 0x0b90,
+        0x0b92, 0x0b95,
+        0x0b99, 0x0b9a,
+        0x0b9c, 0x0b9c,
+        0x0b9e, 0x0b9f,
+        0x0ba3, 0x0ba4,
+        0x0ba8, 0x0baa,
+        0x0bae, 0x0bb9,
+        0x0bbe, 0x0bc2,
+        0x0bc6, 0x0bc8,
+        0x0bca, 0x0bcd,
+        0x0bd0, 0x0bd0,
+        0x0bd7, 0x0bd7,
+        0x0be6, 0x0bef,
+        0x0c01, 0x0c03,
+        0x0c05, 0x0c0c,
+        0x0c0e, 0x0c10,
+        0x0c12, 0x0c28,
+        0x0c2a, 0x0c33,
+        0x0c35, 0x0c39,
+        0x0c3d, 0x0c44,
+        0x0c46, 0x0c48,
+        0x0c4a, 0x0c4d,
+        0x0c55, 0x0c56,
+        0x0c58, 0x0c59,
+        0x0c60, 0x0c63,
+        0x0c66, 0x0c6f,
+        0x0c82, 0x0c83,
+        0x0c85, 0x0c8c,
+        0x0c8e, 0x0c90,
+        0x0c92, 0x0ca8,
+        0x0caa, 0x0cb3,
+        0x0cb5, 0x0cb9,
+        0x0cbc, 0x0cc4,
+        0x0cc6, 0x0cc8,
+        0x0cca, 0x0ccd,
+        0x0cd5, 0x0cd6,
+        0x0cde, 0x0cde,
+        0x0ce0, 0x0ce3,
+        0x0ce6, 0x0cef,
+        0x0d02, 0x0d03,
+        0x0d05, 0x0d0c,
+        0x0d0e, 0x0d10,
+        0x0d12, 0x0d28,
+        0x0d2a, 0x0d39,
+        0x0d3d, 0x0d44,
+        0x0d46, 0x0d48,
+        0x0d4a, 0x0d4d,
+        0x0d57, 0x0d57,
+        0x0d60, 0x0d63,
+        0x0d66, 0x0d6f,
+        0x0d7a, 0x0d7f,
+        0x0d82, 0x0d83,
+        0x0d85, 0x0d96,
+        0x0d9a, 0x0db1,
+        0x0db3, 0x0dbb,
+        0x0dbd, 0x0dbd,
+        0x0dc0, 0x0dc6,
+        0x0dca, 0x0dca,
+        0x0dcf, 0x0dd4,
+        0x0dd6, 0x0dd6,
+        0x0dd8, 0x0ddf,
+        0x0df2, 0x0df3,
+        0x0e01, 0x0e3a,
+        0x0e40, 0x0e4e,
+        0x0e50, 0x0e59,
+        0x0e81, 0x0e82,
+        0x0e84, 0x0e84,
+        0x0e87, 0x0e88,
+        0x0e8a, 0x0e8a,
+        0x0e8d, 0x0e8d,
+        0x0e94, 0x0e97,
+        0x0e99, 0x0e9f,
+        0x0ea1, 0x0ea3,
+        0x0ea5, 0x0ea5,
+        0x0ea7, 0x0ea7,
+        0x0eaa, 0x0eab,
+        0x0ead, 0x0eb9,
+        0x0ebb, 0x0ebd,
+        0x0ec0, 0x0ec4,
+        0x0ec6, 0x0ec6,
+        0x0ec8, 0x0ecd,
+        0x0ed0, 0x0ed9,
+        0x0edc, 0x0edd,
+        0x0f00, 0x0f00,
+        0x0f18, 0x0f19,
+        0x0f20, 0x0f29,
+        0x0f35, 0x0f35,
+        0x0f37, 0x0f37,
+        0x0f39, 0x0f39,
+        0x0f3e, 0x0f47,
+        0x0f49, 0x0f6c,
+        0x0f71, 0x0f84,
+        0x0f86, 0x0f8b,
+        0x0f90, 0x0f97,
+        0x0f99, 0x0fbc,
+        0x0fc6, 0x0fc6,
+        0x1000, 0x1049,
+        0x1050, 0x109d,
+        0x10a0, 0x10c5,
+        0x10d0, 0x10fa,
+        0x10fc, 0x10fc,
+        0x1100, 0x1248,
+        0x124a, 0x124d,
+        0x1250, 0x1256,
+        0x1258, 0x1258,
+        0x125a, 0x125d,
+        0x1260, 0x1288,
+        0x128a, 0x128d,
+        0x1290, 0x12b0,
+        0x12b2, 0x12b5,
+        0x12b8, 0x12be,
+        0x12c0, 0x12c0,
+        0x12c2, 0x12c5,
+        0x12c8, 0x12d6,
+        0x12d8, 0x1310,
+        0x1312, 0x1315,
+        0x1318, 0x135a,
+        0x135f, 0x135f,
+        0x1380, 0x138f,
+        0x13a0, 0x13f4,
+        0x1401, 0x166c,
+        0x166f, 0x167f,
+        0x1681, 0x169a,
+        0x16a0, 0x16ea,
+        0x16ee, 0x16f0,
+        0x1700, 0x170c,
+        0x170e, 0x1714,
+        0x1720, 0x1734,
+        0x1740, 0x1753,
+        0x1760, 0x176c,
+        0x176e, 0x1770,
+        0x1772, 0x1773,
+        0x1780, 0x17b3,
+        0x17b6, 0x17d3,
+        0x17d7, 0x17d7,
+        0x17dc, 0x17dd,
+        0x17e0, 0x17e9,
+        0x180b, 0x180d,
+        0x1810, 0x1819,
+        0x1820, 0x1877,
+        0x1880, 0x18aa,
+        0x18b0, 0x18f5,
+        0x1900, 0x191c,
+        0x1920, 0x192b,
+        0x1930, 0x193b,
+        0x1946, 0x196d,
+        0x1970, 0x1974,
+        0x1980, 0x19ab,
+        0x19b0, 0x19c9,
+        0x19d0, 0x19da,
+        0x1a00, 0x1a1b,
+        0x1a20, 0x1a5e,
+        0x1a60, 0x1a7c,
+        0x1a7f, 0x1a89,
+        0x1a90, 0x1a99,
+        0x1aa7, 0x1aa7,
+        0x1b00, 0x1b4b,
+        0x1b50, 0x1b59,
+        0x1b6b, 0x1b73,
+        0x1b80, 0x1baa,
+        0x1bae, 0x1bb9,
+        0x1c00, 0x1c37,
+        0x1c40, 0x1c49,
+        0x1c4d, 0x1c7d,
+        0x1cd0, 0x1cd2,
+        0x1cd4, 0x1cf2,
+        0x1d00, 0x1de6,
+        0x1dfd, 0x1f15,
+        0x1f18, 0x1f1d,
+        0x1f20, 0x1f45,
+        0x1f48, 0x1f4d,
+        0x1f50, 0x1f57,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f7d,
+        0x1f80, 0x1fb4,
+        0x1fb6, 0x1fbc,
+        0x1fbe, 0x1fbe,
+        0x1fc2, 0x1fc4,
+        0x1fc6, 0x1fcc,
+        0x1fd0, 0x1fd3,
+        0x1fd6, 0x1fdb,
+        0x1fe0, 0x1fec,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ffc,
+        0x203f, 0x2040,
+        0x2054, 0x2054,
+        0x2071, 0x2071,
+        0x207f, 0x207f,
+        0x2090, 0x2094,
+        0x20d0, 0x20f0,
+        0x2102, 0x2102,
+        0x2107, 0x2107,
+        0x210a, 0x2113,
+        0x2115, 0x2115,
+        0x2119, 0x211d,
+        0x2124, 0x2124,
+        0x2126, 0x2126,
+        0x2128, 0x2128,
+        0x212a, 0x212d,
+        0x212f, 0x2139,
+        0x213c, 0x213f,
+        0x2145, 0x2149,
+        0x214e, 0x214e,
+        0x2160, 0x2188,
+        0x24b6, 0x24e9,
+        0x2c00, 0x2c2e,
+        0x2c30, 0x2c5e,
+        0x2c60, 0x2ce4,
+        0x2ceb, 0x2cf1,
+        0x2d00, 0x2d25,
+        0x2d30, 0x2d65,
+        0x2d6f, 0x2d6f,
+        0x2d80, 0x2d96,
+        0x2da0, 0x2da6,
+        0x2da8, 0x2dae,
+        0x2db0, 0x2db6,
+        0x2db8, 0x2dbe,
+        0x2dc0, 0x2dc6,
+        0x2dc8, 0x2dce,
+        0x2dd0, 0x2dd6,
+        0x2dd8, 0x2dde,
+        0x2de0, 0x2dff,
+        0x2e2f, 0x2e2f,
+        0x3005, 0x3007,
+        0x3021, 0x302f,
+        0x3031, 0x3035,
+        0x3038, 0x303c,
+        0x3041, 0x3096,
+        0x3099, 0x309a,
+        0x309d, 0x309f,
+        0x30a1, 0x30fa,
+        0x30fc, 0x30ff,
+        0x3105, 0x312d,
+        0x3131, 0x318e,
+        0x31a0, 0x31b7,
+        0x31f0, 0x31ff,
+        0x3400, 0x4db5,
+        0x4e00, 0x9fcb,
+        0xa000, 0xa48c,
+        0xa4d0, 0xa4fd,
+        0xa500, 0xa60c,
+        0xa610, 0xa62b,
+        0xa640, 0xa65f,
+        0xa662, 0xa672,
+        0xa67c, 0xa67d,
+        0xa67f, 0xa697,
+        0xa6a0, 0xa6f1,
+        0xa717, 0xa71f,
+        0xa722, 0xa788,
+        0xa78b, 0xa78c,
+        0xa7fb, 0xa827,
+        0xa840, 0xa873,
+        0xa880, 0xa8c4,
+        0xa8d0, 0xa8d9,
+        0xa8e0, 0xa8f7,
+        0xa8fb, 0xa8fb,
+        0xa900, 0xa92d,
+        0xa930, 0xa953,
+        0xa960, 0xa97c,
+        0xa980, 0xa9c0,
+        0xa9cf, 0xa9d9,
+        0xaa00, 0xaa36,
+        0xaa40, 0xaa4d,
+        0xaa50, 0xaa59,
+        0xaa60, 0xaa76,
+        0xaa7a, 0xaa7b,
+        0xaa80, 0xaac2,
+        0xaadb, 0xaadd,
+        0xabc0, 0xabea,
+        0xabec, 0xabed,
+        0xabf0, 0xabf9,
+        0xac00, 0xd7a3,
+        0xd7b0, 0xd7c6,
+        0xd7cb, 0xd7fb,
+        0xf900, 0xfa2d,
+        0xfa30, 0xfa6d,
+        0xfa70, 0xfad9,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xfb1d, 0xfb28,
+        0xfb2a, 0xfb36,
+        0xfb38, 0xfb3c,
+        0xfb3e, 0xfb3e,
+        0xfb40, 0xfb41,
+        0xfb43, 0xfb44,
+        0xfb46, 0xfbb1,
+        0xfbd3, 0xfd3d,
+        0xfd50, 0xfd8f,
+        0xfd92, 0xfdc7,
+        0xfdf0, 0xfdfb,
+        0xfe00, 0xfe0f,
+        0xfe20, 0xfe26,
+        0xfe33, 0xfe34,
+        0xfe4d, 0xfe4f,
+        0xfe70, 0xfe74,
+        0xfe76, 0xfefc,
+        0xff10, 0xff19,
+        0xff21, 0xff3a,
+        0xff3f, 0xff3f,
+        0xff41, 0xff5a,
+        0xff66, 0xffbe,
+        0xffc2, 0xffc7,
+        0xffca, 0xffcf,
+        0xffd2, 0xffd7,
+        0xffda, 0xffdc,
+        0x10000, 0x1000b,
+        0x1000d, 0x10026,
+        0x10028, 0x1003a,
+        0x1003c, 0x1003d,
+        0x1003f, 0x1004d,
+        0x10050, 0x1005d,
+        0x10080, 0x100fa,
+        0x10140, 0x10174,
+        0x101fd, 0x101fd,
+        0x10280, 0x1029c,
+        0x102a0, 0x102d0,
+        0x10300, 0x1031e,
+        0x10330, 0x1034a,
+        0x10380, 0x1039d,
+        0x103a0, 0x103c3,
+        0x103c8, 0x103cf,
+        0x103d1, 0x103d5,
+        0x10400, 0x1049d,
+        0x104a0, 0x104a9,
+        0x10800, 0x10805,
+        0x10808, 0x10808,
+        0x1080a, 0x10835,
+        0x10837, 0x10838,
+        0x1083c, 0x1083c,
+        0x1083f, 0x10855,
+        0x10900, 0x10915,
+        0x10920, 0x10939,
+        0x10a00, 0x10a03,
+        0x10a05, 0x10a06,
+        0x10a0c, 0x10a13,
+        0x10a15, 0x10a17,
+        0x10a19, 0x10a33,
+        0x10a38, 0x10a3a,
+        0x10a3f, 0x10a3f,
+        0x10a60, 0x10a7c,
+        0x10b00, 0x10b35,
+        0x10b40, 0x10b55,
+        0x10b60, 0x10b72,
+        0x10c00, 0x10c48,
+        0x11080, 0x110ba,
+        0x12000, 0x1236e,
+        0x12400, 0x12462,
+        0x13000, 0x1342e,
+        0x1d165, 0x1d169,
+        0x1d16d, 0x1d172,
+        0x1d17b, 0x1d182,
+        0x1d185, 0x1d18b,
+        0x1d1aa, 0x1d1ad,
+        0x1d242, 0x1d244,
+        0x1d400, 0x1d454,
+        0x1d456, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d51e, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d552, 0x1d6a5,
+        0x1d6a8, 0x1d6c0,
+        0x1d6c2, 0x1d6da,
+        0x1d6dc, 0x1d6fa,
+        0x1d6fc, 0x1d714,
+        0x1d716, 0x1d734,
+        0x1d736, 0x1d74e,
+        0x1d750, 0x1d76e,
+        0x1d770, 0x1d788,
+        0x1d78a, 0x1d7a8,
+        0x1d7aa, 0x1d7c2,
+        0x1d7c4, 0x1d7cb,
+        0x1d7ce, 0x1d7ff,
+        0x20000, 0x2a6d6,
+        0x2a700, 0x2b734,
+        0x2f800, 0x2fa1d,
+        0xe0100, 0xe01ef,
 }; /* CR_Word */
 
 /* 'Alnum': [[:Alnum:]] */
 static const OnigCodePoint CR_Alnum[] = {
-	497,
-	0x0030, 0x0039,
-	0x0041, 0x005a,
-	0x0061, 0x007a,
-	0x00aa, 0x00aa,
-	0x00b5, 0x00b5,
-	0x00ba, 0x00ba,
-	0x00c0, 0x00d6,
-	0x00d8, 0x00f6,
-	0x00f8, 0x02c1,
-	0x02c6, 0x02d1,
-	0x02e0, 0x02e4,
-	0x02ec, 0x02ec,
-	0x02ee, 0x02ee,
-	0x0345, 0x0345,
-	0x0370, 0x0374,
-	0x0376, 0x0377,
-	0x037a, 0x037d,
-	0x0386, 0x0386,
-	0x0388, 0x038a,
-	0x038c, 0x038c,
-	0x038e, 0x03a1,
-	0x03a3, 0x03f5,
-	0x03f7, 0x0481,
-	0x048a, 0x0525,
-	0x0531, 0x0556,
-	0x0559, 0x0559,
-	0x0561, 0x0587,
-	0x05b0, 0x05bd,
-	0x05bf, 0x05bf,
-	0x05c1, 0x05c2,
-	0x05c4, 0x05c5,
-	0x05c7, 0x05c7,
-	0x05d0, 0x05ea,
-	0x05f0, 0x05f2,
-	0x0610, 0x061a,
-	0x0621, 0x0657,
-	0x0659, 0x065e,
-	0x0660, 0x0669,
-	0x066e, 0x06d3,
-	0x06d5, 0x06dc,
-	0x06e1, 0x06e8,
-	0x06ed, 0x06fc,
-	0x06ff, 0x06ff,
-	0x0710, 0x073f,
-	0x074d, 0x07b1,
-	0x07c0, 0x07ea,
-	0x07f4, 0x07f5,
-	0x07fa, 0x07fa,
-	0x0800, 0x0817,
-	0x081a, 0x082c,
-	0x0900, 0x0939,
-	0x093d, 0x094c,
-	0x094e, 0x094e,
-	0x0950, 0x0950,
-	0x0955, 0x0955,
-	0x0958, 0x0963,
-	0x0966, 0x096f,
-	0x0971, 0x0972,
-	0x0979, 0x097f,
-	0x0981, 0x0983,
-	0x0985, 0x098c,
-	0x098f, 0x0990,
-	0x0993, 0x09a8,
-	0x09aa, 0x09b0,
-	0x09b2, 0x09b2,
-	0x09b6, 0x09b9,
-	0x09bd, 0x09c4,
-	0x09c7, 0x09c8,
-	0x09cb, 0x09cc,
-	0x09ce, 0x09ce,
-	0x09d7, 0x09d7,
-	0x09dc, 0x09dd,
-	0x09df, 0x09e3,
-	0x09e6, 0x09f1,
-	0x0a01, 0x0a03,
-	0x0a05, 0x0a0a,
-	0x0a0f, 0x0a10,
-	0x0a13, 0x0a28,
-	0x0a2a, 0x0a30,
-	0x0a32, 0x0a33,
-	0x0a35, 0x0a36,
-	0x0a38, 0x0a39,
-	0x0a3e, 0x0a42,
-	0x0a47, 0x0a48,
-	0x0a4b, 0x0a4c,
-	0x0a51, 0x0a51,
-	0x0a59, 0x0a5c,
-	0x0a5e, 0x0a5e,
-	0x0a66, 0x0a75,
-	0x0a81, 0x0a83,
-	0x0a85, 0x0a8d,
-	0x0a8f, 0x0a91,
-	0x0a93, 0x0aa8,
-	0x0aaa, 0x0ab0,
-	0x0ab2, 0x0ab3,
-	0x0ab5, 0x0ab9,
-	0x0abd, 0x0ac5,
-	0x0ac7, 0x0ac9,
-	0x0acb, 0x0acc,
-	0x0ad0, 0x0ad0,
-	0x0ae0, 0x0ae3,
-	0x0ae6, 0x0aef,
-	0x0b01, 0x0b03,
-	0x0b05, 0x0b0c,
-	0x0b0f, 0x0b10,
-	0x0b13, 0x0b28,
-	0x0b2a, 0x0b30,
-	0x0b32, 0x0b33,
-	0x0b35, 0x0b39,
-	0x0b3d, 0x0b44,
-	0x0b47, 0x0b48,
-	0x0b4b, 0x0b4c,
-	0x0b56, 0x0b57,
-	0x0b5c, 0x0b5d,
-	0x0b5f, 0x0b63,
-	0x0b66, 0x0b6f,
-	0x0b71, 0x0b71,
-	0x0b82, 0x0b83,
-	0x0b85, 0x0b8a,
-	0x0b8e, 0x0b90,
-	0x0b92, 0x0b95,
-	0x0b99, 0x0b9a,
-	0x0b9c, 0x0b9c,
-	0x0b9e, 0x0b9f,
-	0x0ba3, 0x0ba4,
-	0x0ba8, 0x0baa,
-	0x0bae, 0x0bb9,
-	0x0bbe, 0x0bc2,
-	0x0bc6, 0x0bc8,
-	0x0bca, 0x0bcc,
-	0x0bd0, 0x0bd0,
-	0x0bd7, 0x0bd7,
-	0x0be6, 0x0bef,
-	0x0c01, 0x0c03,
-	0x0c05, 0x0c0c,
-	0x0c0e, 0x0c10,
-	0x0c12, 0x0c28,
-	0x0c2a, 0x0c33,
-	0x0c35, 0x0c39,
-	0x0c3d, 0x0c44,
-	0x0c46, 0x0c48,
-	0x0c4a, 0x0c4c,
-	0x0c55, 0x0c56,
-	0x0c58, 0x0c59,
-	0x0c60, 0x0c63,
-	0x0c66, 0x0c6f,
-	0x0c82, 0x0c83,
-	0x0c85, 0x0c8c,
-	0x0c8e, 0x0c90,
-	0x0c92, 0x0ca8,
-	0x0caa, 0x0cb3,
-	0x0cb5, 0x0cb9,
-	0x0cbd, 0x0cc4,
-	0x0cc6, 0x0cc8,
-	0x0cca, 0x0ccc,
-	0x0cd5, 0x0cd6,
-	0x0cde, 0x0cde,
-	0x0ce0, 0x0ce3,
-	0x0ce6, 0x0cef,
-	0x0d02, 0x0d03,
-	0x0d05, 0x0d0c,
-	0x0d0e, 0x0d10,
-	0x0d12, 0x0d28,
-	0x0d2a, 0x0d39,
-	0x0d3d, 0x0d44,
-	0x0d46, 0x0d48,
-	0x0d4a, 0x0d4c,
-	0x0d57, 0x0d57,
-	0x0d60, 0x0d63,
-	0x0d66, 0x0d6f,
-	0x0d7a, 0x0d7f,
-	0x0d82, 0x0d83,
-	0x0d85, 0x0d96,
-	0x0d9a, 0x0db1,
-	0x0db3, 0x0dbb,
-	0x0dbd, 0x0dbd,
-	0x0dc0, 0x0dc6,
-	0x0dcf, 0x0dd4,
-	0x0dd6, 0x0dd6,
-	0x0dd8, 0x0ddf,
-	0x0df2, 0x0df3,
-	0x0e01, 0x0e3a,
-	0x0e40, 0x0e46,
-	0x0e4d, 0x0e4d,
-	0x0e50, 0x0e59,
-	0x0e81, 0x0e82,
-	0x0e84, 0x0e84,
-	0x0e87, 0x0e88,
-	0x0e8a, 0x0e8a,
-	0x0e8d, 0x0e8d,
-	0x0e94, 0x0e97,
-	0x0e99, 0x0e9f,
-	0x0ea1, 0x0ea3,
-	0x0ea5, 0x0ea5,
-	0x0ea7, 0x0ea7,
-	0x0eaa, 0x0eab,
-	0x0ead, 0x0eb9,
-	0x0ebb, 0x0ebd,
-	0x0ec0, 0x0ec4,
-	0x0ec6, 0x0ec6,
-	0x0ecd, 0x0ecd,
-	0x0ed0, 0x0ed9,
-	0x0edc, 0x0edd,
-	0x0f00, 0x0f00,
-	0x0f20, 0x0f29,
-	0x0f40, 0x0f47,
-	0x0f49, 0x0f6c,
-	0x0f71, 0x0f81,
-	0x0f88, 0x0f8b,
-	0x0f90, 0x0f97,
-	0x0f99, 0x0fbc,
-	0x1000, 0x1036,
-	0x1038, 0x1038,
-	0x103b, 0x1049,
-	0x1050, 0x1062,
-	0x1065, 0x1068,
-	0x106e, 0x1086,
-	0x108e, 0x108e,
-	0x1090, 0x1099,
-	0x109c, 0x109d,
-	0x10a0, 0x10c5,
-	0x10d0, 0x10fa,
-	0x10fc, 0x10fc,
-	0x1100, 0x1248,
-	0x124a, 0x124d,
-	0x1250, 0x1256,
-	0x1258, 0x1258,
-	0x125a, 0x125d,
-	0x1260, 0x1288,
-	0x128a, 0x128d,
-	0x1290, 0x12b0,
-	0x12b2, 0x12b5,
-	0x12b8, 0x12be,
-	0x12c0, 0x12c0,
-	0x12c2, 0x12c5,
-	0x12c8, 0x12d6,
-	0x12d8, 0x1310,
-	0x1312, 0x1315,
-	0x1318, 0x135a,
-	0x135f, 0x135f,
-	0x1380, 0x138f,
-	0x13a0, 0x13f4,
-	0x1401, 0x166c,
-	0x166f, 0x167f,
-	0x1681, 0x169a,
-	0x16a0, 0x16ea,
-	0x16ee, 0x16f0,
-	0x1700, 0x170c,
-	0x170e, 0x1713,
-	0x1720, 0x1733,
-	0x1740, 0x1753,
-	0x1760, 0x176c,
-	0x176e, 0x1770,
-	0x1772, 0x1773,
-	0x1780, 0x17b3,
-	0x17b6, 0x17c8,
-	0x17d7, 0x17d7,
-	0x17dc, 0x17dc,
-	0x17e0, 0x17e9,
-	0x1810, 0x1819,
-	0x1820, 0x1877,
-	0x1880, 0x18aa,
-	0x18b0, 0x18f5,
-	0x1900, 0x191c,
-	0x1920, 0x192b,
-	0x1930, 0x1938,
-	0x1946, 0x196d,
-	0x1970, 0x1974,
-	0x1980, 0x19ab,
-	0x19b0, 0x19c9,
-	0x19d0, 0x19da,
-	0x1a00, 0x1a1b,
-	0x1a20, 0x1a5e,
-	0x1a61, 0x1a74,
-	0x1a80, 0x1a89,
-	0x1a90, 0x1a99,
-	0x1aa7, 0x1aa7,
-	0x1b00, 0x1b33,
-	0x1b35, 0x1b43,
-	0x1b45, 0x1b4b,
-	0x1b50, 0x1b59,
-	0x1b80, 0x1ba9,
-	0x1bae, 0x1bb9,
-	0x1c00, 0x1c35,
-	0x1c40, 0x1c49,
-	0x1c4d, 0x1c7d,
-	0x1ce9, 0x1cec,
-	0x1cee, 0x1cf2,
-	0x1d00, 0x1dbf,
-	0x1e00, 0x1f15,
-	0x1f18, 0x1f1d,
-	0x1f20, 0x1f45,
-	0x1f48, 0x1f4d,
-	0x1f50, 0x1f57,
-	0x1f59, 0x1f59,
-	0x1f5b, 0x1f5b,
-	0x1f5d, 0x1f5d,
-	0x1f5f, 0x1f7d,
-	0x1f80, 0x1fb4,
-	0x1fb6, 0x1fbc,
-	0x1fbe, 0x1fbe,
-	0x1fc2, 0x1fc4,
-	0x1fc6, 0x1fcc,
-	0x1fd0, 0x1fd3,
-	0x1fd6, 0x1fdb,
-	0x1fe0, 0x1fec,
-	0x1ff2, 0x1ff4,
-	0x1ff6, 0x1ffc,
-	0x2071, 0x2071,
-	0x207f, 0x207f,
-	0x2090, 0x2094,
-	0x2102, 0x2102,
-	0x2107, 0x2107,
-	0x210a, 0x2113,
-	0x2115, 0x2115,
-	0x2119, 0x211d,
-	0x2124, 0x2124,
-	0x2126, 0x2126,
-	0x2128, 0x2128,
-	0x212a, 0x212d,
-	0x212f, 0x2139,
-	0x213c, 0x213f,
-	0x2145, 0x2149,
-	0x214e, 0x214e,
-	0x2160, 0x2188,
-	0x24b6, 0x24e9,
-	0x2c00, 0x2c2e,
-	0x2c30, 0x2c5e,
-	0x2c60, 0x2ce4,
-	0x2ceb, 0x2cee,
-	0x2d00, 0x2d25,
-	0x2d30, 0x2d65,
-	0x2d6f, 0x2d6f,
-	0x2d80, 0x2d96,
-	0x2da0, 0x2da6,
-	0x2da8, 0x2dae,
-	0x2db0, 0x2db6,
-	0x2db8, 0x2dbe,
-	0x2dc0, 0x2dc6,
-	0x2dc8, 0x2dce,
-	0x2dd0, 0x2dd6,
-	0x2dd8, 0x2dde,
-	0x2de0, 0x2dff,
-	0x2e2f, 0x2e2f,
-	0x3005, 0x3007,
-	0x3021, 0x3029,
-	0x3031, 0x3035,
-	0x3038, 0x303c,
-	0x3041, 0x3096,
-	0x309d, 0x309f,
-	0x30a1, 0x30fa,
-	0x30fc, 0x30ff,
-	0x3105, 0x312d,
-	0x3131, 0x318e,
-	0x31a0, 0x31b7,
-	0x31f0, 0x31ff,
-	0x3400, 0x4db5,
-	0x4e00, 0x9fcb,
-	0xa000, 0xa48c,
-	0xa4d0, 0xa4fd,
-	0xa500, 0xa60c,
-	0xa610, 0xa62b,
-	0xa640, 0xa65f,
-	0xa662, 0xa66e,
-	0xa67f, 0xa697,
-	0xa6a0, 0xa6ef,
-	0xa717, 0xa71f,
-	0xa722, 0xa788,
-	0xa78b, 0xa78c,
-	0xa7fb, 0xa801,
-	0xa803, 0xa805,
-	0xa807, 0xa80a,
-	0xa80c, 0xa827,
-	0xa840, 0xa873,
-	0xa880, 0xa8c3,
-	0xa8d0, 0xa8d9,
-	0xa8f2, 0xa8f7,
-	0xa8fb, 0xa8fb,
-	0xa900, 0xa92a,
-	0xa930, 0xa952,
-	0xa960, 0xa97c,
-	0xa980, 0xa9bf,
-	0xa9cf, 0xa9d9,
-	0xaa00, 0xaa36,
-	0xaa40, 0xaa4d,
-	0xaa50, 0xaa59,
-	0xaa60, 0xaa76,
-	0xaa7a, 0xaa7a,
-	0xaa80, 0xaabe,
-	0xaac0, 0xaac0,
-	0xaac2, 0xaac2,
-	0xaadb, 0xaadd,
-	0xabc0, 0xabea,
-	0xabf0, 0xabf9,
-	0xac00, 0xd7a3,
-	0xd7b0, 0xd7c6,
-	0xd7cb, 0xd7fb,
-	0xf900, 0xfa2d,
-	0xfa30, 0xfa6d,
-	0xfa70, 0xfad9,
-	0xfb00, 0xfb06,
-	0xfb13, 0xfb17,
-	0xfb1d, 0xfb28,
-	0xfb2a, 0xfb36,
-	0xfb38, 0xfb3c,
-	0xfb3e, 0xfb3e,
-	0xfb40, 0xfb41,
-	0xfb43, 0xfb44,
-	0xfb46, 0xfbb1,
-	0xfbd3, 0xfd3d,
-	0xfd50, 0xfd8f,
-	0xfd92, 0xfdc7,
-	0xfdf0, 0xfdfb,
-	0xfe70, 0xfe74,
-	0xfe76, 0xfefc,
-	0xff10, 0xff19,
-	0xff21, 0xff3a,
-	0xff41, 0xff5a,
-	0xff66, 0xffbe,
-	0xffc2, 0xffc7,
-	0xffca, 0xffcf,
-	0xffd2, 0xffd7,
-	0xffda, 0xffdc,
-	0x10000, 0x1000b,
-	0x1000d, 0x10026,
-	0x10028, 0x1003a,
-	0x1003c, 0x1003d,
-	0x1003f, 0x1004d,
-	0x10050, 0x1005d,
-	0x10080, 0x100fa,
-	0x10140, 0x10174,
-	0x10280, 0x1029c,
-	0x102a0, 0x102d0,
-	0x10300, 0x1031e,
-	0x10330, 0x1034a,
-	0x10380, 0x1039d,
-	0x103a0, 0x103c3,
-	0x103c8, 0x103cf,
-	0x103d1, 0x103d5,
-	0x10400, 0x1049d,
-	0x104a0, 0x104a9,
-	0x10800, 0x10805,
-	0x10808, 0x10808,
-	0x1080a, 0x10835,
-	0x10837, 0x10838,
-	0x1083c, 0x1083c,
-	0x1083f, 0x10855,
-	0x10900, 0x10915,
-	0x10920, 0x10939,
-	0x10a00, 0x10a03,
-	0x10a05, 0x10a06,
-	0x10a0c, 0x10a13,
-	0x10a15, 0x10a17,
-	0x10a19, 0x10a33,
-	0x10a60, 0x10a7c,
-	0x10b00, 0x10b35,
-	0x10b40, 0x10b55,
-	0x10b60, 0x10b72,
-	0x10c00, 0x10c48,
-	0x11082, 0x110b8,
-	0x12000, 0x1236e,
-	0x12400, 0x12462,
-	0x13000, 0x1342e,
-	0x1d400, 0x1d454,
-	0x1d456, 0x1d49c,
-	0x1d49e, 0x1d49f,
-	0x1d4a2, 0x1d4a2,
-	0x1d4a5, 0x1d4a6,
-	0x1d4a9, 0x1d4ac,
-	0x1d4ae, 0x1d4b9,
-	0x1d4bb, 0x1d4bb,
-	0x1d4bd, 0x1d4c3,
-	0x1d4c5, 0x1d505,
-	0x1d507, 0x1d50a,
-	0x1d50d, 0x1d514,
-	0x1d516, 0x1d51c,
-	0x1d51e, 0x1d539,
-	0x1d53b, 0x1d53e,
-	0x1d540, 0x1d544,
-	0x1d546, 0x1d546,
-	0x1d54a, 0x1d550,
-	0x1d552, 0x1d6a5,
-	0x1d6a8, 0x1d6c0,
-	0x1d6c2, 0x1d6da,
-	0x1d6dc, 0x1d6fa,
-	0x1d6fc, 0x1d714,
-	0x1d716, 0x1d734,
-	0x1d736, 0x1d74e,
-	0x1d750, 0x1d76e,
-	0x1d770, 0x1d788,
-	0x1d78a, 0x1d7a8,
-	0x1d7aa, 0x1d7c2,
-	0x1d7c4, 0x1d7cb,
-	0x1d7ce, 0x1d7ff,
-	0x20000, 0x2a6d6,
-	0x2a700, 0x2b734,
-	0x2f800, 0x2fa1d,
+        497,
+        0x0030, 0x0039,
+        0x0041, 0x005a,
+        0x0061, 0x007a,
+        0x00aa, 0x00aa,
+        0x00b5, 0x00b5,
+        0x00ba, 0x00ba,
+        0x00c0, 0x00d6,
+        0x00d8, 0x00f6,
+        0x00f8, 0x02c1,
+        0x02c6, 0x02d1,
+        0x02e0, 0x02e4,
+        0x02ec, 0x02ec,
+        0x02ee, 0x02ee,
+        0x0345, 0x0345,
+        0x0370, 0x0374,
+        0x0376, 0x0377,
+        0x037a, 0x037d,
+        0x0386, 0x0386,
+        0x0388, 0x038a,
+        0x038c, 0x038c,
+        0x038e, 0x03a1,
+        0x03a3, 0x03f5,
+        0x03f7, 0x0481,
+        0x048a, 0x0525,
+        0x0531, 0x0556,
+        0x0559, 0x0559,
+        0x0561, 0x0587,
+        0x05b0, 0x05bd,
+        0x05bf, 0x05bf,
+        0x05c1, 0x05c2,
+        0x05c4, 0x05c5,
+        0x05c7, 0x05c7,
+        0x05d0, 0x05ea,
+        0x05f0, 0x05f2,
+        0x0610, 0x061a,
+        0x0621, 0x0657,
+        0x0659, 0x065e,
+        0x0660, 0x0669,
+        0x066e, 0x06d3,
+        0x06d5, 0x06dc,
+        0x06e1, 0x06e8,
+        0x06ed, 0x06fc,
+        0x06ff, 0x06ff,
+        0x0710, 0x073f,
+        0x074d, 0x07b1,
+        0x07c0, 0x07ea,
+        0x07f4, 0x07f5,
+        0x07fa, 0x07fa,
+        0x0800, 0x0817,
+        0x081a, 0x082c,
+        0x0900, 0x0939,
+        0x093d, 0x094c,
+        0x094e, 0x094e,
+        0x0950, 0x0950,
+        0x0955, 0x0955,
+        0x0958, 0x0963,
+        0x0966, 0x096f,
+        0x0971, 0x0972,
+        0x0979, 0x097f,
+        0x0981, 0x0983,
+        0x0985, 0x098c,
+        0x098f, 0x0990,
+        0x0993, 0x09a8,
+        0x09aa, 0x09b0,
+        0x09b2, 0x09b2,
+        0x09b6, 0x09b9,
+        0x09bd, 0x09c4,
+        0x09c7, 0x09c8,
+        0x09cb, 0x09cc,
+        0x09ce, 0x09ce,
+        0x09d7, 0x09d7,
+        0x09dc, 0x09dd,
+        0x09df, 0x09e3,
+        0x09e6, 0x09f1,
+        0x0a01, 0x0a03,
+        0x0a05, 0x0a0a,
+        0x0a0f, 0x0a10,
+        0x0a13, 0x0a28,
+        0x0a2a, 0x0a30,
+        0x0a32, 0x0a33,
+        0x0a35, 0x0a36,
+        0x0a38, 0x0a39,
+        0x0a3e, 0x0a42,
+        0x0a47, 0x0a48,
+        0x0a4b, 0x0a4c,
+        0x0a51, 0x0a51,
+        0x0a59, 0x0a5c,
+        0x0a5e, 0x0a5e,
+        0x0a66, 0x0a75,
+        0x0a81, 0x0a83,
+        0x0a85, 0x0a8d,
+        0x0a8f, 0x0a91,
+        0x0a93, 0x0aa8,
+        0x0aaa, 0x0ab0,
+        0x0ab2, 0x0ab3,
+        0x0ab5, 0x0ab9,
+        0x0abd, 0x0ac5,
+        0x0ac7, 0x0ac9,
+        0x0acb, 0x0acc,
+        0x0ad0, 0x0ad0,
+        0x0ae0, 0x0ae3,
+        0x0ae6, 0x0aef,
+        0x0b01, 0x0b03,
+        0x0b05, 0x0b0c,
+        0x0b0f, 0x0b10,
+        0x0b13, 0x0b28,
+        0x0b2a, 0x0b30,
+        0x0b32, 0x0b33,
+        0x0b35, 0x0b39,
+        0x0b3d, 0x0b44,
+        0x0b47, 0x0b48,
+        0x0b4b, 0x0b4c,
+        0x0b56, 0x0b57,
+        0x0b5c, 0x0b5d,
+        0x0b5f, 0x0b63,
+        0x0b66, 0x0b6f,
+        0x0b71, 0x0b71,
+        0x0b82, 0x0b83,
+        0x0b85, 0x0b8a,
+        0x0b8e, 0x0b90,
+        0x0b92, 0x0b95,
+        0x0b99, 0x0b9a,
+        0x0b9c, 0x0b9c,
+        0x0b9e, 0x0b9f,
+        0x0ba3, 0x0ba4,
+        0x0ba8, 0x0baa,
+        0x0bae, 0x0bb9,
+        0x0bbe, 0x0bc2,
+        0x0bc6, 0x0bc8,
+        0x0bca, 0x0bcc,
+        0x0bd0, 0x0bd0,
+        0x0bd7, 0x0bd7,
+        0x0be6, 0x0bef,
+        0x0c01, 0x0c03,
+        0x0c05, 0x0c0c,
+        0x0c0e, 0x0c10,
+        0x0c12, 0x0c28,
+        0x0c2a, 0x0c33,
+        0x0c35, 0x0c39,
+        0x0c3d, 0x0c44,
+        0x0c46, 0x0c48,
+        0x0c4a, 0x0c4c,
+        0x0c55, 0x0c56,
+        0x0c58, 0x0c59,
+        0x0c60, 0x0c63,
+        0x0c66, 0x0c6f,
+        0x0c82, 0x0c83,
+        0x0c85, 0x0c8c,
+        0x0c8e, 0x0c90,
+        0x0c92, 0x0ca8,
+        0x0caa, 0x0cb3,
+        0x0cb5, 0x0cb9,
+        0x0cbd, 0x0cc4,
+        0x0cc6, 0x0cc8,
+        0x0cca, 0x0ccc,
+        0x0cd5, 0x0cd6,
+        0x0cde, 0x0cde,
+        0x0ce0, 0x0ce3,
+        0x0ce6, 0x0cef,
+        0x0d02, 0x0d03,
+        0x0d05, 0x0d0c,
+        0x0d0e, 0x0d10,
+        0x0d12, 0x0d28,
+        0x0d2a, 0x0d39,
+        0x0d3d, 0x0d44,
+        0x0d46, 0x0d48,
+        0x0d4a, 0x0d4c,
+        0x0d57, 0x0d57,
+        0x0d60, 0x0d63,
+        0x0d66, 0x0d6f,
+        0x0d7a, 0x0d7f,
+        0x0d82, 0x0d83,
+        0x0d85, 0x0d96,
+        0x0d9a, 0x0db1,
+        0x0db3, 0x0dbb,
+        0x0dbd, 0x0dbd,
+        0x0dc0, 0x0dc6,
+        0x0dcf, 0x0dd4,
+        0x0dd6, 0x0dd6,
+        0x0dd8, 0x0ddf,
+        0x0df2, 0x0df3,
+        0x0e01, 0x0e3a,
+        0x0e40, 0x0e46,
+        0x0e4d, 0x0e4d,
+        0x0e50, 0x0e59,
+        0x0e81, 0x0e82,
+        0x0e84, 0x0e84,
+        0x0e87, 0x0e88,
+        0x0e8a, 0x0e8a,
+        0x0e8d, 0x0e8d,
+        0x0e94, 0x0e97,
+        0x0e99, 0x0e9f,
+        0x0ea1, 0x0ea3,
+        0x0ea5, 0x0ea5,
+        0x0ea7, 0x0ea7,
+        0x0eaa, 0x0eab,
+        0x0ead, 0x0eb9,
+        0x0ebb, 0x0ebd,
+        0x0ec0, 0x0ec4,
+        0x0ec6, 0x0ec6,
+        0x0ecd, 0x0ecd,
+        0x0ed0, 0x0ed9,
+        0x0edc, 0x0edd,
+        0x0f00, 0x0f00,
+        0x0f20, 0x0f29,
+        0x0f40, 0x0f47,
+        0x0f49, 0x0f6c,
+        0x0f71, 0x0f81,
+        0x0f88, 0x0f8b,
+        0x0f90, 0x0f97,
+        0x0f99, 0x0fbc,
+        0x1000, 0x1036,
+        0x1038, 0x1038,
+        0x103b, 0x1049,
+        0x1050, 0x1062,
+        0x1065, 0x1068,
+        0x106e, 0x1086,
+        0x108e, 0x108e,
+        0x1090, 0x1099,
+        0x109c, 0x109d,
+        0x10a0, 0x10c5,
+        0x10d0, 0x10fa,
+        0x10fc, 0x10fc,
+        0x1100, 0x1248,
+        0x124a, 0x124d,
+        0x1250, 0x1256,
+        0x1258, 0x1258,
+        0x125a, 0x125d,
+        0x1260, 0x1288,
+        0x128a, 0x128d,
+        0x1290, 0x12b0,
+        0x12b2, 0x12b5,
+        0x12b8, 0x12be,
+        0x12c0, 0x12c0,
+        0x12c2, 0x12c5,
+        0x12c8, 0x12d6,
+        0x12d8, 0x1310,
+        0x1312, 0x1315,
+        0x1318, 0x135a,
+        0x135f, 0x135f,
+        0x1380, 0x138f,
+        0x13a0, 0x13f4,
+        0x1401, 0x166c,
+        0x166f, 0x167f,
+        0x1681, 0x169a,
+        0x16a0, 0x16ea,
+        0x16ee, 0x16f0,
+        0x1700, 0x170c,
+        0x170e, 0x1713,
+        0x1720, 0x1733,
+        0x1740, 0x1753,
+        0x1760, 0x176c,
+        0x176e, 0x1770,
+        0x1772, 0x1773,
+        0x1780, 0x17b3,
+        0x17b6, 0x17c8,
+        0x17d7, 0x17d7,
+        0x17dc, 0x17dc,
+        0x17e0, 0x17e9,
+        0x1810, 0x1819,
+        0x1820, 0x1877,
+        0x1880, 0x18aa,
+        0x18b0, 0x18f5,
+        0x1900, 0x191c,
+        0x1920, 0x192b,
+        0x1930, 0x1938,
+        0x1946, 0x196d,
+        0x1970, 0x1974,
+        0x1980, 0x19ab,
+        0x19b0, 0x19c9,
+        0x19d0, 0x19da,
+        0x1a00, 0x1a1b,
+        0x1a20, 0x1a5e,
+        0x1a61, 0x1a74,
+        0x1a80, 0x1a89,
+        0x1a90, 0x1a99,
+        0x1aa7, 0x1aa7,
+        0x1b00, 0x1b33,
+        0x1b35, 0x1b43,
+        0x1b45, 0x1b4b,
+        0x1b50, 0x1b59,
+        0x1b80, 0x1ba9,
+        0x1bae, 0x1bb9,
+        0x1c00, 0x1c35,
+        0x1c40, 0x1c49,
+        0x1c4d, 0x1c7d,
+        0x1ce9, 0x1cec,
+        0x1cee, 0x1cf2,
+        0x1d00, 0x1dbf,
+        0x1e00, 0x1f15,
+        0x1f18, 0x1f1d,
+        0x1f20, 0x1f45,
+        0x1f48, 0x1f4d,
+        0x1f50, 0x1f57,
+        0x1f59, 0x1f59,
+        0x1f5b, 0x1f5b,
+        0x1f5d, 0x1f5d,
+        0x1f5f, 0x1f7d,
+        0x1f80, 0x1fb4,
+        0x1fb6, 0x1fbc,
+        0x1fbe, 0x1fbe,
+        0x1fc2, 0x1fc4,
+        0x1fc6, 0x1fcc,
+        0x1fd0, 0x1fd3,
+        0x1fd6, 0x1fdb,
+        0x1fe0, 0x1fec,
+        0x1ff2, 0x1ff4,
+        0x1ff6, 0x1ffc,
+        0x2071, 0x2071,
+        0x207f, 0x207f,
+        0x2090, 0x2094,
+        0x2102, 0x2102,
+        0x2107, 0x2107,
+        0x210a, 0x2113,
+        0x2115, 0x2115,
+        0x2119, 0x211d,
+        0x2124, 0x2124,
+        0x2126, 0x2126,
+        0x2128, 0x2128,
+        0x212a, 0x212d,
+        0x212f, 0x2139,
+        0x213c, 0x213f,
+        0x2145, 0x2149,
+        0x214e, 0x214e,
+        0x2160, 0x2188,
+        0x24b6, 0x24e9,
+        0x2c00, 0x2c2e,
+        0x2c30, 0x2c5e,
+        0x2c60, 0x2ce4,
+        0x2ceb, 0x2cee,
+        0x2d00, 0x2d25,
+        0x2d30, 0x2d65,
+        0x2d6f, 0x2d6f,
+        0x2d80, 0x2d96,
+        0x2da0, 0x2da6,
+        0x2da8, 0x2dae,
+        0x2db0, 0x2db6,
+        0x2db8, 0x2dbe,
+        0x2dc0, 0x2dc6,
+        0x2dc8, 0x2dce,
+        0x2dd0, 0x2dd6,
+        0x2dd8, 0x2dde,
+        0x2de0, 0x2dff,
+        0x2e2f, 0x2e2f,
+        0x3005, 0x3007,
+        0x3021, 0x3029,
+        0x3031, 0x3035,
+        0x3038, 0x303c,
+        0x3041, 0x3096,
+        0x309d, 0x309f,
+        0x30a1, 0x30fa,
+        0x30fc, 0x30ff,
+        0x3105, 0x312d,
+        0x3131, 0x318e,
+        0x31a0, 0x31b7,
+        0x31f0, 0x31ff,
+        0x3400, 0x4db5,
+        0x4e00, 0x9fcb,
+        0xa000, 0xa48c,
+        0xa4d0, 0xa4fd,
+        0xa500, 0xa60c,
+        0xa610, 0xa62b,
+        0xa640, 0xa65f,
+        0xa662, 0xa66e,
+        0xa67f, 0xa697,
+        0xa6a0, 0xa6ef,
+        0xa717, 0xa71f,
+        0xa722, 0xa788,
+        0xa78b, 0xa78c,
+        0xa7fb, 0xa801,
+        0xa803, 0xa805,
+        0xa807, 0xa80a,
+        0xa80c, 0xa827,
+        0xa840, 0xa873,
+        0xa880, 0xa8c3,
+        0xa8d0, 0xa8d9,
+        0xa8f2, 0xa8f7,
+        0xa8fb, 0xa8fb,
+        0xa900, 0xa92a,
+        0xa930, 0xa952,
+        0xa960, 0xa97c,
+        0xa980, 0xa9bf,
+        0xa9cf, 0xa9d9,
+        0xaa00, 0xaa36,
+        0xaa40, 0xaa4d,
+        0xaa50, 0xaa59,
+        0xaa60, 0xaa76,
+        0xaa7a, 0xaa7a,
+        0xaa80, 0xaabe,
+        0xaac0, 0xaac0,
+        0xaac2, 0xaac2,
+        0xaadb, 0xaadd,
+        0xabc0, 0xabea,
+        0xabf0, 0xabf9,
+        0xac00, 0xd7a3,
+        0xd7b0, 0xd7c6,
+        0xd7cb, 0xd7fb,
+        0xf900, 0xfa2d,
+        0xfa30, 0xfa6d,
+        0xfa70, 0xfad9,
+        0xfb00, 0xfb06,
+        0xfb13, 0xfb17,
+        0xfb1d, 0xfb28,
+        0xfb2a, 0xfb36,
+        0xfb38, 0xfb3c,
+        0xfb3e, 0xfb3e,
+        0xfb40, 0xfb41,
+        0xfb43, 0xfb44,
+        0xfb46, 0xfbb1,
+        0xfbd3, 0xfd3d,
+        0xfd50, 0xfd8f,
+        0xfd92, 0xfdc7,
+        0xfdf0, 0xfdfb,
+        0xfe70, 0xfe74,
+        0xfe76, 0xfefc,
+        0xff10, 0xff19,
+        0xff21, 0xff3a,
+        0xff41, 0xff5a,
+        0xff66, 0xffbe,
+        0xffc2, 0xffc7,
+        0xffca, 0xffcf,
+        0xffd2, 0xffd7,
+        0xffda, 0xffdc,
+        0x10000, 0x1000b,
+        0x1000d, 0x10026,
+        0x10028, 0x1003a,
+        0x1003c, 0x1003d,
+        0x1003f, 0x1004d,
+        0x10050, 0x1005d,
+        0x10080, 0x100fa,
+        0x10140, 0x10174,
+        0x10280, 0x1029c,
+        0x102a0, 0x102d0,
+        0x10300, 0x1031e,
+        0x10330, 0x1034a,
+        0x10380, 0x1039d,
+        0x103a0, 0x103c3,
+        0x103c8, 0x103cf,
+        0x103d1, 0x103d5,
+        0x10400, 0x1049d,
+        0x104a0, 0x104a9,
+        0x10800, 0x10805,
+        0x10808, 0x10808,
+        0x1080a, 0x10835,
+        0x10837, 0x10838,
+        0x1083c, 0x1083c,
+        0x1083f, 0x10855,
+        0x10900, 0x10915,
+        0x10920, 0x10939,
+        0x10a00, 0x10a03,
+        0x10a05, 0x10a06,
+        0x10a0c, 0x10a13,
+        0x10a15, 0x10a17,
+        0x10a19, 0x10a33,
+        0x10a60, 0x10a7c,
+        0x10b00, 0x10b35,
+        0x10b40, 0x10b55,
+        0x10b60, 0x10b72,
+        0x10c00, 0x10c48,
+        0x11082, 0x110b8,
+        0x12000, 0x1236e,
+        0x12400, 0x12462,
+        0x13000, 0x1342e,
+        0x1d400, 0x1d454,
+        0x1d456, 0x1d49c,
+        0x1d49e, 0x1d49f,
+        0x1d4a2, 0x1d4a2,
+        0x1d4a5, 0x1d4a6,
+        0x1d4a9, 0x1d4ac,
+        0x1d4ae, 0x1d4b9,
+        0x1d4bb, 0x1d4bb,
+        0x1d4bd, 0x1d4c3,
+        0x1d4c5, 0x1d505,
+        0x1d507, 0x1d50a,
+        0x1d50d, 0x1d514,
+        0x1d516, 0x1d51c,
+        0x1d51e, 0x1d539,
+        0x1d53b, 0x1d53e,
+        0x1d540, 0x1d544,
+        0x1d546, 0x1d546,
+        0x1d54a, 0x1d550,
+        0x1d552, 0x1d6a5,
+        0x1d6a8, 0x1d6c0,
+        0x1d6c2, 0x1d6da,
+        0x1d6dc, 0x1d6fa,
+        0x1d6fc, 0x1d714,
+        0x1d716, 0x1d734,
+        0x1d736, 0x1d74e,
+        0x1d750, 0x1d76e,
+        0x1d770, 0x1d788,
+        0x1d78a, 0x1d7a8,
+        0x1d7aa, 0x1d7c2,
+        0x1d7c4, 0x1d7cb,
+        0x1d7ce, 0x1d7ff,
+        0x20000, 0x2a6d6,
+        0x2a700, 0x2b734,
+        0x2f800, 0x2fa1d,
 }; /* CR_Alnum */
 
 /* 'ASCII': [[:ASCII:]] */
 static const OnigCodePoint CR_ASCII[] = {
-	1,
-	0x0000, 0x007f,
+        1,
+        0x0000, 0x007f,
 }; /* CR_ASCII */
 
 static const OnigCodePoint* const CodeRanges[] = {
diff --git a/src/node.h b/src/node.h
index 74af5f1e9..8ae0301ba 100644
--- a/src/node.h
+++ b/src/node.h
@@ -1,6 +1,6 @@
 /*
 ** node.h - nodes of abstract syntax tree
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/numeric.c b/src/numeric.c
index 23da9089c..bf255f973 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -1,6 +1,6 @@
 /*
 ** numeric.c - Numeric, Integer, Float, Fixnum class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/object.c b/src/object.c
index 7f2cfcb0f..6c0e944a8 100644
--- a/src/object.c
+++ b/src/object.c
@@ -1,6 +1,6 @@
 /*
 ** object.c - Object, NilClass, TrueClass, FalseClass class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/opcode.h b/src/opcode.h
index 9cf261ce8..9e7cf7f34 100644
--- a/src/opcode.h
+++ b/src/opcode.h
@@ -1,6 +1,6 @@
 /*
 ** opcode.h - RiteVM operation codes
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -47,98 +47,98 @@
 #define MKOP_Abc(op,a,b,c)  (MKOP_A(op,a)|MKARG_bc(b,c))
 
 enum {
-OP_NOP=0,/*								*/
-OP_MOVE,/*	A B	R(A) := R(B)					*/
-OP_LOADL,/*	A Bx	R(A) := Lit(Bx)					*/
-OP_LOADI,/*	A sBx	R(A) := sBx					*/
-OP_LOADSYM,/*	A Bx	R(A) := Sym(Bx)					*/
-OP_LOADNIL,/*	A	R(A) := nil					*/
-OP_LOADSELF,/*	A	R(A) := self					*/
-OP_LOADT,/*	A	R(A) := true					*/
-OP_LOADF,/*	A	R(A) := false					*/
-
-OP_GETGLOBAL,/*	A Bx	R(A) := getglobal(Sym(Bx))			*/
-OP_SETGLOBAL,/*	A Bx	setglobal(Sym(Bx), R(A))			*/
-OP_GETSPECIAL,/*A Bx	R(A) := Special[Bx]				*/
-OP_SETSPECIAL,/*A Bx	Special[Bx] := R(A)				*/
-OP_GETIV,/*	A Bx	R(A) := ivget(Sym(Bx))				*/
-OP_SETIV,/*	A Bx	ivset(Sym(Bx),R(A))				*/
-OP_GETCV,/*	A Bx	R(A) := cvget(Sym(Bx))				*/
-OP_SETCV,/*	A Bx	cvset(Sym(Bx),R(A))				*/
-OP_GETCONST,/*	A Bx	R(A) := constget(Sym(Bx))			*/
-OP_SETCONST,/*	A Bx	constset(Sym(Bx),R(A))				*/
-OP_GETMCNST,/*	A Bx	R(A) := R(A)::Sym(B)				*/
-OP_SETMCNST,/*	A Bx	R(A+1)::Sym(B) := R(A)				*/
-OP_GETUPVAR,/*	A B C	R(A) := uvget(B,C)				*/
-OP_SETUPVAR,/*	A B C	uvset(B,C,R(A))					*/
-
-OP_JMP,/*	sBx	pc+=sBx						*/
-OP_JMPIF,/*	A sBx	if R(A) pc+=sBx					*/
-OP_JMPNOT,/*	A sBx	if !R(A) pc+=sBx				*/
-OP_ONERR,/*	sBx	rescue_push(pc+sBx)				*/
-OP_RESCUE,/*	A	clear(exc); R(A) := exception (ignore when A=0)	*/
-OP_POPERR,/*	A	A.times{rescue_pop()}				*/
-OP_RAISE,/*	A	raise(R(A))					*/
-OP_EPUSH,/*	Bx	ensure_push(SEQ[Bx])				*/
-OP_EPOP,/*	A	A.times{ensure_pop().call}			*/
-
-OP_SEND,/*	A B C	R(A) := call(R(A),mSym(B),R(A+1),...,R(A+C))	*/
-OP_FSEND,/*	A B C	R(A) := fcall(R(A),mSym(B),R(A+1),...,R(A+C-1)) */
-OP_VSEND,/*	A B	R(A) := vcall(R(A),mSym(B))			*/
-OP_CALL,/*	A B C	R(A) := self.call(R(A),.., R(A+C))		*/
-OP_SUPER,/*	A B C	R(A) := super(R(A+1),... ,R(A+C-1))		*/
-OP_ARGARY,/*	A Bx	R(A) := argument array (16=6:1:5:4)		*/
-OP_ENTER,/*	Ax	arg setup according to flags (24=5:5:1:5:5:1:1)	*/
-OP_KARG,/*	A B C	R(A) := kdict[mSym(B)]; if C kdict.rm(mSym(B))	*/
-OP_KDICT,/*	A C	R(A) := kdict					*/
-
-OP_RETURN,/*	A B	return R(A) (B=normal,in-block return/break)	*/
-OP_TAILCALL,/*	A B C	return call(R(A),mSym(B),*R(C))			*/
-OP_BLKPUSH,/*	A Bx	R(A) := block (16=6:1:5:4)			*/
-
-OP_ADD,/*	A B C	R(A) := R(A)+R(A+1) (mSyms[B]=:+,C=1)		*/
-OP_ADDI,/*	A B C	R(A) := R(A)+C (mSyms[B]=:+)			*/
-OP_SUB,/*	A B C	R(A) := R(A)-R(A+1) (mSyms[B]=:-,C=1)		*/
-OP_SUBI,/*	A B C	R(A) := R(A)-C (mSyms[B]=:-)			*/
-OP_MUL,/*	A B C	R(A) := R(A)*R(A+1) (mSyms[B]=:*,C=1)		*/
-OP_DIV,/*	A B C	R(A) := R(A)/R(A+1) (mSyms[B]=:/,C=1)		*/
-OP_EQ,/*	A B C	R(A) := R(A)==R(A+1) (mSyms[B]=:==,C=1)		*/
-OP_LT,/*	A B C	R(A) := R(A)<R(A+1)  (mSyms[B]=:<,C=1)		*/
-OP_LE,/*	A B C	R(A) := R(A)<=R(A+1) (mSyms[B]=:<=,C=1)		*/
-OP_GT,/*	A B C	R(A) := R(A)>R(A+1)  (mSyms[B]=:>,C=1)		*/
-OP_GE,/*	A B C	R(A) := R(A)>=R(A+1) (mSyms[B]=:>=,C=1)		*/
-
-OP_ARRAY,/*	A B C	R(A) := ary_new(R(B),R(B+1)..R(B+C))		*/
-OP_ARYCAT,/*	A B	ary_cat(R(A),R(B))				*/
-OP_ARYPUSH,/*	A B	ary_push(R(A),R(B))				*/
-OP_AREF,/*	A B C	R(A) := R(B)[C]					*/
-OP_ASET,/*	A B C	R(B)[C] := R(A)					*/
-OP_APOST,/*	A B C	*R(A),R(A+1)..R(A+C) := R(A)			*/
-
-OP_STRING,/*	A Bx	R(A) := str_dup(Lit(Bx))			*/
-OP_STRCAT,/*	A B	str_cat(R(A),R(B))				*/
-
-OP_HASH,/*	A B C	R(A) := hash_new(R(B),R(B+1)..R(B+C))		*/
-OP_LAMBDA,/*	A Bz Cz	R(A) := lambda(SEQ[Bz],Cm)			*/
-OP_RANGE,/*	A B C	R(A) := range_new(R(B),R(B+1),C)		*/
-
-OP_OCLASS,/*	A	R(A) := ::Object				*/
-OP_CLASS,/*	A B	R(A) := newclass(R(A),mSym(B),R(A+1))		*/
-OP_MODULE,/*	A B	R(A) := newmodule(R(A),mSym(B))			*/
-OP_EXEC,/*	A Bx	R(A) := blockexec(R(A),SEQ[Bx])			*/
-OP_METHOD,/*	A B	R(A).newmethod(mSym(B),R(A+1))			*/
-OP_SCLASS,/*	A B	R(A) := R(B).singleton_class			*/
-OP_TCLASS,/*	A	R(A) := target_class				*/
-
-OP_DEBUG,/*	A	print R(A)					*/
-OP_STOP,/*		stop VM						*/
-OP_ERR,/*	Bx	raise RuntimeError with message Lit(Bx)		*/
-
-OP_RSVD1,/*		reserved instruction #1				*/
-OP_RSVD2,/*		reserved instruction #2				*/
-OP_RSVD3,/*		reserved instruction #3				*/
-OP_RSVD4,/*		reserved instruction #4				*/
-OP_RSVD5,/*		reserved instruction #5				*/
+OP_NOP=0,/*                                                             */
+OP_MOVE,/*      A B     R(A) := R(B)                                    */
+OP_LOADL,/*     A Bx    R(A) := Lit(Bx)                                 */
+OP_LOADI,/*     A sBx   R(A) := sBx                                     */
+OP_LOADSYM,/*   A Bx    R(A) := Sym(Bx)                                 */
+OP_LOADNIL,/*   A       R(A) := nil                                     */
+OP_LOADSELF,/*  A       R(A) := self                                    */
+OP_LOADT,/*     A       R(A) := true                                    */
+OP_LOADF,/*     A       R(A) := false                                   */
+
+OP_GETGLOBAL,/* A Bx    R(A) := getglobal(Sym(Bx))                      */
+OP_SETGLOBAL,/* A Bx    setglobal(Sym(Bx), R(A))                        */
+OP_GETSPECIAL,/*A Bx    R(A) := Special[Bx]                             */
+OP_SETSPECIAL,/*A Bx    Special[Bx] := R(A)                             */
+OP_GETIV,/*     A Bx    R(A) := ivget(Sym(Bx))                          */
+OP_SETIV,/*     A Bx    ivset(Sym(Bx),R(A))                             */
+OP_GETCV,/*     A Bx    R(A) := cvget(Sym(Bx))                          */
+OP_SETCV,/*     A Bx    cvset(Sym(Bx),R(A))                             */
+OP_GETCONST,/*  A Bx    R(A) := constget(Sym(Bx))                       */
+OP_SETCONST,/*  A Bx    constset(Sym(Bx),R(A))                          */
+OP_GETMCNST,/*  A Bx    R(A) := R(A)::Sym(B)                            */
+OP_SETMCNST,/*  A Bx    R(A+1)::Sym(B) := R(A)                          */
+OP_GETUPVAR,/*  A B C   R(A) := uvget(B,C)                              */
+OP_SETUPVAR,/*  A B C   uvset(B,C,R(A))                                 */
+
+OP_JMP,/*       sBx     pc+=sBx                                         */
+OP_JMPIF,/*     A sBx   if R(A) pc+=sBx                                 */
+OP_JMPNOT,/*    A sBx   if !R(A) pc+=sBx                                */
+OP_ONERR,/*     sBx     rescue_push(pc+sBx)                             */
+OP_RESCUE,/*    A       clear(exc); R(A) := exception (ignore when A=0) */
+OP_POPERR,/*    A       A.times{rescue_pop()}                           */
+OP_RAISE,/*     A       raise(R(A))                                     */
+OP_EPUSH,/*     Bx      ensure_push(SEQ[Bx])                            */
+OP_EPOP,/*      A       A.times{ensure_pop().call}                      */
+
+OP_SEND,/*      A B C   R(A) := call(R(A),mSym(B),R(A+1),...,R(A+C))    */
+OP_FSEND,/*     A B C   R(A) := fcall(R(A),mSym(B),R(A+1),...,R(A+C-1)) */
+OP_VSEND,/*     A B     R(A) := vcall(R(A),mSym(B))                     */
+OP_CALL,/*      A B C   R(A) := self.call(R(A),.., R(A+C))              */
+OP_SUPER,/*     A B C   R(A) := super(R(A+1),... ,R(A+C-1))             */
+OP_ARGARY,/*    A Bx    R(A) := argument array (16=6:1:5:4)             */
+OP_ENTER,/*     Ax      arg setup according to flags (24=5:5:1:5:5:1:1) */
+OP_KARG,/*      A B C   R(A) := kdict[mSym(B)]; if C kdict.rm(mSym(B))  */
+OP_KDICT,/*     A C     R(A) := kdict                                   */
+
+OP_RETURN,/*    A B     return R(A) (B=normal,in-block return/break)    */
+OP_TAILCALL,/*  A B C   return call(R(A),mSym(B),*R(C))                 */
+OP_BLKPUSH,/*   A Bx    R(A) := block (16=6:1:5:4)                      */
+
+OP_ADD,/*       A B C   R(A) := R(A)+R(A+1) (mSyms[B]=:+,C=1)           */
+OP_ADDI,/*      A B C   R(A) := R(A)+C (mSyms[B]=:+)                    */
+OP_SUB,/*       A B C   R(A) := R(A)-R(A+1) (mSyms[B]=:-,C=1)           */
+OP_SUBI,/*      A B C   R(A) := R(A)-C (mSyms[B]=:-)                    */
+OP_MUL,/*       A B C   R(A) := R(A)*R(A+1) (mSyms[B]=:*,C=1)           */
+OP_DIV,/*       A B C   R(A) := R(A)/R(A+1) (mSyms[B]=:/,C=1)           */
+OP_EQ,/*        A B C   R(A) := R(A)==R(A+1) (mSyms[B]=:==,C=1)         */
+OP_LT,/*        A B C   R(A) := R(A)<R(A+1)  (mSyms[B]=:<,C=1)          */
+OP_LE,/*        A B C   R(A) := R(A)<=R(A+1) (mSyms[B]=:<=,C=1)         */
+OP_GT,/*        A B C   R(A) := R(A)>R(A+1)  (mSyms[B]=:>,C=1)          */
+OP_GE,/*        A B C   R(A) := R(A)>=R(A+1) (mSyms[B]=:>=,C=1)         */
+
+OP_ARRAY,/*     A B C   R(A) := ary_new(R(B),R(B+1)..R(B+C))            */
+OP_ARYCAT,/*    A B     ary_cat(R(A),R(B))                              */
+OP_ARYPUSH,/*   A B     ary_push(R(A),R(B))                             */
+OP_AREF,/*      A B C   R(A) := R(B)[C]                                 */
+OP_ASET,/*      A B C   R(B)[C] := R(A)                                 */
+OP_APOST,/*     A B C   *R(A),R(A+1)..R(A+C) := R(A)                    */
+
+OP_STRING,/*    A Bx    R(A) := str_dup(Lit(Bx))                        */
+OP_STRCAT,/*    A B     str_cat(R(A),R(B))                              */
+
+OP_HASH,/*      A B C   R(A) := hash_new(R(B),R(B+1)..R(B+C))           */
+OP_LAMBDA,/*    A Bz Cz R(A) := lambda(SEQ[Bz],Cm)                      */
+OP_RANGE,/*     A B C   R(A) := range_new(R(B),R(B+1),C)                */
+
+OP_OCLASS,/*    A       R(A) := ::Object                                */
+OP_CLASS,/*     A B     R(A) := newclass(R(A),mSym(B),R(A+1))           */
+OP_MODULE,/*    A B     R(A) := newmodule(R(A),mSym(B))                 */
+OP_EXEC,/*      A Bx    R(A) := blockexec(R(A),SEQ[Bx])                 */
+OP_METHOD,/*    A B     R(A).newmethod(mSym(B),R(A+1))                  */
+OP_SCLASS,/*    A B     R(A) := R(B).singleton_class                    */
+OP_TCLASS,/*    A       R(A) := target_class                            */
+
+OP_DEBUG,/*     A       print R(A)                                      */
+OP_STOP,/*              stop VM                                         */
+OP_ERR,/*       Bx      raise RuntimeError with message Lit(Bx)         */
+
+OP_RSVD1,/*             reserved instruction #1                         */
+OP_RSVD2,/*             reserved instruction #2                         */
+OP_RSVD3,/*             reserved instruction #3                         */
+OP_RSVD4,/*             reserved instruction #4                         */
+OP_RSVD5,/*             reserved instruction #5                         */
 };
 
 #define OP_L_STRICT  1
@@ -151,4 +151,4 @@ OP_RSVD5,/*		reserved instruction #5				*/
 #define OP_R_BREAK  1
 #define OP_R_RETURN 2
 
-#endif	/* OPCODE_H */
+#endif  /* OPCODE_H */
diff --git a/src/pool.c b/src/pool.c
index 9461ecf60..369953699 100644
--- a/src/pool.c
+++ b/src/pool.c
@@ -1,6 +1,6 @@
 /*
 ** pool.c - memory pool
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -124,8 +124,8 @@ mrb_pool_realloc(mrb_pool *pool, void *p, size_t oldlen, size_t newlen)
       beg = (char*)p - page->page;
       if (beg + oldlen != page->offset) break;
       if (beg + newlen > page->len) {
-	page->offset = beg;
-	break;
+        page->offset = beg;
+        break;
       }
       page->offset = beg + newlen;
       return p;
diff --git a/src/pool.h b/src/pool.h
index 7b0ae78cb..6b1897a14 100644
--- a/src/pool.h
+++ b/src/pool.h
@@ -1,6 +1,6 @@
 /*
 ** pool.h - memory pool
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/print.c b/src/print.c
index e13e1ef5c..35fde4896 100644
--- a/src/print.c
+++ b/src/print.c
@@ -1,6 +1,6 @@
 /*
 ** print.c - Kernel.#p
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/proc.c b/src/proc.c
index ab5e3ac53..b77c7342a 100644
--- a/src/proc.c
+++ b/src/proc.c
@@ -1,6 +1,6 @@
 /*
 ** proc.c - Proc class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/range.c b/src/range.c
index a12e7bae6..020ae7ec0 100644
--- a/src/range.c
+++ b/src/range.c
@@ -1,6 +1,6 @@
 /*
 ** range.c - Range class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/re.c b/src/re.c
index c72f22146..d7d9914ec 100644
--- a/src/re.c
+++ b/src/re.c
@@ -1,6 +1,6 @@
 /*
 ** re.c - Regexp class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/re.h b/src/re.h
index e53927e60..686120569 100644
--- a/src/re.h
+++ b/src/re.h
@@ -1,6 +1,6 @@
 /*
 ** re.h - Regexp class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/regcomp.c b/src/regcomp.c
index 3aaac4194..816e219c7 100644
--- a/src/regcomp.c
+++ b/src/regcomp.c
@@ -764,17 +764,17 @@ compile_length_quantifier_node(QtfrNode* qn, regex_t* reg)
   if (infinite && qn->lower <= 1) {
     if (qn->greedy) {
       if (qn->lower == 1)
-	len = SIZE_OP_JUMP;
+        len = SIZE_OP_JUMP;
       else
-	len = 0;
+        len = 0;
 
       len += SIZE_OP_PUSH + cklen + mod_tlen + SIZE_OP_JUMP;
     }
     else {
       if (qn->lower == 0)
-	len = SIZE_OP_JUMP;
+        len = SIZE_OP_JUMP;
       else
-	len = 0;
+        len = 0;
 
       len += mod_tlen + SIZE_OP_PUSH + cklen;
     }
@@ -788,10 +788,10 @@ compile_length_quantifier_node(QtfrNode* qn, regex_t* reg)
   else if (qn->upper == 1 && qn->greedy) {
     if (qn->lower == 0) {
       if (CKN_ON) {
-	len = SIZE_OP_STATE_CHECK_PUSH + tlen;
+        len = SIZE_OP_STATE_CHECK_PUSH + tlen;
       }
       else {
-	len = SIZE_OP_PUSH + tlen;
+        len = SIZE_OP_PUSH + tlen;
       }
     }
     else {
@@ -829,31 +829,31 @@ compile_quantifier_node(QtfrNode* qn, regex_t* reg)
     if (r) return r;
     if (IS_NOT_NULL(qn->next_head_exact) && !CKN_ON) {
       if (IS_MULTILINE(reg->options))
-	r = add_opcode(reg, OP_ANYCHAR_ML_STAR_PEEK_NEXT);
+        r = add_opcode(reg, OP_ANYCHAR_ML_STAR_PEEK_NEXT);
       else
-	r = add_opcode(reg, OP_ANYCHAR_STAR_PEEK_NEXT);
+        r = add_opcode(reg, OP_ANYCHAR_STAR_PEEK_NEXT);
       if (r) return r;
       if (CKN_ON) {
-	r = add_state_check_num(reg, ckn);
-	if (r) return r;
+        r = add_state_check_num(reg, ckn);
+        if (r) return r;
       }
 
       return add_bytes(reg, NSTR(qn->next_head_exact)->s, 1);
     }
     else {
       if (IS_MULTILINE(reg->options)) {
-	r = add_opcode(reg, (CKN_ON ?
-			       OP_STATE_CHECK_ANYCHAR_ML_STAR
-			     : OP_ANYCHAR_ML_STAR));
+        r = add_opcode(reg, (CKN_ON ?
+                               OP_STATE_CHECK_ANYCHAR_ML_STAR
+                             : OP_ANYCHAR_ML_STAR));
       }
       else {
-	r = add_opcode(reg, (CKN_ON ?
-			       OP_STATE_CHECK_ANYCHAR_STAR
-			     : OP_ANYCHAR_STAR));
+        r = add_opcode(reg, (CKN_ON ?
+                               OP_STATE_CHECK_ANYCHAR_STAR
+                             : OP_ANYCHAR_STAR));
       }
       if (r) return r;
       if (CKN_ON)
-	r = add_state_check_num(reg, ckn);
+        r = add_state_check_num(reg, ckn);
 
       return r;
     }
@@ -867,45 +867,45 @@ compile_quantifier_node(QtfrNode* qn, regex_t* reg)
   if (infinite && qn->lower <= 1) {
     if (qn->greedy) {
       if (qn->lower == 1) {
-	r = add_opcode_rel_addr(reg, OP_JUMP,
-			(CKN_ON ? SIZE_OP_STATE_CHECK_PUSH : SIZE_OP_PUSH));
-	if (r) return r;
+        r = add_opcode_rel_addr(reg, OP_JUMP,
+                        (CKN_ON ? SIZE_OP_STATE_CHECK_PUSH : SIZE_OP_PUSH));
+        if (r) return r;
       }
 
       if (CKN_ON) {
-	r = add_opcode(reg, OP_STATE_CHECK_PUSH);
-	if (r) return r;
-	r = add_state_check_num(reg, ckn);
-	if (r) return r;
-	r = add_rel_addr(reg, mod_tlen + SIZE_OP_JUMP);
+        r = add_opcode(reg, OP_STATE_CHECK_PUSH);
+        if (r) return r;
+        r = add_state_check_num(reg, ckn);
+        if (r) return r;
+        r = add_rel_addr(reg, mod_tlen + SIZE_OP_JUMP);
       }
       else {
-	r = add_opcode_rel_addr(reg, OP_PUSH, mod_tlen + SIZE_OP_JUMP);
+        r = add_opcode_rel_addr(reg, OP_PUSH, mod_tlen + SIZE_OP_JUMP);
       }
       if (r) return r;
       r = compile_tree_empty_check(qn->target, reg, empty_info);
       if (r) return r;
       r = add_opcode_rel_addr(reg, OP_JUMP,
-	      -(mod_tlen + (int )SIZE_OP_JUMP
-		+ (int )(CKN_ON ? SIZE_OP_STATE_CHECK_PUSH : SIZE_OP_PUSH)));
+              -(mod_tlen + (int )SIZE_OP_JUMP
+                + (int )(CKN_ON ? SIZE_OP_STATE_CHECK_PUSH : SIZE_OP_PUSH)));
     }
     else {
       if (qn->lower == 0) {
-	r = add_opcode_rel_addr(reg, OP_JUMP, mod_tlen);
-	if (r) return r;
+        r = add_opcode_rel_addr(reg, OP_JUMP, mod_tlen);
+        if (r) return r;
       }
       r = compile_tree_empty_check(qn->target, reg, empty_info);
       if (r) return r;
       if (CKN_ON) {
-	r = add_opcode(reg, OP_STATE_CHECK_PUSH_OR_JUMP);
-	if (r) return r;
-	r = add_state_check_num(reg, ckn);
-	if (r) return r;
-	r = add_rel_addr(reg,
-		 -(mod_tlen + (int )SIZE_OP_STATE_CHECK_PUSH_OR_JUMP));
+        r = add_opcode(reg, OP_STATE_CHECK_PUSH_OR_JUMP);
+        if (r) return r;
+        r = add_state_check_num(reg, ckn);
+        if (r) return r;
+        r = add_rel_addr(reg,
+                 -(mod_tlen + (int )SIZE_OP_STATE_CHECK_PUSH_OR_JUMP));
       }
       else
-	r = add_opcode_rel_addr(reg, OP_PUSH, -(mod_tlen + (int )SIZE_OP_PUSH));
+        r = add_opcode_rel_addr(reg, OP_PUSH, -(mod_tlen + (int )SIZE_OP_PUSH));
     }
   }
   else if (qn->upper == 0) {
@@ -920,14 +920,14 @@ compile_quantifier_node(QtfrNode* qn, regex_t* reg)
   else if (qn->upper == 1 && qn->greedy) {
     if (qn->lower == 0) {
       if (CKN_ON) {
-	r = add_opcode(reg, OP_STATE_CHECK_PUSH);
-	if (r) return r;
-	r = add_state_check_num(reg, ckn);
-	if (r) return r;
-	r = add_rel_addr(reg, tlen);
+        r = add_opcode(reg, OP_STATE_CHECK_PUSH);
+        if (r) return r;
+        r = add_state_check_num(reg, ckn);
+        if (r) return r;
+        r = add_rel_addr(reg, tlen);
       }
       else {
-	r = add_opcode_rel_addr(reg, OP_PUSH, tlen);
+        r = add_opcode_rel_addr(reg, OP_PUSH, tlen);
       }
       if (r) return r;
     }
@@ -1001,11 +1001,11 @@ compile_length_quantifier_node(QtfrNode* qn, regex_t* reg)
 
     if (qn->greedy) {
       if (IS_NOT_NULL(qn->head_exact))
-	len += SIZE_OP_PUSH_OR_JUMP_EXACT1 + mod_tlen + SIZE_OP_JUMP;
+        len += SIZE_OP_PUSH_OR_JUMP_EXACT1 + mod_tlen + SIZE_OP_JUMP;
       else if (IS_NOT_NULL(qn->next_head_exact))
-	len += SIZE_OP_PUSH_IF_PEEK_NEXT + mod_tlen + SIZE_OP_JUMP;
+        len += SIZE_OP_PUSH_IF_PEEK_NEXT + mod_tlen + SIZE_OP_JUMP;
       else
-	len += SIZE_OP_PUSH + mod_tlen + SIZE_OP_JUMP;
+        len += SIZE_OP_PUSH + mod_tlen + SIZE_OP_JUMP;
     }
     else
       len += SIZE_OP_JUMP + mod_tlen + SIZE_OP_PUSH;
@@ -1045,17 +1045,17 @@ compile_quantifier_node(QtfrNode* qn, regex_t* reg)
     if (r) return r;
     if (IS_NOT_NULL(qn->next_head_exact)) {
       if (IS_MULTILINE(reg->options))
-	r = add_opcode(reg, OP_ANYCHAR_ML_STAR_PEEK_NEXT);
+        r = add_opcode(reg, OP_ANYCHAR_ML_STAR_PEEK_NEXT);
       else
-	r = add_opcode(reg, OP_ANYCHAR_STAR_PEEK_NEXT);
+        r = add_opcode(reg, OP_ANYCHAR_STAR_PEEK_NEXT);
       if (r) return r;
       return add_bytes(reg, NSTR(qn->next_head_exact)->s, 1);
     }
     else {
       if (IS_MULTILINE(reg->options))
-	return add_opcode(reg, OP_ANYCHAR_ML_STAR);
+        return add_opcode(reg, OP_ANYCHAR_ML_STAR);
       else
-	return add_opcode(reg, OP_ANYCHAR_STAR);
+        return add_opcode(reg, OP_ANYCHAR_STAR);
     }
   }
 
@@ -1068,15 +1068,15 @@ compile_quantifier_node(QtfrNode* qn, regex_t* reg)
       (qn->lower <= 1 || tlen * qn->lower <= QUANTIFIER_EXPAND_LIMIT_SIZE)) {
     if (qn->lower == 1 && tlen > QUANTIFIER_EXPAND_LIMIT_SIZE) {
       if (qn->greedy) {
-	if (IS_NOT_NULL(qn->head_exact))
-	  r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH_OR_JUMP_EXACT1);
-	else if (IS_NOT_NULL(qn->next_head_exact))
-	  r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH_IF_PEEK_NEXT);
-	else
-	  r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH);
+        if (IS_NOT_NULL(qn->head_exact))
+          r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH_OR_JUMP_EXACT1);
+        else if (IS_NOT_NULL(qn->next_head_exact))
+          r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH_IF_PEEK_NEXT);
+        else
+          r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH);
       }
       else {
-	r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_JUMP);
+        r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_JUMP);
       }
       if (r) return r;
     }
@@ -1087,32 +1087,32 @@ compile_quantifier_node(QtfrNode* qn, regex_t* reg)
 
     if (qn->greedy) {
       if (IS_NOT_NULL(qn->head_exact)) {
-	r = add_opcode_rel_addr(reg, OP_PUSH_OR_JUMP_EXACT1,
-			     mod_tlen + SIZE_OP_JUMP);
-	if (r) return r;
-	add_bytes(reg, NSTR(qn->head_exact)->s, 1);
-	r = compile_tree_empty_check(qn->target, reg, empty_info);
-	if (r) return r;
-	r = add_opcode_rel_addr(reg, OP_JUMP,
-	-(mod_tlen + (int )SIZE_OP_JUMP + (int )SIZE_OP_PUSH_OR_JUMP_EXACT1));
+        r = add_opcode_rel_addr(reg, OP_PUSH_OR_JUMP_EXACT1,
+                             mod_tlen + SIZE_OP_JUMP);
+        if (r) return r;
+        add_bytes(reg, NSTR(qn->head_exact)->s, 1);
+        r = compile_tree_empty_check(qn->target, reg, empty_info);
+        if (r) return r;
+        r = add_opcode_rel_addr(reg, OP_JUMP,
+        -(mod_tlen + (int )SIZE_OP_JUMP + (int )SIZE_OP_PUSH_OR_JUMP_EXACT1));
       }
       else if (IS_NOT_NULL(qn->next_head_exact)) {
-	r = add_opcode_rel_addr(reg, OP_PUSH_IF_PEEK_NEXT,
-				mod_tlen + SIZE_OP_JUMP);
-	if (r) return r;
-	add_bytes(reg, NSTR(qn->next_head_exact)->s, 1);
-	r = compile_tree_empty_check(qn->target, reg, empty_info);
-	if (r) return r;
-	r = add_opcode_rel_addr(reg, OP_JUMP,
+        r = add_opcode_rel_addr(reg, OP_PUSH_IF_PEEK_NEXT,
+                                mod_tlen + SIZE_OP_JUMP);
+        if (r) return r;
+        add_bytes(reg, NSTR(qn->next_head_exact)->s, 1);
+        r = compile_tree_empty_check(qn->target, reg, empty_info);
+        if (r) return r;
+        r = add_opcode_rel_addr(reg, OP_JUMP,
           -(mod_tlen + (int )SIZE_OP_JUMP + (int )SIZE_OP_PUSH_IF_PEEK_NEXT));
       }
       else {
-	r = add_opcode_rel_addr(reg, OP_PUSH, mod_tlen + SIZE_OP_JUMP);
-	if (r) return r;
-	r = compile_tree_empty_check(qn->target, reg, empty_info);
-	if (r) return r;
-	r = add_opcode_rel_addr(reg, OP_JUMP,
-		     -(mod_tlen + (int )SIZE_OP_JUMP + (int )SIZE_OP_PUSH));
+        r = add_opcode_rel_addr(reg, OP_PUSH, mod_tlen + SIZE_OP_JUMP);
+        if (r) return r;
+        r = compile_tree_empty_check(qn->target, reg, empty_info);
+        if (r) return r;
+        r = add_opcode_rel_addr(reg, OP_JUMP,
+                     -(mod_tlen + (int )SIZE_OP_JUMP + (int )SIZE_OP_PUSH));
       }
     }
     else {
@@ -1138,7 +1138,7 @@ compile_quantifier_node(QtfrNode* qn, regex_t* reg)
 
     for (i = 0; i < n; i++) {
       r = add_opcode_rel_addr(reg, OP_PUSH,
-			   (n - i) * tlen + (n - i - 1) * SIZE_OP_PUSH);
+                           (n - i) * tlen + (n - i - 1) * SIZE_OP_PUSH);
       if (r) return r;
       r = compile_tree(qn->target, reg);
       if (r) return r;
@@ -1225,24 +1225,24 @@ compile_length_enclose_node(EncloseNode* node, regex_t* reg)
 #ifdef USE_SUBEXP_CALL
     if (IS_ENCLOSE_CALLED(node)) {
       len = SIZE_OP_MEMORY_START_PUSH + tlen
-	  + SIZE_OP_CALL + SIZE_OP_JUMP + SIZE_OP_RETURN;
+          + SIZE_OP_CALL + SIZE_OP_JUMP + SIZE_OP_RETURN;
       if (BIT_STATUS_AT(reg->bt_mem_end, node->regnum))
-	len += (IS_ENCLOSE_RECURSION(node)
-		? SIZE_OP_MEMORY_END_PUSH_REC : SIZE_OP_MEMORY_END_PUSH);
+        len += (IS_ENCLOSE_RECURSION(node)
+                ? SIZE_OP_MEMORY_END_PUSH_REC : SIZE_OP_MEMORY_END_PUSH);
       else
-	len += (IS_ENCLOSE_RECURSION(node)
-		? SIZE_OP_MEMORY_END_REC : SIZE_OP_MEMORY_END);
+        len += (IS_ENCLOSE_RECURSION(node)
+                ? SIZE_OP_MEMORY_END_REC : SIZE_OP_MEMORY_END);
     }
     else
 #endif
     {
       if (BIT_STATUS_AT(reg->bt_mem_start, node->regnum))
-	len = SIZE_OP_MEMORY_START_PUSH;
+        len = SIZE_OP_MEMORY_START_PUSH;
       else
-	len = SIZE_OP_MEMORY_START;
+        len = SIZE_OP_MEMORY_START;
 
       len += tlen + (BIT_STATUS_AT(reg->bt_mem_end, node->regnum)
-		     ? SIZE_OP_MEMORY_END_PUSH : SIZE_OP_MEMORY_END);
+                     ? SIZE_OP_MEMORY_END_PUSH : SIZE_OP_MEMORY_END);
     }
     break;
 
@@ -1253,7 +1253,7 @@ compile_length_enclose_node(EncloseNode* node, regex_t* reg)
       if (tlen < 0) return tlen;
 
       len = tlen * qn->lower
-	  + SIZE_OP_PUSH + tlen + SIZE_OP_POP + SIZE_OP_JUMP;
+          + SIZE_OP_PUSH + tlen + SIZE_OP_POP + SIZE_OP_JUMP;
     }
     else {
       len = SIZE_OP_PUSH_STOP_BT + tlen + SIZE_OP_POP_STOP_BT;
@@ -1291,11 +1291,11 @@ compile_enclose_node(EncloseNode* node, regex_t* reg)
       len = compile_length_tree(node->target, reg);
       len += (SIZE_OP_MEMORY_START_PUSH + SIZE_OP_RETURN);
       if (BIT_STATUS_AT(reg->bt_mem_end, node->regnum))
-	len += (IS_ENCLOSE_RECURSION(node)
-		? SIZE_OP_MEMORY_END_PUSH_REC : SIZE_OP_MEMORY_END_PUSH);
+        len += (IS_ENCLOSE_RECURSION(node)
+                ? SIZE_OP_MEMORY_END_PUSH_REC : SIZE_OP_MEMORY_END_PUSH);
       else
-	len += (IS_ENCLOSE_RECURSION(node)
-		? SIZE_OP_MEMORY_END_REC : SIZE_OP_MEMORY_END);
+        len += (IS_ENCLOSE_RECURSION(node)
+                ? SIZE_OP_MEMORY_END_REC : SIZE_OP_MEMORY_END);
 
       r = add_opcode_rel_addr(reg, OP_JUMP, len);
       if (r) return r;
@@ -1313,11 +1313,11 @@ compile_enclose_node(EncloseNode* node, regex_t* reg)
 #ifdef USE_SUBEXP_CALL
     if (IS_ENCLOSE_CALLED(node)) {
       if (BIT_STATUS_AT(reg->bt_mem_end, node->regnum))
-	r = add_opcode(reg, (IS_ENCLOSE_RECURSION(node)
-			     ? OP_MEMORY_END_PUSH_REC : OP_MEMORY_END_PUSH));
+        r = add_opcode(reg, (IS_ENCLOSE_RECURSION(node)
+                             ? OP_MEMORY_END_PUSH_REC : OP_MEMORY_END_PUSH));
       else
-	r = add_opcode(reg, (IS_ENCLOSE_RECURSION(node)
-			     ? OP_MEMORY_END_REC : OP_MEMORY_END));
+        r = add_opcode(reg, (IS_ENCLOSE_RECURSION(node)
+                             ? OP_MEMORY_END_REC : OP_MEMORY_END));
 
       if (r) return r;
       r = add_mem_num(reg, node->regnum);
@@ -1328,9 +1328,9 @@ compile_enclose_node(EncloseNode* node, regex_t* reg)
 #endif
     {
       if (BIT_STATUS_AT(reg->bt_mem_end, node->regnum))
-	r = add_opcode(reg, OP_MEMORY_END_PUSH);
+        r = add_opcode(reg, OP_MEMORY_END_PUSH);
       else
-	r = add_opcode(reg, OP_MEMORY_END);
+        r = add_opcode(reg, OP_MEMORY_END);
       if (r) return r;
       r = add_mem_num(reg, node->regnum);
     }
@@ -1352,7 +1352,7 @@ compile_enclose_node(EncloseNode* node, regex_t* reg)
       r = add_opcode(reg, OP_POP);
       if (r) return r;
       r = add_opcode_rel_addr(reg, OP_JUMP,
-	 -((int )SIZE_OP_PUSH + len + (int )SIZE_OP_POP + (int )SIZE_OP_JUMP));
+         -((int )SIZE_OP_PUSH + len + (int )SIZE_OP_POP + (int )SIZE_OP_JUMP));
     }
     else {
       r = add_opcode(reg, OP_PUSH_STOP_BT);
@@ -1448,11 +1448,11 @@ compile_anchor_node(AnchorNode* node, regex_t* reg)
       r = add_opcode(reg, OP_LOOK_BEHIND);
       if (r) return r;
       if (node->char_len < 0) {
-	r = get_char_length_tree(node->target, reg, &n);
-	if (r) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
+        r = get_char_length_tree(node->target, reg, &n);
+        if (r) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
       }
       else
-	n = node->char_len;
+        n = node->char_len;
       r = add_length(reg, n);
       if (r) return r;
       r = compile_tree(node->target, reg);
@@ -1464,14 +1464,14 @@ compile_anchor_node(AnchorNode* node, regex_t* reg)
       int n;
       len = compile_length_tree(node->target, reg);
       r = add_opcode_rel_addr(reg, OP_PUSH_LOOK_BEHIND_NOT,
-			   len + SIZE_OP_FAIL_LOOK_BEHIND_NOT);
+                           len + SIZE_OP_FAIL_LOOK_BEHIND_NOT);
       if (r) return r;
       if (node->char_len < 0) {
-	r = get_char_length_tree(node->target, reg, &n);
-	if (r) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
+        r = get_char_length_tree(node->target, reg, &n);
+        if (r) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
       }
       else
-	n = node->char_len;
+        n = node->char_len;
       r = add_length(reg, n);
       if (r) return r;
       r = compile_tree(node->target, reg);
@@ -1511,8 +1511,8 @@ compile_length_tree(Node* node, regex_t* reg)
 
       n = r = 0;
       do {
-	r += compile_length_tree(NCAR(node), reg);
-	n++;
+        r += compile_length_tree(NCAR(node), reg);
+        n++;
       } while (IS_NOT_NULL(node = NCDR(node)));
       r += (SIZE_OP_PUSH + SIZE_OP_JUMP) * (n - 1);
     }
@@ -1546,11 +1546,11 @@ compile_length_tree(Node* node, regex_t* reg)
       else
 #endif
       if (br->back_num == 1) {
-	r = ((!IS_IGNORECASE(reg->options) && br->back_static[0] <= 2)
-	     ? SIZE_OPCODE : (SIZE_OPCODE + SIZE_MEMNUM));
+        r = ((!IS_IGNORECASE(reg->options) && br->back_static[0] <= 2)
+             ? SIZE_OPCODE : (SIZE_OPCODE + SIZE_MEMNUM));
       }
       else {
-	r = SIZE_OPCODE + SIZE_LENGTH + (SIZE_MEMNUM * br->back_num);
+        r = SIZE_OPCODE + SIZE_LENGTH + (SIZE_MEMNUM * br->back_num);
       }
     }
     break;
@@ -1599,26 +1599,26 @@ compile_tree(Node* node, regex_t* reg)
       Node* x = node;
       len = 0;
       do {
-	len += compile_length_tree(NCAR(x), reg);
-	if (NCDR(x) != NULL) {
-	  len += SIZE_OP_PUSH + SIZE_OP_JUMP;
-	}
+        len += compile_length_tree(NCAR(x), reg);
+        if (NCDR(x) != NULL) {
+          len += SIZE_OP_PUSH + SIZE_OP_JUMP;
+        }
       } while (IS_NOT_NULL(x = NCDR(x)));
       pos = reg->used + len;  /* goal position */
 
       do {
-	len = compile_length_tree(NCAR(node), reg);
-	if (IS_NOT_NULL(NCDR(node))) {
-	  r = add_opcode_rel_addr(reg, OP_PUSH, len + SIZE_OP_JUMP);
-	  if (r) break;
-	}
-	r = compile_tree(NCAR(node), reg);
-	if (r) break;
-	if (IS_NOT_NULL(NCDR(node))) {
-	  len = pos - (reg->used + SIZE_OP_JUMP);
-	  r = add_opcode_rel_addr(reg, OP_JUMP, len);
-	  if (r) break;
-	}
+        len = compile_length_tree(NCAR(node), reg);
+        if (IS_NOT_NULL(NCDR(node))) {
+          r = add_opcode_rel_addr(reg, OP_PUSH, len + SIZE_OP_JUMP);
+          if (r) break;
+        }
+        r = compile_tree(NCAR(node), reg);
+        if (r) break;
+        if (IS_NOT_NULL(NCDR(node))) {
+          len = pos - (reg->used + SIZE_OP_JUMP);
+          r = add_opcode_rel_addr(reg, OP_JUMP, len);
+          if (r) break;
+        }
       } while (IS_NOT_NULL(node = NCDR(node)));
     }
     break;
@@ -1640,12 +1640,12 @@ compile_tree(Node* node, regex_t* reg)
 
       switch (NCTYPE(node)->ctype) {
       case ONIGENC_CTYPE_WORD:
-	if (NCTYPE(node)->not != 0)  op = OP_NOT_WORD;
-	else                         op = OP_WORD;
-	break;
+        if (NCTYPE(node)->not != 0)  op = OP_NOT_WORD;
+        else                         op = OP_WORD;
+        break;
       default:
-	return ONIGERR_TYPE_BUG;
-	break;
+        return ONIGERR_TYPE_BUG;
+        break;
       }
       r = add_opcode(reg, op);
     }
@@ -1664,39 +1664,39 @@ compile_tree(Node* node, regex_t* reg)
 
 #ifdef USE_BACKREF_WITH_LEVEL
       if (IS_BACKREF_NEST_LEVEL(br)) {
-	r = add_opcode(reg, OP_BACKREF_WITH_LEVEL);
-	if (r) return r;
-	r = add_option(reg, (reg->options & ONIG_OPTION_IGNORECASE));
-	if (r) return r;
-	r = add_length(reg, br->nest_level);
-	if (r) return r;
-
-	goto add_bacref_mems;
+        r = add_opcode(reg, OP_BACKREF_WITH_LEVEL);
+        if (r) return r;
+        r = add_option(reg, (reg->options & ONIG_OPTION_IGNORECASE));
+        if (r) return r;
+        r = add_length(reg, br->nest_level);
+        if (r) return r;
+
+        goto add_bacref_mems;
       }
       else
 #endif
       if (br->back_num == 1) {
-	n = br->back_static[0];
-	if (IS_IGNORECASE(reg->options)) {
-	  r = add_opcode(reg, OP_BACKREFN_IC);
-	  if (r) return r;
-	  r = add_mem_num(reg, n);
-	}
-	else {
-	  switch (n) {
-	  case 1:  r = add_opcode(reg, OP_BACKREF1); break;
-	  case 2:  r = add_opcode(reg, OP_BACKREF2); break;
-	  default:
-	    r = add_opcode(reg, OP_BACKREFN);
-	    if (r) return r;
-	    r = add_mem_num(reg, n);
-	    break;
-	  }
-	}
+        n = br->back_static[0];
+        if (IS_IGNORECASE(reg->options)) {
+          r = add_opcode(reg, OP_BACKREFN_IC);
+          if (r) return r;
+          r = add_mem_num(reg, n);
+        }
+        else {
+          switch (n) {
+          case 1:  r = add_opcode(reg, OP_BACKREF1); break;
+          case 2:  r = add_opcode(reg, OP_BACKREF2); break;
+          default:
+            r = add_opcode(reg, OP_BACKREFN);
+            if (r) return r;
+            r = add_mem_num(reg, n);
+            break;
+          }
+        }
       }
       else {
-	int i;
-	int* p;
+        int i;
+        int* p;
 
         if (IS_IGNORECASE(reg->options)) {
           r = add_opcode(reg, OP_BACKREF_MULTI_IC);
@@ -1704,18 +1704,18 @@ compile_tree(Node* node, regex_t* reg)
         else {
           r = add_opcode(reg, OP_BACKREF_MULTI);
         }
-	if (r) return r;
+        if (r) return r;
 
 #ifdef USE_BACKREF_WITH_LEVEL
       add_bacref_mems:
 #endif
-	r = add_length(reg, br->back_num);
-	if (r) return r;
-	p = BACKREFS_P(br);
-	for (i = br->back_num - 1; i >= 0; i--) {
-	  r = add_mem_num(reg, p[i]);
-	  if (r) return r;
-	}
+        r = add_length(reg, br->back_num);
+        if (r) return r;
+        p = BACKREFS_P(br);
+        for (i = br->back_num - 1; i >= 0; i--) {
+          r = add_mem_num(reg, p[i]);
+          if (r) return r;
+        }
       }
     }
     break;
@@ -1770,7 +1770,7 @@ noname_disable_map(Node** plink, GroupNumRemap* map, int* counter)
       Node*  old = *ptarget;
       r = noname_disable_map(ptarget, map, counter);
       if (*ptarget != old && NTYPE(*ptarget) == NT_QTFR) {
-	onig_reduce_nested_quantifier(node, *ptarget);
+        onig_reduce_nested_quantifier(node, *ptarget);
       }
     }
     break;
@@ -1779,21 +1779,21 @@ noname_disable_map(Node** plink, GroupNumRemap* map, int* counter)
     {
       EncloseNode* en = NENCLOSE(node);
       if (en->type == ENCLOSE_MEMORY) {
-	if (IS_ENCLOSE_NAMED_GROUP(en)) {
-	  (*counter)++;
-	  map[en->regnum].new_val = *counter;
-	  en->regnum = *counter;
-	  r = noname_disable_map(&(en->target), map, counter);
-	}
-	else {
-	  *plink = en->target;
-	  en->target = NULL_NODE;
-	  onig_node_free(node);
-	  r = noname_disable_map(plink, map, counter);
-	}
+        if (IS_ENCLOSE_NAMED_GROUP(en)) {
+          (*counter)++;
+          map[en->regnum].new_val = *counter;
+          en->regnum = *counter;
+          r = noname_disable_map(&(en->target), map, counter);
+        }
+        else {
+          *plink = en->target;
+          en->target = NULL_NODE;
+          onig_node_free(node);
+          r = noname_disable_map(plink, map, counter);
+        }
       }
       else
-	r = noname_disable_map(&(en->target), map, counter);
+        r = noname_disable_map(&(en->target), map, counter);
     }
     break;
 
@@ -1805,8 +1805,8 @@ noname_disable_map(Node** plink, GroupNumRemap* map, int* counter)
       case ANCHOR_PREC_READ_NOT:
       case ANCHOR_LOOK_BEHIND:
       case ANCHOR_LOOK_BEHIND_NOT:
-	r = noname_disable_map(&(an->target), map, counter);
-	break;
+        r = noname_disable_map(&(an->target), map, counter);
+        break;
       }
     }
     break;
@@ -1877,8 +1877,8 @@ renumber_by_map(Node* node, GroupNumRemap* map)
       case ANCHOR_PREC_READ_NOT:
       case ANCHOR_LOOK_BEHIND:
       case ANCHOR_LOOK_BEHIND_NOT:
-	r = renumber_by_map(an->target, map);
-	break;
+        r = renumber_by_map(an->target, map);
+        break;
       }
     }
     break;
@@ -1994,8 +1994,8 @@ quantifiers_memory_node_info(Node* node)
     {
       int v;
       do {
-	v = quantifiers_memory_node_info(NCAR(node));
-	if (v > r) r = v;
+        v = quantifiers_memory_node_info(NCAR(node));
+        if (v > r) r = v;
       } while (v >= 0 && IS_NOT_NULL(node = NCDR(node)));
     }
     break;
@@ -2014,7 +2014,7 @@ quantifiers_memory_node_info(Node* node)
     {
       QtfrNode* qn = NQTFR(node);
       if (qn->upper != 0) {
-	r = quantifiers_memory_node_info(qn->target);
+        r = quantifiers_memory_node_info(qn->target);
       }
     }
     break;
@@ -2024,15 +2024,15 @@ quantifiers_memory_node_info(Node* node)
       EncloseNode* en = NENCLOSE(node);
       switch (en->type) {
       case ENCLOSE_MEMORY:
-	return NQ_TARGET_IS_EMPTY_MEM;
-	break;
+        return NQ_TARGET_IS_EMPTY_MEM;
+        break;
 
       case ENCLOSE_OPTION:
       case ENCLOSE_STOP_BACKTRACK:
-	r = quantifiers_memory_node_info(en->target);
-	break;
+        r = quantifiers_memory_node_info(en->target);
+        break;
       default:
-	break;
+        break;
       }
     }
     break;
@@ -2072,10 +2072,10 @@ get_min_match_length(Node* node, OnigDistance *min, ScanEnv* env)
       r = get_min_match_length(nodes[backs[0]], min, env);
       if (r != 0) break;
       for (i = 1; i < br->back_num; i++) {
-	if (backs[i] > env->num_mem)  return ONIGERR_INVALID_BACKREF;
-	r = get_min_match_length(nodes[backs[i]], &tmin, env);
-	if (r != 0) break;
-	if (*min > tmin) *min = tmin;
+        if (backs[i] > env->num_mem)  return ONIGERR_INVALID_BACKREF;
+        r = get_min_match_length(nodes[backs[i]], &tmin, env);
+        if (r != 0) break;
+        if (*min > tmin) *min = tmin;
       }
     }
     break;
@@ -2085,7 +2085,7 @@ get_min_match_length(Node* node, OnigDistance *min, ScanEnv* env)
     if (IS_CALL_RECURSION(NCALL(node))) {
       EncloseNode* en = NENCLOSE(NCALL(node)->target);
       if (IS_ENCLOSE_MIN_FIXED(en))
-	*min = en->min_len;
+        *min = en->min_len;
     }
     else
       r = get_min_match_length(NCALL(node)->target, min, env);
@@ -2104,11 +2104,11 @@ get_min_match_length(Node* node, OnigDistance *min, ScanEnv* env)
       Node *x, *y;
       y = node;
       do {
-	x = NCAR(y);
-	r = get_min_match_length(x, &tmin, env);
-	if (r != 0) break;
-	if (y == node) *min = tmin;
-	else if (*min > tmin) *min = tmin;
+        x = NCAR(y);
+        r = get_min_match_length(x, &tmin, env);
+        if (r != 0) break;
+        if (y == node) *min = tmin;
+        else if (*min > tmin) *min = tmin;
       } while (r == 0 && IS_NOT_NULL(y = NCDR(y)));
     }
     break;
@@ -2134,9 +2134,9 @@ get_min_match_length(Node* node, OnigDistance *min, ScanEnv* env)
       QtfrNode* qn = NQTFR(node);
 
       if (qn->lower > 0) {
-	r = get_min_match_length(qn->target, min, env);
-	if (r == 0)
-	  *min = distance_multiply(*min, qn->lower);
+        r = get_min_match_length(qn->target, min, env);
+        if (r == 0)
+          *min = distance_multiply(*min, qn->lower);
       }
     }
     break;
@@ -2147,21 +2147,21 @@ get_min_match_length(Node* node, OnigDistance *min, ScanEnv* env)
       switch (en->type) {
       case ENCLOSE_MEMORY:
 #ifdef USE_SUBEXP_CALL
-	if (IS_ENCLOSE_MIN_FIXED(en))
-	  *min = en->min_len;
-	else {
-	  r = get_min_match_length(en->target, min, env);
-	  if (r == 0) {
-	    en->min_len = *min;
-	    SET_ENCLOSE_STATUS(node, NST_MIN_FIXED);
-	  }
-	}
-	break;
+        if (IS_ENCLOSE_MIN_FIXED(en))
+          *min = en->min_len;
+        else {
+          r = get_min_match_length(en->target, min, env);
+          if (r == 0) {
+            en->min_len = *min;
+            SET_ENCLOSE_STATUS(node, NST_MIN_FIXED);
+          }
+        }
+        break;
 #endif
       case ENCLOSE_OPTION:
       case ENCLOSE_STOP_BACKTRACK:
-	r = get_min_match_length(en->target, min, env);
-	break;
+        r = get_min_match_length(en->target, min, env);
+        break;
       }
     }
     break;
@@ -2186,7 +2186,7 @@ get_max_match_length(Node* node, OnigDistance *max, ScanEnv* env)
     do {
       r = get_max_match_length(NCAR(node), &tmax, env);
       if (r == 0)
-	*max = distance_add(*max, tmax);
+        *max = distance_add(*max, tmax);
     } while (r == 0 && IS_NOT_NULL(node = NCDR(node)));
     break;
 
@@ -2220,15 +2220,15 @@ get_max_match_length(Node* node, OnigDistance *max, ScanEnv* env)
       Node** nodes = SCANENV_MEM_NODES(env);
       BRefNode* br = NBREF(node);
       if (br->state & NST_RECURSION) {
-	*max = ONIG_INFINITE_DISTANCE;
-	break;
+        *max = ONIG_INFINITE_DISTANCE;
+        break;
       }
       backs = BACKREFS_P(br);
       for (i = 0; i < br->back_num; i++) {
-	if (backs[i] > env->num_mem)  return ONIGERR_INVALID_BACKREF;
-	r = get_max_match_length(nodes[backs[i]], &tmax, env);
-	if (r != 0) break;
-	if (*max < tmax) *max = tmax;
+        if (backs[i] > env->num_mem)  return ONIGERR_INVALID_BACKREF;
+        r = get_max_match_length(nodes[backs[i]], &tmax, env);
+        if (r != 0) break;
+        if (*max < tmax) *max = tmax;
       }
     }
     break;
@@ -2247,13 +2247,13 @@ get_max_match_length(Node* node, OnigDistance *max, ScanEnv* env)
       QtfrNode* qn = NQTFR(node);
 
       if (qn->upper != 0) {
-	r = get_max_match_length(qn->target, max, env);
-	if (r == 0 && *max != 0) {
-	  if (! IS_REPEAT_INFINITE(qn->upper))
-	    *max = distance_multiply(*max, qn->upper);
-	  else
-	    *max = ONIG_INFINITE_DISTANCE;
-	}
+        r = get_max_match_length(qn->target, max, env);
+        if (r == 0 && *max != 0) {
+          if (! IS_REPEAT_INFINITE(qn->upper))
+            *max = distance_multiply(*max, qn->upper);
+          else
+            *max = ONIG_INFINITE_DISTANCE;
+        }
       }
     }
     break;
@@ -2264,21 +2264,21 @@ get_max_match_length(Node* node, OnigDistance *max, ScanEnv* env)
       switch (en->type) {
       case ENCLOSE_MEMORY:
 #ifdef USE_SUBEXP_CALL
-	if (IS_ENCLOSE_MAX_FIXED(en))
-	  *max = en->max_len;
-	else {
-	  r = get_max_match_length(en->target, max, env);
-	  if (r == 0) {
-	    en->max_len = *max;
-	    SET_ENCLOSE_STATUS(node, NST_MAX_FIXED);
-	  }
-	}
-	break;
+        if (IS_ENCLOSE_MAX_FIXED(en))
+          *max = en->max_len;
+        else {
+          r = get_max_match_length(en->target, max, env);
+          if (r == 0) {
+            en->max_len = *max;
+            SET_ENCLOSE_STATUS(node, NST_MAX_FIXED);
+          }
+        }
+        break;
 #endif
       case ENCLOSE_OPTION:
       case ENCLOSE_STOP_BACKTRACK:
-	r = get_max_match_length(en->target, max, env);
-	break;
+        r = get_max_match_length(en->target, max, env);
+        break;
       }
     }
     break;
@@ -2308,7 +2308,7 @@ get_char_length_tree1(Node* node, regex_t* reg, int* len, int level)
     do {
       r = get_char_length_tree1(NCAR(node), reg, &tlen, level);
       if (r == 0)
-	*len = distance_add(*len, tlen);
+        *len = distance_add(*len, tlen);
     } while (r == 0 && IS_NOT_NULL(node = NCDR(node)));
     break;
 
@@ -2319,21 +2319,21 @@ get_char_length_tree1(Node* node, regex_t* reg, int* len, int level)
 
       r = get_char_length_tree1(NCAR(node), reg, &tlen, level);
       while (r == 0 && IS_NOT_NULL(node = NCDR(node))) {
-	r = get_char_length_tree1(NCAR(node), reg, &tlen2, level);
-	if (r == 0) {
-	  if (tlen != tlen2)
-	    varlen = 1;
-	}
+        r = get_char_length_tree1(NCAR(node), reg, &tlen2, level);
+        if (r == 0) {
+          if (tlen != tlen2)
+            varlen = 1;
+        }
       }
       if (r == 0) {
-	if (varlen != 0) {
-	  if (level == 1)
-	    r = GET_CHAR_LEN_TOP_ALT_VARLEN;
-	  else
-	    r = GET_CHAR_LEN_VARLEN;
-	}
-	else
-	  *len = tlen;
+        if (varlen != 0) {
+          if (level == 1)
+            r = GET_CHAR_LEN_TOP_ALT_VARLEN;
+          else
+            r = GET_CHAR_LEN_VARLEN;
+        }
+        else
+          *len = tlen;
       }
     }
     break;
@@ -2343,8 +2343,8 @@ get_char_length_tree1(Node* node, regex_t* reg, int* len, int level)
       StrNode* sn = NSTR(node);
       UChar *s = sn->s;
       while (s < sn->end) {
-	s += enclen(reg->enc, s, sn->end);
-	(*len)++;
+        s += enclen(reg->enc, s, sn->end);
+        (*len)++;
       }
     }
     break;
@@ -2353,12 +2353,12 @@ get_char_length_tree1(Node* node, regex_t* reg, int* len, int level)
     {
       QtfrNode* qn = NQTFR(node);
       if (qn->lower == qn->upper) {
-	r = get_char_length_tree1(qn->target, reg, &tlen, level);
-	if (r == 0)
-	  *len = distance_multiply(tlen, qn->lower);
+        r = get_char_length_tree1(qn->target, reg, &tlen, level);
+        if (r == 0)
+          *len = distance_multiply(tlen, qn->lower);
       }
       else
-	r = GET_CHAR_LEN_VARLEN;
+        r = GET_CHAR_LEN_VARLEN;
     }
     break;
 
@@ -2386,23 +2386,23 @@ get_char_length_tree1(Node* node, regex_t* reg, int* len, int level)
       switch (en->type) {
       case ENCLOSE_MEMORY:
 #ifdef USE_SUBEXP_CALL
-	if (IS_ENCLOSE_CLEN_FIXED(en))
-	  *len = en->char_len;
-	else {
-	  r = get_char_length_tree1(en->target, reg, len, level);
-	  if (r == 0) {
-	    en->char_len = *len;
-	    SET_ENCLOSE_STATUS(node, NST_CLEN_FIXED);
-	  }
-	}
-	break;
+        if (IS_ENCLOSE_CLEN_FIXED(en))
+          *len = en->char_len;
+        else {
+          r = get_char_length_tree1(en->target, reg, len, level);
+          if (r == 0) {
+            en->char_len = *len;
+            SET_ENCLOSE_STATUS(node, NST_CLEN_FIXED);
+          }
+        }
+        break;
 #endif
       case ENCLOSE_OPTION:
       case ENCLOSE_STOP_BACKTRACK:
-	r = get_char_length_tree1(en->target, reg, len, level);
-	break;
+        r = get_char_length_tree1(en->target, reg, len, level);
+        break;
       default:
-	break;
+        break;
       }
     }
     break;
@@ -2440,28 +2440,28 @@ is_not_included(Node* x, Node* y, regex_t* reg)
     {
       switch (ytype) {
       case NT_CTYPE:
-	if (NCTYPE(y)->ctype == NCTYPE(x)->ctype &&
-	    NCTYPE(y)->not   != NCTYPE(x)->not)
-	  return 1;
-	else
-	  return 0;
-	break;
+        if (NCTYPE(y)->ctype == NCTYPE(x)->ctype &&
+            NCTYPE(y)->not   != NCTYPE(x)->not)
+          return 1;
+        else
+          return 0;
+        break;
 
       case NT_CCLASS:
       swap:
-	{
-	  Node* tmp;
-	  tmp = x; x = y; y = tmp;
-	  goto retry;
-	}
-	break;
+        {
+          Node* tmp;
+          tmp = x; x = y; y = tmp;
+          goto retry;
+        }
+        break;
 
       case NT_STR:
-	goto swap;
-	break;
+        goto swap;
+        break;
 
       default:
-	break;
+        break;
       }
     }
     break;
@@ -2471,69 +2471,69 @@ is_not_included(Node* x, Node* y, regex_t* reg)
       CClassNode* xc = NCCLASS(x);
       switch (ytype) {
       case NT_CTYPE:
-	switch (NCTYPE(y)->ctype) {
-	case ONIGENC_CTYPE_WORD:
-	  if (NCTYPE(y)->not == 0) {
-	    if (IS_NULL(xc->mbuf) && !IS_NCCLASS_NOT(xc)) {
-	      for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
-		if (BITSET_AT(xc->bs, i)) {
-		  if (IS_CODE_SB_WORD(reg->enc, i)) return 0;
-		}
-	      }
-	      return 1;
-	    }
-	    return 0;
-	  }
-	  else {
-	    for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
-	      if (! IS_CODE_SB_WORD(reg->enc, i)) {
-		if (!IS_NCCLASS_NOT(xc)) {
-		  if (BITSET_AT(xc->bs, i))
-		    return 0;
-		}
-		else {
-		  if (! BITSET_AT(xc->bs, i))
-		    return 0;
-		}
-	      }
-	    }
-	    return 1;
-	  }
-	  break;
-
-	default:
-	  break;
-	}
-	break;
+        switch (NCTYPE(y)->ctype) {
+        case ONIGENC_CTYPE_WORD:
+          if (NCTYPE(y)->not == 0) {
+            if (IS_NULL(xc->mbuf) && !IS_NCCLASS_NOT(xc)) {
+              for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
+                if (BITSET_AT(xc->bs, i)) {
+                  if (IS_CODE_SB_WORD(reg->enc, i)) return 0;
+                }
+              }
+              return 1;
+            }
+            return 0;
+          }
+          else {
+            for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
+              if (! IS_CODE_SB_WORD(reg->enc, i)) {
+                if (!IS_NCCLASS_NOT(xc)) {
+                  if (BITSET_AT(xc->bs, i))
+                    return 0;
+                }
+                else {
+                  if (! BITSET_AT(xc->bs, i))
+                    return 0;
+                }
+              }
+            }
+            return 1;
+          }
+          break;
+
+        default:
+          break;
+        }
+        break;
 
       case NT_CCLASS:
-	{
-	  int v;
-	  CClassNode* yc = NCCLASS(y);
+        {
+          int v;
+          CClassNode* yc = NCCLASS(y);
 
-	  for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
-	    v = BITSET_AT(xc->bs, i);
-	    if ((v != 0 && !IS_NCCLASS_NOT(xc)) ||
+          for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
+            v = BITSET_AT(xc->bs, i);
+            if ((v != 0 && !IS_NCCLASS_NOT(xc)) ||
                 (v == 0 && IS_NCCLASS_NOT(xc))) {
-	      v = BITSET_AT(yc->bs, i);
-	      if ((v != 0 && !IS_NCCLASS_NOT(yc)) ||
+              v = BITSET_AT(yc->bs, i);
+              if ((v != 0 && !IS_NCCLASS_NOT(yc)) ||
                   (v == 0 && IS_NCCLASS_NOT(yc)))
-		return 0;
-	    }
-	  }
-	  if ((IS_NULL(xc->mbuf) && !IS_NCCLASS_NOT(xc)) ||
-	      (IS_NULL(yc->mbuf) && !IS_NCCLASS_NOT(yc)))
-	    return 1;
-	  return 0;
-	}
-	break;
+                return 0;
+            }
+          }
+          if ((IS_NULL(xc->mbuf) && !IS_NCCLASS_NOT(xc)) ||
+              (IS_NULL(yc->mbuf) && !IS_NCCLASS_NOT(yc)))
+            return 1;
+          return 0;
+        }
+        break;
 
       case NT_STR:
-	goto swap;
-	break;
+        goto swap;
+        break;
 
       default:
-	break;
+        break;
       }
     }
     break;
@@ -2542,53 +2542,53 @@ is_not_included(Node* x, Node* y, regex_t* reg)
     {
       StrNode* xs = NSTR(x);
       if (NSTRING_LEN(x) == 0)
-	break;
+        break;
 
       c = *(xs->s);
       switch (ytype) {
       case NT_CTYPE:
-	switch (NCTYPE(y)->ctype) {
-	case ONIGENC_CTYPE_WORD:
-	  if (ONIGENC_IS_MBC_WORD(reg->enc, xs->s, xs->end))
-	    return NCTYPE(y)->not;
-	  else
-	    return !(NCTYPE(y)->not);
-	  break;
-	default:
-	  break;
-	}
-	break;
+        switch (NCTYPE(y)->ctype) {
+        case ONIGENC_CTYPE_WORD:
+          if (ONIGENC_IS_MBC_WORD(reg->enc, xs->s, xs->end))
+            return NCTYPE(y)->not;
+          else
+            return !(NCTYPE(y)->not);
+          break;
+        default:
+          break;
+        }
+        break;
 
       case NT_CCLASS:
-	{
-	  CClassNode* cc = NCCLASS(y);
+        {
+          CClassNode* cc = NCCLASS(y);
 
-	  code = ONIGENC_MBC_TO_CODE(reg->enc, xs->s,
-				     xs->s + ONIGENC_MBC_MAXLEN(reg->enc));
-	  return (onig_is_code_in_cc(reg->enc, code, cc) != 0 ? 0 : 1);
-	}
-	break;
+          code = ONIGENC_MBC_TO_CODE(reg->enc, xs->s,
+                                     xs->s + ONIGENC_MBC_MAXLEN(reg->enc));
+          return (onig_is_code_in_cc(reg->enc, code, cc) != 0 ? 0 : 1);
+        }
+        break;
 
       case NT_STR:
-	{
-	  UChar *q;
-	  StrNode* ys = NSTR(y);
-	  len = NSTRING_LEN(x);
-	  if (len > NSTRING_LEN(y)) len = NSTRING_LEN(y);
-	  if (NSTRING_IS_AMBIG(x) || NSTRING_IS_AMBIG(y)) {
+        {
+          UChar *q;
+          StrNode* ys = NSTR(y);
+          len = NSTRING_LEN(x);
+          if (len > NSTRING_LEN(y)) len = NSTRING_LEN(y);
+          if (NSTRING_IS_AMBIG(x) || NSTRING_IS_AMBIG(y)) {
             /* tiny version */
             return 0;
-	  }
-	  else {
-	    for (i = 0, p = ys->s, q = xs->s; i < len; i++, p++, q++) {
-	      if (*p != *q) return 1;
-	    }
-	  }
-	}
-	break;
+          }
+          else {
+            for (i = 0, p = ys->s, q = xs->s; i < len; i++, p++, q++) {
+              if (*p != *q) return 1;
+            }
+          }
+        }
+        break;
 
       default:
-	break;
+        break;
       }
     }
     break;
@@ -2630,13 +2630,13 @@ get_head_value_node(Node* node, int exact, regex_t* reg)
       StrNode* sn = NSTR(node);
 
       if (sn->end <= sn->s)
-	break;
+        break;
 
       if (exact != 0 &&
-	  !NSTRING_IS_RAW(node) && IS_IGNORECASE(reg->options)) {
+          !NSTRING_IS_RAW(node) && IS_IGNORECASE(reg->options)) {
       }
       else {
-	n = node;
+        n = node;
       }
     }
     break;
@@ -2645,10 +2645,10 @@ get_head_value_node(Node* node, int exact, regex_t* reg)
     {
       QtfrNode* qn = NQTFR(node);
       if (qn->lower > 0) {
-	if (IS_NOT_NULL(qn->head_exact))
-	  n = qn->head_exact;
-	else
-	  n = get_head_value_node(qn->target, exact, reg);
+        if (IS_NOT_NULL(qn->head_exact))
+          n = qn->head_exact;
+        else
+          n = get_head_value_node(qn->target, exact, reg);
       }
     }
     break;
@@ -2658,19 +2658,19 @@ get_head_value_node(Node* node, int exact, regex_t* reg)
       EncloseNode* en = NENCLOSE(node);
       switch (en->type) {
       case ENCLOSE_OPTION:
-	{
-	  OnigOptionType options = reg->options;
+        {
+          OnigOptionType options = reg->options;
 
-	  reg->options = NENCLOSE(node)->option;
-	  n = get_head_value_node(NENCLOSE(node)->target, exact, reg);
-	  reg->options = options;
-	}
-	break;
+          reg->options = NENCLOSE(node)->option;
+          n = get_head_value_node(NENCLOSE(node)->target, exact, reg);
+          reg->options = options;
+        }
+        break;
 
       case ENCLOSE_MEMORY:
       case ENCLOSE_STOP_BACKTRACK:
-	n = get_head_value_node(en->target, exact, reg);
-	break;
+        n = get_head_value_node(en->target, exact, reg);
+        break;
       }
     }
     break;
@@ -2701,20 +2701,20 @@ check_type_tree(Node* node, int type_mask, int enclose_mask, int anchor_mask)
   case NT_ALT:
     do {
       r = check_type_tree(NCAR(node), type_mask, enclose_mask,
-			  anchor_mask);
+                          anchor_mask);
     } while (r == 0 && IS_NOT_NULL(node = NCDR(node)));
     break;
 
   case NT_QTFR:
     r = check_type_tree(NQTFR(node)->target, type_mask, enclose_mask,
-			anchor_mask);
+                        anchor_mask);
     break;
 
   case NT_ENCLOSE:
     {
       EncloseNode* en = NENCLOSE(node);
       if ((en->type & enclose_mask) == 0)
-	return 1;
+        return 1;
 
       r = check_type_tree(en->target, type_mask, enclose_mask, anchor_mask);
     }
@@ -2727,7 +2727,7 @@ check_type_tree(Node* node, int type_mask, int enclose_mask, int anchor_mask)
 
     if (NANCHOR(node)->target)
       r = check_type_tree(NANCHOR(node)->target,
-			  type_mask, enclose_mask, anchor_mask);
+                          type_mask, enclose_mask, anchor_mask);
     break;
 
   default:
@@ -2757,14 +2757,14 @@ subexp_inf_recursive_check(Node* node, ScanEnv* env, int head)
 
       x = node;
       do {
-	ret = subexp_inf_recursive_check(NCAR(x), env, head);
-	if (ret < 0 || ret == RECURSION_INFINITE) return ret;
-	r |= ret;
-	if (head) {
-	  ret = get_min_match_length(NCAR(x), &min, env);
-	  if (ret != 0) return ret;
-	  if (min != 0) head = 0;
-	}
+        ret = subexp_inf_recursive_check(NCAR(x), env, head);
+        if (ret < 0 || ret == RECURSION_INFINITE) return ret;
+        r |= ret;
+        if (head) {
+          ret = get_min_match_length(NCAR(x), &min, env);
+          if (ret != 0) return ret;
+          if (min != 0) head = 0;
+        }
       } while (IS_NOT_NULL(x = NCDR(x)));
     }
     break;
@@ -2774,9 +2774,9 @@ subexp_inf_recursive_check(Node* node, ScanEnv* env, int head)
       int ret;
       r = RECURSION_EXIST;
       do {
-	ret = subexp_inf_recursive_check(NCAR(node), env, head);
-	if (ret < 0 || ret == RECURSION_INFINITE) return ret;
-	r &= ret;
+        ret = subexp_inf_recursive_check(NCAR(node), env, head);
+        if (ret < 0 || ret == RECURSION_INFINITE) return ret;
+        r &= ret;
       } while (IS_NOT_NULL(node = NCDR(node)));
     }
     break;
@@ -2796,8 +2796,8 @@ subexp_inf_recursive_check(Node* node, ScanEnv* env, int head)
       case ANCHOR_PREC_READ_NOT:
       case ANCHOR_LOOK_BEHIND:
       case ANCHOR_LOOK_BEHIND_NOT:
-	r = subexp_inf_recursive_check(an->target, env, head);
-	break;
+        r = subexp_inf_recursive_check(an->target, env, head);
+        break;
       }
     }
     break;
@@ -2852,8 +2852,8 @@ subexp_inf_recursive_check_trav(Node* node, ScanEnv* env)
       case ANCHOR_PREC_READ_NOT:
       case ANCHOR_LOOK_BEHIND:
       case ANCHOR_LOOK_BEHIND_NOT:
-	r = subexp_inf_recursive_check_trav(an->target, env);
-	break;
+        r = subexp_inf_recursive_check_trav(an->target, env);
+        break;
       }
     }
     break;
@@ -2863,10 +2863,10 @@ subexp_inf_recursive_check_trav(Node* node, ScanEnv* env)
       EncloseNode* en = NENCLOSE(node);
 
       if (IS_ENCLOSE_RECURSION(en)) {
-	SET_ENCLOSE_STATUS(node, NST_MARK1);
-	r = subexp_inf_recursive_check(en->target, env, 1);
-	if (r > 0) return ONIGERR_NEVER_ENDING_RECURSION;
-	CLEAR_ENCLOSE_STATUS(node, NST_MARK1);
+        SET_ENCLOSE_STATUS(node, NST_MARK1);
+        r = subexp_inf_recursive_check(en->target, env, 1);
+        if (r > 0) return ONIGERR_NEVER_ENDING_RECURSION;
+        CLEAR_ENCLOSE_STATUS(node, NST_MARK1);
       }
       r = subexp_inf_recursive_check_trav(en->target, env);
     }
@@ -2905,8 +2905,8 @@ subexp_recursive_check(Node* node)
       case ANCHOR_PREC_READ_NOT:
       case ANCHOR_LOOK_BEHIND:
       case ANCHOR_LOOK_BEHIND_NOT:
-	r = subexp_recursive_check(an->target);
-	break;
+        r = subexp_recursive_check(an->target);
+        break;
       }
     }
     break;
@@ -2951,9 +2951,9 @@ subexp_recursive_check_trav(Node* node, ScanEnv* env)
     {
       int ret;
       do {
-	ret = subexp_recursive_check_trav(NCAR(node), env);
-	if (ret == FOUND_CALLED_NODE) r = FOUND_CALLED_NODE;
-	else if (ret < 0) return ret;
+        ret = subexp_recursive_check_trav(NCAR(node), env);
+        if (ret == FOUND_CALLED_NODE) r = FOUND_CALLED_NODE;
+        else if (ret < 0) return ret;
       } while (IS_NOT_NULL(node = NCDR(node)));
     }
     break;
@@ -2962,7 +2962,7 @@ subexp_recursive_check_trav(Node* node, ScanEnv* env)
     r = subexp_recursive_check_trav(NQTFR(node)->target, env);
     if (NQTFR(node)->upper == 0) {
       if (r == FOUND_CALLED_NODE)
-	NQTFR(node)->is_refered = 1;
+        NQTFR(node)->is_refered = 1;
     }
     break;
 
@@ -2974,8 +2974,8 @@ subexp_recursive_check_trav(Node* node, ScanEnv* env)
       case ANCHOR_PREC_READ_NOT:
       case ANCHOR_LOOK_BEHIND:
       case ANCHOR_LOOK_BEHIND_NOT:
-	r = subexp_recursive_check_trav(an->target, env);
-	break;
+        r = subexp_recursive_check_trav(an->target, env);
+        break;
       }
     }
     break;
@@ -2985,16 +2985,16 @@ subexp_recursive_check_trav(Node* node, ScanEnv* env)
       EncloseNode* en = NENCLOSE(node);
 
       if (! IS_ENCLOSE_RECURSION(en)) {
-	if (IS_ENCLOSE_CALLED(en)) {
-	  SET_ENCLOSE_STATUS(node, NST_MARK1);
-	  r = subexp_recursive_check(en->target);
-	  if (r != 0) SET_ENCLOSE_STATUS(node, NST_RECURSION);
-	  CLEAR_ENCLOSE_STATUS(node, NST_MARK1);
-	}
+        if (IS_ENCLOSE_CALLED(en)) {
+          SET_ENCLOSE_STATUS(node, NST_MARK1);
+          r = subexp_recursive_check(en->target);
+          if (r != 0) SET_ENCLOSE_STATUS(node, NST_RECURSION);
+          CLEAR_ENCLOSE_STATUS(node, NST_MARK1);
+        }
       }
       r = subexp_recursive_check_trav(en->target, env);
       if (IS_ENCLOSE_CALLED(en))
-	r |= FOUND_CALLED_NODE;
+        r |= FOUND_CALLED_NODE;
     }
     break;
 
@@ -3038,54 +3038,54 @@ setup_subexp_call(Node* node, ScanEnv* env)
       Node** nodes = SCANENV_MEM_NODES(env);
 
       if (cn->group_num != 0) {
-	int gnum = cn->group_num;
+        int gnum = cn->group_num;
 
 #ifdef USE_NAMED_GROUP
-	if (env->num_named > 0 &&
-	    IS_SYNTAX_BV(env->syntax, ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP) &&
-	    !ONIG_IS_OPTION_ON(env->option, ONIG_OPTION_CAPTURE_GROUP)) {
-	  return ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED;
-	}
+        if (env->num_named > 0 &&
+            IS_SYNTAX_BV(env->syntax, ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP) &&
+            !ONIG_IS_OPTION_ON(env->option, ONIG_OPTION_CAPTURE_GROUP)) {
+          return ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED;
+        }
 #endif
-	if (gnum > env->num_mem) {
-	  onig_scan_env_set_error_string(env,
-		 ONIGERR_UNDEFINED_GROUP_REFERENCE, cn->name, cn->name_end);
-	  return ONIGERR_UNDEFINED_GROUP_REFERENCE;
-	}
+        if (gnum > env->num_mem) {
+          onig_scan_env_set_error_string(env,
+                 ONIGERR_UNDEFINED_GROUP_REFERENCE, cn->name, cn->name_end);
+          return ONIGERR_UNDEFINED_GROUP_REFERENCE;
+        }
 
 #ifdef USE_NAMED_GROUP
       set_call_attr:
 #endif
-	cn->target = nodes[cn->group_num];
-	if (IS_NULL(cn->target)) {
-	  onig_scan_env_set_error_string(env,
-		 ONIGERR_UNDEFINED_NAME_REFERENCE, cn->name, cn->name_end);
-	  return ONIGERR_UNDEFINED_NAME_REFERENCE;
-	}
-	SET_ENCLOSE_STATUS(cn->target, NST_CALLED);
-	BIT_STATUS_ON_AT(env->bt_mem_start, cn->group_num);
-	cn->unset_addr_list = env->unset_addr_list;
+        cn->target = nodes[cn->group_num];
+        if (IS_NULL(cn->target)) {
+          onig_scan_env_set_error_string(env,
+                 ONIGERR_UNDEFINED_NAME_REFERENCE, cn->name, cn->name_end);
+          return ONIGERR_UNDEFINED_NAME_REFERENCE;
+        }
+        SET_ENCLOSE_STATUS(cn->target, NST_CALLED);
+        BIT_STATUS_ON_AT(env->bt_mem_start, cn->group_num);
+        cn->unset_addr_list = env->unset_addr_list;
       }
 #ifdef USE_NAMED_GROUP
       else {
-	int *refs;
-
-	int n = onig_name_to_group_numbers(env->reg, cn->name, cn->name_end,
-					   &refs);
-	if (n <= 0) {
-	  onig_scan_env_set_error_string(env,
-		 ONIGERR_UNDEFINED_NAME_REFERENCE, cn->name, cn->name_end);
-	  return ONIGERR_UNDEFINED_NAME_REFERENCE;
-	}
-	else if (n > 1) {
-	  onig_scan_env_set_error_string(env,
-	    ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL, cn->name, cn->name_end);
-	  return ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL;
-	}
-	else {
-	  cn->group_num = refs[0];
-	  goto set_call_attr;
-	}
+        int *refs;
+
+        int n = onig_name_to_group_numbers(env->reg, cn->name, cn->name_end,
+                                           &refs);
+        if (n <= 0) {
+          onig_scan_env_set_error_string(env,
+                 ONIGERR_UNDEFINED_NAME_REFERENCE, cn->name, cn->name_end);
+          return ONIGERR_UNDEFINED_NAME_REFERENCE;
+        }
+        else if (n > 1) {
+          onig_scan_env_set_error_string(env,
+            ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL, cn->name, cn->name_end);
+          return ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL;
+        }
+        else {
+          cn->group_num = refs[0];
+          goto set_call_attr;
+        }
       }
 #endif
     }
@@ -3100,8 +3100,8 @@ setup_subexp_call(Node* node, ScanEnv* env)
       case ANCHOR_PREC_READ_NOT:
       case ANCHOR_LOOK_BEHIND:
       case ANCHOR_LOOK_BEHIND_NOT:
-	r = setup_subexp_call(an->target, env);
-	break;
+        r = setup_subexp_call(an->target, env);
+        break;
       }
     }
     break;
@@ -3183,26 +3183,26 @@ next_setup(Node* node, Node* next_node, regex_t* reg)
       Node* n = get_head_value_node(next_node, 1, reg);
       /* '\0': for UTF-16BE etc... */
       if (IS_NOT_NULL(n) && NSTR(n)->s[0] != '\0') {
-	qn->next_head_exact = n;
+        qn->next_head_exact = n;
       }
 #endif
       /* automatic posseivation a*b ==> (?>a*)b */
       if (qn->lower <= 1) {
-	int ttype = NTYPE(qn->target);
-	if (IS_NODE_TYPE_SIMPLE(ttype)) {
-	  Node *x, *y;
-	  x = get_head_value_node(qn->target, 0, reg);
-	  if (IS_NOT_NULL(x)) {
-	    y = get_head_value_node(next_node,  0, reg);
-	    if (IS_NOT_NULL(y) && is_not_included(x, y, reg)) {
-	      Node* en = onig_node_new_enclose(ENCLOSE_STOP_BACKTRACK);
-	      CHECK_NULL_RETURN_MEMERR(en);
-	      SET_ENCLOSE_STATUS(en, NST_STOP_BT_SIMPLE_REPEAT);
-	      swap_node(node, en);
-	      NENCLOSE(node)->target = en;
-	    }
-	  }
-	}
+        int ttype = NTYPE(qn->target);
+        if (IS_NODE_TYPE_SIMPLE(ttype)) {
+          Node *x, *y;
+          x = get_head_value_node(qn->target, 0, reg);
+          if (IS_NOT_NULL(x)) {
+            y = get_head_value_node(next_node,  0, reg);
+            if (IS_NOT_NULL(y) && is_not_included(x, y, reg)) {
+              Node* en = onig_node_new_enclose(ENCLOSE_STOP_BACKTRACK);
+              CHECK_NULL_RETURN_MEMERR(en);
+              SET_ENCLOSE_STATUS(en, NST_STOP_BT_SIMPLE_REPEAT);
+              swap_node(node, en);
+              NENCLOSE(node)->target = en;
+            }
+          }
+        }
       }
     }
   }
@@ -3238,11 +3238,11 @@ update_string_node_case_fold(regex_t* reg, Node *node)
     q = buf;
     for (i = 0; i < len; i++) {
       if (sp >= ebuf) {
-	sbuf = (UChar* )xrealloc(sbuf, sbuf_size * 2);
-	CHECK_NULL_RETURN_MEMERR(sbuf);
-	sp = sbuf + sbuf_size;
-	sbuf_size *= 2;
-	ebuf = sbuf + sbuf_size;
+        sbuf = (UChar* )xrealloc(sbuf, sbuf_size * 2);
+        CHECK_NULL_RETURN_MEMERR(sbuf);
+        sp = sbuf + sbuf_size;
+        sbuf_size *= 2;
+        ebuf = sbuf + sbuf_size;
       }
 
       *sp++ = buf[i];
@@ -3261,7 +3261,7 @@ update_string_node_case_fold(regex_t* reg, Node *node)
 
 static int
 expand_case_fold_make_rem_string(Node** rnode, UChar *s, UChar *end,
-				 regex_t* reg)
+                                 regex_t* reg)
 {
   int r;
   Node *node;
@@ -3283,8 +3283,8 @@ expand_case_fold_make_rem_string(Node** rnode, UChar *s, UChar *end,
 
 static int
 expand_case_fold_string_alt(int item_num, OnigCaseFoldCodeItem items[],
-			    UChar *p, int slen, UChar *end,
-			    regex_t* reg, Node **rnode)
+                            UChar *p, int slen, UChar *end,
+                            regex_t* reg, Node **rnode)
 {
   int r, i, j, len, varlen;
   Node *anode, *var_anode, *snode, *xnode, *an;
@@ -3329,8 +3329,8 @@ expand_case_fold_string_alt(int item_num, OnigCaseFoldCodeItem items[],
     for (j = 0; j < items[i].code_len; j++) {
       len = ONIGENC_CODE_TO_MBC(reg->enc, items[i].code[j], buf);
       if (len < 0) {
-	r = len;
-	goto mem_err2;
+        r = len;
+        goto mem_err2;
       }
 
       r = onig_node_str_cat(snode, buf, buf + len);
@@ -3347,29 +3347,29 @@ expand_case_fold_string_alt(int item_num, OnigCaseFoldCodeItem items[],
       UChar *q = p + items[i].byte_len;
 
       if (q < end) {
-	r = expand_case_fold_make_rem_string(&rem, q, end, reg);
-	if (r != 0) {
-	  onig_node_free(an);
-	  goto mem_err2;
-	}
-
-	xnode = onig_node_list_add(NULL_NODE, snode);
-	if (IS_NULL(xnode)) {
-	  onig_node_free(an);
-	  onig_node_free(rem);
-	  goto mem_err2;
-	}
-	if (IS_NULL(onig_node_list_add(xnode, rem))) {
-	  onig_node_free(an);
-	  onig_node_free(xnode);
-	  onig_node_free(rem);
-	  goto mem_err;
-	}
-
-	NCAR(an) = xnode;
+        r = expand_case_fold_make_rem_string(&rem, q, end, reg);
+        if (r != 0) {
+          onig_node_free(an);
+          goto mem_err2;
+        }
+
+        xnode = onig_node_list_add(NULL_NODE, snode);
+        if (IS_NULL(xnode)) {
+          onig_node_free(an);
+          onig_node_free(rem);
+          goto mem_err2;
+        }
+        if (IS_NULL(onig_node_list_add(xnode, rem))) {
+          onig_node_free(an);
+          onig_node_free(xnode);
+          onig_node_free(rem);
+          goto mem_err;
+        }
+
+        NCAR(an) = xnode;
       }
       else {
-	NCAR(an) = snode;
+        NCAR(an) = snode;
       }
 
       NCDR(var_anode) = an;
@@ -3416,7 +3416,7 @@ expand_case_fold_string(Node* node, regex_t* reg)
   p = start;
   while (p < end) {
     n = ONIGENC_GET_CASE_FOLD_CODES_BY_STR(reg->enc, reg->case_fold_flag,
-					   p, end, items);
+                                           p, end, items);
     if (n < 0) {
       r = n;
       goto err;
@@ -3426,22 +3426,22 @@ expand_case_fold_string(Node* node, regex_t* reg)
 
     if (n == 0) {
       if (IS_NULL(snode)) {
-	if (IS_NULL(root) && IS_NOT_NULL(prev_node)) {
-	  top_root = root = onig_node_list_add(NULL_NODE, prev_node);
-	  if (IS_NULL(root)) {
-	    onig_node_free(prev_node);
-	    goto mem_err;
-	  }
-	}
-
-	prev_node = snode = onig_node_new_str(NULL, NULL);
-	if (IS_NULL(snode)) goto mem_err;
-	if (IS_NOT_NULL(root)) {
-	  if (IS_NULL(onig_node_list_add(root, snode))) {
-	    onig_node_free(snode);
-	    goto mem_err;
-	  }
-	}
+        if (IS_NULL(root) && IS_NOT_NULL(prev_node)) {
+          top_root = root = onig_node_list_add(NULL_NODE, prev_node);
+          if (IS_NULL(root)) {
+            onig_node_free(prev_node);
+            goto mem_err;
+          }
+        }
+
+        prev_node = snode = onig_node_new_str(NULL, NULL);
+        if (IS_NULL(snode)) goto mem_err;
+        if (IS_NOT_NULL(root)) {
+          if (IS_NULL(onig_node_list_add(root, snode))) {
+            onig_node_free(snode);
+            goto mem_err;
+          }
+        }
       }
 
       r = onig_node_str_cat(snode, p, p + len);
@@ -3452,35 +3452,35 @@ expand_case_fold_string(Node* node, regex_t* reg)
       if (alt_num > THRESHOLD_CASE_FOLD_ALT_FOR_EXPANSION) break;
 
       if (IS_NULL(root) && IS_NOT_NULL(prev_node)) {
-	top_root = root = onig_node_list_add(NULL_NODE, prev_node);
-	if (IS_NULL(root)) {
-	  onig_node_free(prev_node);
-	  goto mem_err;
-	}
+        top_root = root = onig_node_list_add(NULL_NODE, prev_node);
+        if (IS_NULL(root)) {
+          onig_node_free(prev_node);
+          goto mem_err;
+        }
       }
 
       r = expand_case_fold_string_alt(n, items, p, len, end, reg, &prev_node);
       if (r < 0) goto mem_err;
       if (r == 1) {
-	if (IS_NULL(root)) {
-	  top_root = prev_node;
-	}
-	else {
-	  if (IS_NULL(onig_node_list_add(root, prev_node))) {
-	    onig_node_free(prev_node);
-	    goto mem_err;
-	  }
-	}
-
-	root = NCAR(prev_node);
+        if (IS_NULL(root)) {
+          top_root = prev_node;
+        }
+        else {
+          if (IS_NULL(onig_node_list_add(root, prev_node))) {
+            onig_node_free(prev_node);
+            goto mem_err;
+          }
+        }
+
+        root = NCAR(prev_node);
       }
       else { /* r == 0 */
-	if (IS_NOT_NULL(root)) {
-	  if (IS_NULL(onig_node_list_add(root, prev_node))) {
-	    onig_node_free(prev_node);
-	    goto mem_err;
-	  }
-	}
+        if (IS_NOT_NULL(root)) {
+          if (IS_NULL(onig_node_list_add(root, prev_node))) {
+            onig_node_free(prev_node);
+            goto mem_err;
+          }
+        }
       }
 
       snode = NULL_NODE;
@@ -3498,9 +3498,9 @@ expand_case_fold_string(Node* node, regex_t* reg)
     if (IS_NOT_NULL(prev_node) && IS_NULL(root)) {
       top_root = root = onig_node_list_add(NULL_NODE, prev_node);
       if (IS_NULL(root)) {
-	onig_node_free(srem);
-	onig_node_free(prev_node);
-	goto mem_err;
+        onig_node_free(srem);
+        onig_node_free(prev_node);
+        goto mem_err;
       }
     }
 
@@ -3509,8 +3509,8 @@ expand_case_fold_string(Node* node, regex_t* reg)
     }
     else {
       if (IS_NULL(onig_node_list_add(root, srem))) {
-	onig_node_free(srem);
-	goto mem_err;
+        onig_node_free(srem);
+        goto mem_err;
       }
     }
   }
@@ -3551,8 +3551,8 @@ setup_comb_exp_check(Node* node, int state, ScanEnv* env)
     {
       Node* prev = NULL_NODE;
       do {
-	r = setup_comb_exp_check(NCAR(node), r, env);
-	prev = NCAR(node);
+        r = setup_comb_exp_check(NCAR(node), r, env);
+        prev = NCAR(node);
       } while (r >= 0 && IS_NOT_NULL(node = NCDR(node)));
     }
     break;
@@ -3561,8 +3561,8 @@ setup_comb_exp_check(Node* node, int state, ScanEnv* env)
     {
       int ret;
       do {
-	ret = setup_comb_exp_check(NCAR(node), state, env);
-	r |= ret;
+        ret = setup_comb_exp_check(NCAR(node), state, env);
+        r |= ret;
       } while (ret >= 0 && IS_NOT_NULL(node = NCDR(node)));
     }
     break;
@@ -3576,55 +3576,55 @@ setup_comb_exp_check(Node* node, int state, ScanEnv* env)
       int var_num;
 
       if (! IS_REPEAT_INFINITE(qn->upper)) {
-	if (qn->upper > 1) {
-	  /* {0,1}, {1,1} are allowed */
-	  child_state |= CEC_IN_FINITE_REPEAT;
-
-	  /* check (a*){n,m}, (a+){n,m} => (a*){n,n}, (a+){n,n} */
-	  if (env->backrefed_mem == 0) {
-	    if (NTYPE(qn->target) == NT_ENCLOSE) {
-	      EncloseNode* en = NENCLOSE(qn->target);
-	      if (en->type == ENCLOSE_MEMORY) {
-		if (NTYPE(en->target) == NT_QTFR) {
-		  QtfrNode* q = NQTFR(en->target);
-		  if (IS_REPEAT_INFINITE(q->upper)
-		      && q->greedy == qn->greedy) {
-		    qn->upper = (qn->lower == 0 ? 1 : qn->lower);
-		    if (qn->upper == 1)
-		      child_state = state;
-		  }
-		}
-	      }
-	    }
-	  }
-	}
+        if (qn->upper > 1) {
+          /* {0,1}, {1,1} are allowed */
+          child_state |= CEC_IN_FINITE_REPEAT;
+
+          /* check (a*){n,m}, (a+){n,m} => (a*){n,n}, (a+){n,n} */
+          if (env->backrefed_mem == 0) {
+            if (NTYPE(qn->target) == NT_ENCLOSE) {
+              EncloseNode* en = NENCLOSE(qn->target);
+              if (en->type == ENCLOSE_MEMORY) {
+                if (NTYPE(en->target) == NT_QTFR) {
+                  QtfrNode* q = NQTFR(en->target);
+                  if (IS_REPEAT_INFINITE(q->upper)
+                      && q->greedy == qn->greedy) {
+                    qn->upper = (qn->lower == 0 ? 1 : qn->lower);
+                    if (qn->upper == 1)
+                      child_state = state;
+                  }
+                }
+              }
+            }
+          }
+        }
       }
 
       if (state & CEC_IN_FINITE_REPEAT) {
-	qn->comb_exp_check_num = -1;
+        qn->comb_exp_check_num = -1;
       }
       else {
-	if (IS_REPEAT_INFINITE(qn->upper)) {
-	  var_num = CEC_INFINITE_NUM;
-	  child_state |= CEC_IN_INFINITE_REPEAT;
-	}
-	else {
-	  var_num = qn->upper - qn->lower;
-	}
-
-	if (var_num >= CEC_THRES_NUM_BIG_REPEAT)
-	  add_state |= CEC_CONT_BIG_REPEAT;
-
-	if (((state & CEC_IN_INFINITE_REPEAT) != 0 && var_num != 0) ||
-	    ((state & CEC_CONT_BIG_REPEAT) != 0 &&
-	     var_num >= CEC_THRES_NUM_BIG_REPEAT)) {
-	  if (qn->comb_exp_check_num == 0) {
-	    env->num_comb_exp_check++;
-	    qn->comb_exp_check_num = env->num_comb_exp_check;
-	    if (env->curr_max_regnum > env->comb_exp_max_regnum)
-	      env->comb_exp_max_regnum = env->curr_max_regnum;
-	  }
-	}
+        if (IS_REPEAT_INFINITE(qn->upper)) {
+          var_num = CEC_INFINITE_NUM;
+          child_state |= CEC_IN_INFINITE_REPEAT;
+        }
+        else {
+          var_num = qn->upper - qn->lower;
+        }
+
+        if (var_num >= CEC_THRES_NUM_BIG_REPEAT)
+          add_state |= CEC_CONT_BIG_REPEAT;
+
+        if (((state & CEC_IN_INFINITE_REPEAT) != 0 && var_num != 0) ||
+            ((state & CEC_CONT_BIG_REPEAT) != 0 &&
+             var_num >= CEC_THRES_NUM_BIG_REPEAT)) {
+          if (qn->comb_exp_check_num == 0) {
+            env->num_comb_exp_check++;
+            qn->comb_exp_check_num = env->num_comb_exp_check;
+            if (env->curr_max_regnum > env->comb_exp_max_regnum)
+              env->comb_exp_max_regnum = env->curr_max_regnum;
+          }
+        }
       }
 
       r = setup_comb_exp_check(target, child_state, env);
@@ -3638,17 +3638,17 @@ setup_comb_exp_check(Node* node, int state, ScanEnv* env)
 
       switch (en->type) {
       case ENCLOSE_MEMORY:
-	{
-	  if (env->curr_max_regnum < en->regnum)
-	    env->curr_max_regnum = en->regnum;
+        {
+          if (env->curr_max_regnum < en->regnum)
+            env->curr_max_regnum = en->regnum;
 
-	  r = setup_comb_exp_check(en->target, state, env);
-	}
-	break;
+          r = setup_comb_exp_check(en->target, state, env);
+        }
+        break;
 
       default:
-	r = setup_comb_exp_check(en->target, state, env);
-	break;
+        r = setup_comb_exp_check(en->target, state, env);
+        break;
       }
     }
     break;
@@ -3695,11 +3695,11 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
     {
       Node* prev = NULL_NODE;
       do {
-	r = setup_tree(NCAR(node), reg, state, env);
-	if (IS_NOT_NULL(prev) && r == 0) {
-	  r = next_setup(prev, NCAR(node), reg);
-	}
-	prev = NCAR(node);
+        r = setup_tree(NCAR(node), reg, state, env);
+        if (IS_NOT_NULL(prev) && r == 0) {
+          r = next_setup(prev, NCAR(node), reg);
+        }
+        prev = NCAR(node);
       } while (r == 0 && IS_NOT_NULL(node = NCDR(node)));
     }
     break;
@@ -3736,15 +3736,15 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
       BRefNode* br = NBREF(node);
       p = BACKREFS_P(br);
       for (i = 0; i < br->back_num; i++) {
-	if (p[i] > env->num_mem)  return ONIGERR_INVALID_BACKREF;
-	BIT_STATUS_ON_AT(env->backrefed_mem, p[i]);
-	BIT_STATUS_ON_AT(env->bt_mem_start, p[i]);
+        if (p[i] > env->num_mem)  return ONIGERR_INVALID_BACKREF;
+        BIT_STATUS_ON_AT(env->backrefed_mem, p[i]);
+        BIT_STATUS_ON_AT(env->bt_mem_start, p[i]);
 #ifdef USE_BACKREF_WITH_LEVEL
-	if (IS_BACKREF_NEST_LEVEL(br)) {
-	  BIT_STATUS_ON_AT(env->bt_mem_end, p[i]);
-	}
+        if (IS_BACKREF_NEST_LEVEL(br)) {
+          BIT_STATUS_ON_AT(env->bt_mem_end, p[i]);
+        }
 #endif
-	SET_ENCLOSE_STATUS(nodes[p[i]], NST_MEM_BACKREFED);
+        SET_ENCLOSE_STATUS(nodes[p[i]], NST_MEM_BACKREFED);
       }
     }
     break;
@@ -3760,59 +3760,59 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
       }
 
       if (IS_REPEAT_INFINITE(qn->upper) || qn->upper >= 1) {
-	r = get_min_match_length(target, &d, env);
-	if (r) break;
-	if (d == 0) {
-	  qn->target_empty_info = NQ_TARGET_IS_EMPTY;
+        r = get_min_match_length(target, &d, env);
+        if (r) break;
+        if (d == 0) {
+          qn->target_empty_info = NQ_TARGET_IS_EMPTY;
 #ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
-	  r = quantifiers_memory_node_info(target);
-	  if (r < 0) break;
-	  if (r > 0) {
-	    qn->target_empty_info = r;
-	  }
+          r = quantifiers_memory_node_info(target);
+          if (r < 0) break;
+          if (r > 0) {
+            qn->target_empty_info = r;
+          }
 #endif
-	}
+        }
       }
 
       state |= IN_REPEAT;
       if (qn->lower != qn->upper)
-	state |= IN_VAR_REPEAT;
+        state |= IN_VAR_REPEAT;
       r = setup_tree(target, reg, state, env);
       if (r) break;
 
       /* expand string */
 #define EXPAND_STRING_MAX_LENGTH  100
       if (NTYPE(target) == NT_STR) {
-	if (!IS_REPEAT_INFINITE(qn->lower) && qn->lower == qn->upper &&
-	    qn->lower > 1 && qn->lower <= EXPAND_STRING_MAX_LENGTH) {
-	  int len = NSTRING_LEN(target);
-	  StrNode* sn = NSTR(target);
-
-	  if (len * qn->lower <= EXPAND_STRING_MAX_LENGTH) {
-	    int i, n = qn->lower;
-	    onig_node_conv_to_str_node(node, NSTR(target)->flag);
-	    for (i = 0; i < n; i++) {
-	      r = onig_node_str_cat(node, sn->s, sn->end);
-	      if (r) break;
-	    }
-	    onig_node_free(target);
-	    break; /* break case NT_QTFR: */
-	  }
-	}
+        if (!IS_REPEAT_INFINITE(qn->lower) && qn->lower == qn->upper &&
+            qn->lower > 1 && qn->lower <= EXPAND_STRING_MAX_LENGTH) {
+          int len = NSTRING_LEN(target);
+          StrNode* sn = NSTR(target);
+
+          if (len * qn->lower <= EXPAND_STRING_MAX_LENGTH) {
+            int i, n = qn->lower;
+            onig_node_conv_to_str_node(node, NSTR(target)->flag);
+            for (i = 0; i < n; i++) {
+              r = onig_node_str_cat(node, sn->s, sn->end);
+              if (r) break;
+            }
+            onig_node_free(target);
+            break; /* break case NT_QTFR: */
+          }
+        }
       }
 
 #ifdef USE_OP_PUSH_OR_JUMP_EXACT
       if (qn->greedy && (qn->target_empty_info != 0)) {
-	if (NTYPE(target) == NT_QTFR) {
-	  QtfrNode* tqn = NQTFR(target);
-	  if (IS_NOT_NULL(tqn->head_exact)) {
-	    qn->head_exact  = tqn->head_exact;
-	    tqn->head_exact = NULL;
-	  }
-	}
-	else {
-	  qn->head_exact = get_head_value_node(qn->target, 1, reg);
-	}
+        if (NTYPE(target) == NT_QTFR) {
+          QtfrNode* tqn = NQTFR(target);
+          if (IS_NOT_NULL(tqn->head_exact)) {
+            qn->head_exact  = tqn->head_exact;
+            tqn->head_exact = NULL;
+          }
+        }
+        else {
+          qn->head_exact = get_head_value_node(qn->target, 1, reg);
+        }
       }
 #endif
     }
@@ -3824,37 +3824,37 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
 
       switch (en->type) {
       case ENCLOSE_OPTION:
-	{
-	  OnigOptionType options = reg->options;
-	  reg->options = NENCLOSE(node)->option;
-	  r = setup_tree(NENCLOSE(node)->target, reg, state, env);
-	  reg->options = options;
-	}
-	break;
+        {
+          OnigOptionType options = reg->options;
+          reg->options = NENCLOSE(node)->option;
+          r = setup_tree(NENCLOSE(node)->target, reg, state, env);
+          reg->options = options;
+        }
+        break;
 
       case ENCLOSE_MEMORY:
-	if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT)) != 0) {
-	  BIT_STATUS_ON_AT(env->bt_mem_start, en->regnum);
-	  /* SET_ENCLOSE_STATUS(node, NST_MEM_IN_ALT_NOT); */
-	}
+        if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT)) != 0) {
+          BIT_STATUS_ON_AT(env->bt_mem_start, en->regnum);
+          /* SET_ENCLOSE_STATUS(node, NST_MEM_IN_ALT_NOT); */
+        }
         r = setup_tree(en->target, reg, state, env);
         break;
 
       case ENCLOSE_STOP_BACKTRACK:
-	{
-	  Node* target = en->target;
-	  r = setup_tree(target, reg, state, env);
-	  if (NTYPE(target) == NT_QTFR) {
-	    QtfrNode* tqn = NQTFR(target);
-	    if (IS_REPEAT_INFINITE(tqn->upper) && tqn->lower <= 1 &&
-		tqn->greedy != 0) {  /* (?>a*), a*+ etc... */
-	      int qtype = NTYPE(tqn->target);
-	      if (IS_NODE_TYPE_SIMPLE(qtype))
-		SET_ENCLOSE_STATUS(node, NST_STOP_BT_SIMPLE_REPEAT);
-	    }
-	  }
-	}
-	break;
+        {
+          Node* target = en->target;
+          r = setup_tree(target, reg, state, env);
+          if (NTYPE(target) == NT_QTFR) {
+            QtfrNode* tqn = NQTFR(target);
+            if (IS_REPEAT_INFINITE(tqn->upper) && tqn->lower <= 1 &&
+                tqn->greedy != 0) {  /* (?>a*), a*+ etc... */
+              int qtype = NTYPE(tqn->target);
+              if (IS_NODE_TYPE_SIMPLE(qtype))
+                SET_ENCLOSE_STATUS(node, NST_STOP_BT_SIMPLE_REPEAT);
+            }
+          }
+        }
+        break;
       }
     }
     break;
@@ -3865,11 +3865,11 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
 
       switch (an->type) {
       case ANCHOR_PREC_READ:
-	r = setup_tree(an->target, reg, state, env);
-	break;
+        r = setup_tree(an->target, reg, state, env);
+        break;
       case ANCHOR_PREC_READ_NOT:
-	r = setup_tree(an->target, reg, (state | IN_NOT), env);
-	break;
+        r = setup_tree(an->target, reg, (state | IN_NOT), env);
+        break;
 
 /* allowed node types in look-behind */
 #define ALLOWED_TYPE_IN_LB  \
@@ -3885,28 +3885,28 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
 ( ANCHOR_LOOK_BEHIND | ANCHOR_LOOK_BEHIND_NOT | ANCHOR_BEGIN_LINE | ANCHOR_END_LINE | ANCHOR_BEGIN_BUF | ANCHOR_BEGIN_POSITION )
 
       case ANCHOR_LOOK_BEHIND:
-	{
-	  r = check_type_tree(an->target, ALLOWED_TYPE_IN_LB,
-			      ALLOWED_ENCLOSE_IN_LB, ALLOWED_ANCHOR_IN_LB);
-	  if (r < 0) return r;
-	  if (r > 0) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
-	  r = setup_look_behind(node, reg, env);
-	  if (r != 0) return r;
-	  r = setup_tree(an->target, reg, state, env);
-	}
-	break;
+        {
+          r = check_type_tree(an->target, ALLOWED_TYPE_IN_LB,
+                              ALLOWED_ENCLOSE_IN_LB, ALLOWED_ANCHOR_IN_LB);
+          if (r < 0) return r;
+          if (r > 0) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
+          r = setup_look_behind(node, reg, env);
+          if (r != 0) return r;
+          r = setup_tree(an->target, reg, state, env);
+        }
+        break;
 
       case ANCHOR_LOOK_BEHIND_NOT:
-	{
-	  r = check_type_tree(an->target, ALLOWED_TYPE_IN_LB,
-		      ALLOWED_ENCLOSE_IN_LB_NOT, ALLOWED_ANCHOR_IN_LB_NOT);
-	  if (r < 0) return r;
-	  if (r > 0) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
-	  r = setup_look_behind(node, reg, env);
-	  if (r != 0) return r;
-	  r = setup_tree(an->target, reg, (state | IN_NOT), env);
-	}
-	break;
+        {
+          r = check_type_tree(an->target, ALLOWED_TYPE_IN_LB,
+                      ALLOWED_ENCLOSE_IN_LB_NOT, ALLOWED_ANCHOR_IN_LB_NOT);
+          if (r < 0) return r;
+          if (r > 0) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
+          r = setup_look_behind(node, reg, env);
+          if (r != 0) return r;
+          r = setup_tree(an->target, reg, (state | IN_NOT), env);
+        }
+        break;
       }
     }
     break;
@@ -3921,7 +3921,7 @@ setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
 /* set skip map for Boyer-Moor search */
 static int
 set_bm_skip(UChar* s, UChar* end, OnigEncoding enc ARG_UNUSED,
-	    UChar skip[], int** int_skip)
+            UChar skip[], int** int_skip)
 {
   int i, len;
 
@@ -4127,7 +4127,7 @@ copy_opt_anc_info(OptAncInfo* to, OptAncInfo* from)
 
 static void
 concat_opt_anc_info(OptAncInfo* to, OptAncInfo* left, OptAncInfo* right,
-		    OnigDistance left_len, OnigDistance right_len)
+                    OnigDistance left_len, OnigDistance right_len)
 {
   clear_opt_anc_info(to);
 
@@ -4241,7 +4241,7 @@ concat_opt_exact_info(OptExactInfo* to, OptExactInfo* add, OnigEncoding enc)
 
 static void
 concat_opt_exact_info_str(OptExactInfo* to, UChar* s, UChar* end,
-			  int raw ARG_UNUSED, OnigEncoding enc)
+                          int raw ARG_UNUSED, OnigEncoding enc)
 {
   int i, j, len;
   UChar *p;
@@ -4483,7 +4483,7 @@ concat_left_node_opt_info(OnigEncoding enc, NodeOptInfo* to, NodeOptInfo* add)
 
   if (add->exb.len > 0 && to->len.max == 0) {
     concat_opt_anc_info(&tanc, &to->anc, &add->exb.anc,
-			to->len.max, add->len.max);
+                        to->len.max, add->len.max);
     copy_opt_anc_info(&add->exb.anc, &tanc);
   }
 
@@ -4514,12 +4514,12 @@ concat_left_node_opt_info(OnigEncoding enc, NodeOptInfo* to, NodeOptInfo* add)
   if (to->expr.len > 0) {
     if (add->len.max > 0) {
       if (to->expr.len > (int )add->len.max)
-	to->expr.len = add->len.max;
+        to->expr.len = add->len.max;
 
       if (to->expr.mmd.max == 0)
-	select_opt_exact_info(enc, &to->exb, &to->expr);
+        select_opt_exact_info(enc, &to->exb, &to->expr);
       else
-	select_opt_exact_info(enc, &to->exm, &to->expr);
+        select_opt_exact_info(enc, &to->exm, &to->expr);
     }
   }
   else if (add->expr.len > 0) {
@@ -4565,11 +4565,11 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
 
       copy_opt_env(&nenv, env);
       do {
-	r = optimize_node_left(NCAR(nd), &nopt, &nenv);
-	if (r == 0) {
-	  add_mml(&nenv.mmd, &nopt.len);
-	  concat_left_node_opt_info(env->enc, opt, &nopt);
-	}
+        r = optimize_node_left(NCAR(nd), &nopt, &nenv);
+        if (r == 0) {
+          add_mml(&nenv.mmd, &nopt.len);
+          concat_left_node_opt_info(env->enc, opt, &nopt);
+        }
       } while (r == 0 && IS_NOT_NULL(nd = NCDR(nd)));
     }
     break;
@@ -4580,11 +4580,11 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
       Node* nd = node;
 
       do {
-	r = optimize_node_left(NCAR(nd), &nopt, env);
-	if (r == 0) {
-	  if (nd == node) copy_node_opt_info(opt, &nopt);
-	  else            alt_merge_node_opt_info(opt, &nopt, env);
-	}
+        r = optimize_node_left(NCAR(nd), &nopt, env);
+        if (r == 0) {
+          if (nd == node) copy_node_opt_info(opt, &nopt);
+          else            alt_merge_node_opt_info(opt, &nopt, env);
+        }
       } while ((r == 0) && IS_NOT_NULL(nd = NCDR(nd)));
     }
     break;
@@ -4596,39 +4596,39 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
       int is_raw = NSTRING_IS_RAW(node);
 
       if (! NSTRING_IS_AMBIG(node)) {
-	concat_opt_exact_info_str(&opt->exb, sn->s, sn->end,
-				  NSTRING_IS_RAW(node), env->enc);
-	if (slen > 0) {
-	  add_char_opt_map_info(&opt->map, *(sn->s), env->enc);
-	}
+        concat_opt_exact_info_str(&opt->exb, sn->s, sn->end,
+                                  NSTRING_IS_RAW(node), env->enc);
+        if (slen > 0) {
+          add_char_opt_map_info(&opt->map, *(sn->s), env->enc);
+        }
         set_mml(&opt->len, slen, slen);
       }
       else {
         int max;
 
-	if (NSTRING_IS_DONT_GET_OPT_INFO(node)) {
+        if (NSTRING_IS_DONT_GET_OPT_INFO(node)) {
           int n = onigenc_strlen(env->enc, sn->s, sn->end);
           max = ONIGENC_MBC_MAXLEN_DIST(env->enc) * n;
-	}
-	else {
-	  concat_opt_exact_info_str(&opt->exb, sn->s, sn->end,
-				    is_raw, env->enc);
-	  opt->exb.ignore_case = 1;
-
-	  if (slen > 0) {
-	    r = add_char_amb_opt_map_info(&opt->map, sn->s, sn->end,
-					  env->enc, env->case_fold_flag);
-	    if (r != 0) break;
-	  }
+        }
+        else {
+          concat_opt_exact_info_str(&opt->exb, sn->s, sn->end,
+                                    is_raw, env->enc);
+          opt->exb.ignore_case = 1;
+
+          if (slen > 0) {
+            r = add_char_amb_opt_map_info(&opt->map, sn->s, sn->end,
+                                          env->enc, env->case_fold_flag);
+            if (r != 0) break;
+          }
 
-	  max = slen;
-	}
+          max = slen;
+        }
 
         set_mml(&opt->len, slen, max);
       }
 
       if (opt->exb.len == slen)
-	opt->exb.reach_end = 1;
+        opt->exb.reach_end = 1;
     }
     break;
 
@@ -4641,9 +4641,9 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
 
       if (IS_NOT_NULL(cc->mbuf) || IS_NCCLASS_NOT(cc)) {
         OnigDistance min = ONIGENC_MBC_MINLEN(env->enc);
-	OnigDistance max = ONIGENC_MBC_MAXLEN_DIST(env->enc);
+        OnigDistance max = ONIGENC_MBC_MAXLEN_DIST(env->enc);
 
-	set_mml(&opt->len, min, max);
+        set_mml(&opt->len, min, max);
       }
       else {
         for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
@@ -4652,7 +4652,7 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
             add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
           }
         }
-	set_mml(&opt->len, 1, 1);
+        set_mml(&opt->len, 1, 1);
       }
     }
     break;
@@ -4666,24 +4666,24 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
       if (max == 1) {
         min = 1;
 
-	switch (NCTYPE(node)->ctype) {
-	case ONIGENC_CTYPE_WORD:
-	  if (NCTYPE(node)->not != 0) {
-	    for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
-	      if (! ONIGENC_IS_CODE_WORD(env->enc, i)) {
-		add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
-	      }
-	    }
-	  }
-	  else {
-	    for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
-	      if (ONIGENC_IS_CODE_WORD(env->enc, i)) {
-		add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
-	      }
-	    }
-	  }
-	  break;
-	}
+        switch (NCTYPE(node)->ctype) {
+        case ONIGENC_CTYPE_WORD:
+          if (NCTYPE(node)->not != 0) {
+            for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
+              if (! ONIGENC_IS_CODE_WORD(env->enc, i)) {
+                add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
+              }
+            }
+          }
+          else {
+            for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
+              if (ONIGENC_IS_CODE_WORD(env->enc, i)) {
+                add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
+              }
+            }
+          }
+          break;
+        }
       }
       else {
         min = ONIGENC_MBC_MINLEN(env->enc);
@@ -4713,20 +4713,20 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
 
     case ANCHOR_PREC_READ:
       {
-	NodeOptInfo nopt;
+        NodeOptInfo nopt;
 
-	r = optimize_node_left(NANCHOR(node)->target, &nopt, env);
-	if (r == 0) {
-	  if (nopt.exb.len > 0)
-	    copy_opt_exact_info(&opt->expr, &nopt.exb);
-	  else if (nopt.exm.len > 0)
-	    copy_opt_exact_info(&opt->expr, &nopt.exm);
+        r = optimize_node_left(NANCHOR(node)->target, &nopt, env);
+        if (r == 0) {
+          if (nopt.exb.len > 0)
+            copy_opt_exact_info(&opt->expr, &nopt.exb);
+          else if (nopt.exm.len > 0)
+            copy_opt_exact_info(&opt->expr, &nopt.exm);
 
-	  opt->expr.reach_end = 0;
+          opt->expr.reach_end = 0;
 
-	  if (nopt.map.value > 0)
-	    copy_opt_map_info(&opt->map, &nopt.map);
-	}
+          if (nopt.map.value > 0)
+            copy_opt_map_info(&opt->map, &nopt.map);
+        }
       }
       break;
 
@@ -4746,8 +4746,8 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
       BRefNode* br = NBREF(node);
 
       if (br->state & NST_RECURSION) {
-	set_mml(&opt->len, 0, ONIG_INFINITE_DISTANCE);
-	break;
+        set_mml(&opt->len, 0, ONIG_INFINITE_DISTANCE);
+        break;
       }
       backs = BACKREFS_P(br);
       r = get_min_match_length(nodes[backs[0]], &min, env->scan_env);
@@ -4755,12 +4755,12 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
       r = get_max_match_length(nodes[backs[0]], &max, env->scan_env);
       if (r != 0) break;
       for (i = 1; i < br->back_num; i++) {
-	r = get_min_match_length(nodes[backs[i]], &tmin, env->scan_env);
-	if (r != 0) break;
-	r = get_max_match_length(nodes[backs[i]], &tmax, env->scan_env);
-	if (r != 0) break;
-	if (min > tmin) min = tmin;
-	if (max < tmax) max = tmax;
+        r = get_min_match_length(nodes[backs[i]], &tmin, env->scan_env);
+        if (r != 0) break;
+        r = get_max_match_length(nodes[backs[i]], &tmax, env->scan_env);
+        if (r != 0) break;
+        if (min > tmin) min = tmin;
+        if (max < tmax) max = tmax;
       }
       if (r == 0) set_mml(&opt->len, min, max);
     }
@@ -4790,43 +4790,43 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
       if (r) break;
 
       if (qn->lower == 0 && IS_REPEAT_INFINITE(qn->upper)) {
-	if (env->mmd.max == 0 &&
-	    NTYPE(qn->target) == NT_CANY && qn->greedy) {
-	  if (IS_MULTILINE(env->options))
-	    add_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_ML);
-	  else
-	    add_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR);
-	}
+        if (env->mmd.max == 0 &&
+            NTYPE(qn->target) == NT_CANY && qn->greedy) {
+          if (IS_MULTILINE(env->options))
+            add_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_ML);
+          else
+            add_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR);
+        }
       }
       else {
-	if (qn->lower > 0) {
-	  copy_node_opt_info(opt, &nopt);
-	  if (nopt.exb.len > 0) {
-	    if (nopt.exb.reach_end) {
-	      for (i = 2; i <= qn->lower &&
-		          ! is_full_opt_exact_info(&opt->exb); i++) {
-		concat_opt_exact_info(&opt->exb, &nopt.exb, env->enc);
-	      }
-	      if (i < qn->lower) {
-		opt->exb.reach_end = 0;
-	      }
-	    }
-	  }
-
-	  if (qn->lower != qn->upper) {
-	    opt->exb.reach_end = 0;
-	    opt->exm.reach_end = 0;
-	  }
-	  if (qn->lower > 1)
-	    opt->exm.reach_end = 0;
-	}
+        if (qn->lower > 0) {
+          copy_node_opt_info(opt, &nopt);
+          if (nopt.exb.len > 0) {
+            if (nopt.exb.reach_end) {
+              for (i = 2; i <= qn->lower &&
+                          ! is_full_opt_exact_info(&opt->exb); i++) {
+                concat_opt_exact_info(&opt->exb, &nopt.exb, env->enc);
+              }
+              if (i < qn->lower) {
+                opt->exb.reach_end = 0;
+              }
+            }
+          }
+
+          if (qn->lower != qn->upper) {
+            opt->exb.reach_end = 0;
+            opt->exm.reach_end = 0;
+          }
+          if (qn->lower > 1)
+            opt->exm.reach_end = 0;
+        }
       }
 
       min = distance_multiply(nopt.len.min, qn->lower);
       if (IS_REPEAT_INFINITE(qn->upper))
-	max = (nopt.len.max > 0 ? ONIG_INFINITE_DISTANCE : 0);
+        max = (nopt.len.max > 0 ? ONIG_INFINITE_DISTANCE : 0);
       else
-	max = distance_multiply(nopt.len.max, qn->upper);
+        max = distance_multiply(nopt.len.max, qn->upper);
 
       set_mml(&opt->len, min, max);
     }
@@ -4838,42 +4838,42 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
 
       switch (en->type) {
       case ENCLOSE_OPTION:
-	{
-	  OnigOptionType save = env->options;
+        {
+          OnigOptionType save = env->options;
 
-	  env->options = en->option;
-	  r = optimize_node_left(en->target, opt, env);
-	  env->options = save;
-	}
-	break;
+          env->options = en->option;
+          r = optimize_node_left(en->target, opt, env);
+          env->options = save;
+        }
+        break;
 
       case ENCLOSE_MEMORY:
 #ifdef USE_SUBEXP_CALL
-	en->opt_count++;
-	if (en->opt_count > MAX_NODE_OPT_INFO_REF_COUNT) {
-	  OnigDistance min, max;
-
-	  min = 0;
-	  max = ONIG_INFINITE_DISTANCE;
-	  if (IS_ENCLOSE_MIN_FIXED(en)) min = en->min_len;
-	  if (IS_ENCLOSE_MAX_FIXED(en)) max = en->max_len;
-	  set_mml(&opt->len, min, max);
-	}
-	else
+        en->opt_count++;
+        if (en->opt_count > MAX_NODE_OPT_INFO_REF_COUNT) {
+          OnigDistance min, max;
+
+          min = 0;
+          max = ONIG_INFINITE_DISTANCE;
+          if (IS_ENCLOSE_MIN_FIXED(en)) min = en->min_len;
+          if (IS_ENCLOSE_MAX_FIXED(en)) max = en->max_len;
+          set_mml(&opt->len, min, max);
+        }
+        else
 #endif
-	{
-	  r = optimize_node_left(en->target, opt, env);
+        {
+          r = optimize_node_left(en->target, opt, env);
 
-	  if (is_set_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_MASK)) {
-	    if (BIT_STATUS_AT(env->scan_env->backrefed_mem, en->regnum))
-	      remove_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_MASK);
-	  }
-	}
-	break;
+          if (is_set_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_MASK)) {
+            if (BIT_STATUS_AT(env->scan_env->backrefed_mem, en->regnum))
+              remove_opt_anc_info(&opt->anc, ANCHOR_ANYCHAR_STAR_MASK);
+          }
+        }
+        break;
 
       case ENCLOSE_STOP_BACKTRACK:
-	r = optimize_node_left(en->target, opt, env);
-	break;
+        r = optimize_node_left(en->target, opt, env);
+        break;
       }
     }
     break;
@@ -4881,7 +4881,7 @@ optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)
   default:
 #ifdef ONIG_DEBUG
     fprintf(stderr, "optimize_node_left: undefined node type %d\n",
-	    NTYPE(node));
+            NTYPE(node));
 #endif
     r = ONIGERR_TYPE_BUG;
     break;
@@ -4912,15 +4912,15 @@ set_optimize_exact_info(regex_t* reg, OptExactInfo* e)
     reg->exact_end = reg->exact + e->len;
 
     allow_reverse =
-	ONIGENC_IS_ALLOWED_REVERSE_MATCH(reg->enc, reg->exact, reg->exact_end);
+        ONIGENC_IS_ALLOWED_REVERSE_MATCH(reg->enc, reg->exact, reg->exact_end);
 
     if (e->len >= 3 || (e->len >= 2 && allow_reverse)) {
       r = set_bm_skip(reg->exact, reg->exact_end, reg->enc,
-	              reg->map, &(reg->int_map));
+                      reg->map, &(reg->int_map));
       if (r) return r;
 
       reg->optimize = (allow_reverse != 0
-		       ? ONIG_OPTIMIZE_EXACT_BM : ONIG_OPTIMIZE_EXACT_BM_NOT_REV);
+                       ? ONIG_OPTIMIZE_EXACT_BM : ONIG_OPTIMIZE_EXACT_BM_NOT_REV);
     }
     else {
       reg->optimize = ONIG_OPTIMIZE_EXACT;
@@ -4995,7 +4995,7 @@ set_optimize_info_from_tree(Node* node, regex_t* reg, ScanEnv* scan_env)
   if (opt.exb.len > 0 || opt.exm.len > 0) {
     select_opt_exact_info(reg->enc, &opt.exb, &opt.exm);
     if (opt.map.value > 0 &&
-	comp_opt_exact_or_map_info(&opt.exb, &opt.map) > 0) {
+        comp_opt_exact_or_map_info(&opt.exb, &opt.map) > 0) {
       goto set_map;
     }
     else {
@@ -5039,7 +5039,7 @@ clear_optimize_info(regex_t* reg)
 #ifdef ONIG_DEBUG
 
 static void print_enc_string(FILE* fp, OnigEncoding enc,
-			     const UChar *s, const UChar *end)
+                             const UChar *s, const UChar *end)
 {
   fprintf(fp, "\nPATTERN: /");
 
@@ -5051,10 +5051,10 @@ static void print_enc_string(FILE* fp, OnigEncoding enc,
     while (p < end) {
       code = ONIGENC_MBC_TO_CODE(enc, p, end);
       if (code >= 0x80) {
-	fprintf(fp, " 0x%04x ", (int )code);
+        fprintf(fp, " 0x%04x ", (int )code);
       }
       else {
-	fputc((int )code, fp);
+        fputc((int )code, fp);
       }
 
       p += enclen(enc, p, end);
@@ -5172,7 +5172,7 @@ print_optimize_info(FILE* f, regex_t* reg)
       c = 0;
       fputc('[', f);
       for (i = 0; i < ONIG_CHAR_TABLE_SIZE; i++) {
-	if (reg->map[i] != 0) {
+        if (reg->map[i] != 0) {
           if (c > 0)  fputs(", ", f);
           c++;
           if (ONIGENC_MBC_MAXLEN(reg->enc) == 1 &&
@@ -5286,7 +5286,7 @@ static void print_tree P_((FILE* f, Node* node));
 
 extern int
 onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
-	      OnigErrorInfo* einfo, const char *sourcefile, int sourceline)
+              OnigErrorInfo* einfo, const char *sourcefile, int sourceline)
 {
 #define COMPILE_INIT_SIZE  20
 
@@ -5393,10 +5393,10 @@ onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
     if (scan_env.comb_exp_max_regnum > 0) {
       int i;
       for (i = 1; i <= scan_env.comb_exp_max_regnum; i++) {
-	if (BIT_STATUS_AT(scan_env.backrefed_mem, i) != 0) {
-	  scan_env.num_comb_exp_check = 0;
-	  break;
-	}
+        if (BIT_STATUS_AT(scan_env.backrefed_mem, i) != 0) {
+          scan_env.num_comb_exp_check = 0;
+          break;
+        }
       }
     }
   }
@@ -5430,9 +5430,9 @@ onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
       reg->stack_pop_level = STACK_POP_LEVEL_ALL;
     else {
       if (reg->bt_mem_start != 0)
-	reg->stack_pop_level = STACK_POP_LEVEL_MEM_START;
+        reg->stack_pop_level = STACK_POP_LEVEL_MEM_START;
       else
-	reg->stack_pop_level = STACK_POP_LEVEL_FREE;
+        reg->stack_pop_level = STACK_POP_LEVEL_FREE;
     }
   }
 #ifdef USE_SUBEXP_CALL
@@ -5477,8 +5477,8 @@ onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
 #ifdef USE_RECOMPILE_API
 extern int
 onig_recompile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
-	    OnigOptionType option, OnigEncoding enc, OnigSyntaxType* syntax,
-	    OnigErrorInfo* einfo)
+            OnigOptionType option, OnigEncoding enc, OnigSyntaxType* syntax,
+            OnigErrorInfo* einfo)
 {
   int r;
   regex_t *new_reg;
@@ -5499,8 +5499,8 @@ static int onig_inited = 0;
 
 extern int
 onig_reg_init(regex_t* reg, OnigOptionType option,
-	      OnigCaseFoldType case_fold_flag,
-	      OnigEncoding enc, const OnigSyntaxType* syntax)
+              OnigCaseFoldType case_fold_flag,
+              OnigEncoding enc, const OnigSyntaxType* syntax)
 {
   if (! onig_inited)
     onig_init();
@@ -5559,8 +5559,8 @@ onig_new_without_alloc(regex_t* reg, const UChar* pattern,
 
 extern int
 onig_new(regex_t** reg, const UChar* pattern, const UChar* pattern_end,
-	  OnigOptionType option, OnigEncoding enc, const OnigSyntaxType* syntax,
-	  OnigErrorInfo* einfo)
+          OnigOptionType option, OnigEncoding enc, const OnigSyntaxType* syntax,
+          OnigErrorInfo* einfo)
 {
   int r;
 
@@ -5880,9 +5880,9 @@ onig_print_compiled_byte_code(FILE* f, UChar* bp, UChar* bpend, UChar** nextp,
       break;
     case ARG_OPTION:
       {
-	OnigOptionType option = *((OnigOptionType* )bp);
-	bp += SIZE_OPTION;
-	fprintf(f, ":%d", option);
+        OnigOptionType option = *((OnigOptionType* )bp);
+        bp += SIZE_OPTION;
+        fprintf(f, ":%d", option);
       }
       break;
 
@@ -5931,13 +5931,13 @@ onig_print_compiled_byte_code(FILE* f, UChar* bp, UChar* bpend, UChar** nextp,
       break;
     case OP_EXACTMBN:
       {
-	int mb_len;
+        int mb_len;
 
-	GET_LENGTH_INC(mb_len, bp);
-	GET_LENGTH_INC(len, bp);
-	fprintf(f, ":%d:%d:", mb_len, len);
-	n = len * mb_len;
-	while (n-- > 0) { fputc(*bp++, f); }
+        GET_LENGTH_INC(mb_len, bp);
+        GET_LENGTH_INC(len, bp);
+        fprintf(f, ":%d:%d:", mb_len, len);
+        n = len * mb_len;
+        while (n-- > 0) { fputc(*bp++, f); }
       }
       break;
 
@@ -6011,40 +6011,40 @@ onig_print_compiled_byte_code(FILE* f, UChar* bp, UChar* bpend, UChar** nextp,
       fputs(" ", f);
       GET_LENGTH_INC(len, bp);
       for (i = 0; i < len; i++) {
-	GET_MEMNUM_INC(mem, bp);
-	if (i > 0) fputs(", ", f);
-	fprintf(f, "%d", mem);
+        GET_MEMNUM_INC(mem, bp);
+        if (i > 0) fputs(", ", f);
+        fprintf(f, "%d", mem);
       }
       break;
 
     case OP_BACKREF_WITH_LEVEL:
       {
-	OnigOptionType option;
-	LengthType level;
-
-	GET_OPTION_INC(option, bp);
-	fprintf(f, ":%d", option);
-	GET_LENGTH_INC(level, bp);
-	fprintf(f, ":%d", level);
-
-	fputs(" ", f);
-	GET_LENGTH_INC(len, bp);
-	for (i = 0; i < len; i++) {
-	  GET_MEMNUM_INC(mem, bp);
-	  if (i > 0) fputs(", ", f);
-	  fprintf(f, "%d", mem);
-	}
+        OnigOptionType option;
+        LengthType level;
+
+        GET_OPTION_INC(option, bp);
+        fprintf(f, ":%d", option);
+        GET_LENGTH_INC(level, bp);
+        fprintf(f, ":%d", level);
+
+        fputs(" ", f);
+        GET_LENGTH_INC(len, bp);
+        for (i = 0; i < len; i++) {
+          GET_MEMNUM_INC(mem, bp);
+          if (i > 0) fputs(", ", f);
+          fprintf(f, "%d", mem);
+        }
       }
       break;
 
     case OP_REPEAT:
     case OP_REPEAT_NG:
       {
-	mem = *((MemNumType* )bp);
-	bp += SIZE_MEMNUM;
-	addr = *((RelAddrType* )bp);
-	bp += SIZE_RELADDR;
-	fprintf(f, ":%d:%d", mem, addr);
+        mem = *((MemNumType* )bp);
+        bp += SIZE_MEMNUM;
+        addr = *((RelAddrType* )bp);
+        bp += SIZE_RELADDR;
+        fprintf(f, ":%d:%d", mem, addr);
       }
       break;
 
@@ -6079,7 +6079,7 @@ onig_print_compiled_byte_code(FILE* f, UChar* bp, UChar* bpend, UChar** nextp,
 
     default:
       fprintf(stderr, "onig_print_compiled_byte_code: undefined code %d\n",
-	      *--bp);
+              *--bp);
     }
   }
   fputs("]", f);
@@ -6100,9 +6100,9 @@ print_compiled_byte_code_list(FILE* f, regex_t* reg)
     ncode++;
     if (bp > reg->p) {
       if (ncode % 5 == 0)
-	fprintf(f, "\n");
+        fprintf(f, "\n");
       else
-	fputs(" ", f);
+        fputs(" ", f);
     }
     onig_print_compiled_byte_code(f, bp, end, &bp, reg->enc);
   }
@@ -6135,8 +6135,8 @@ print_indent_tree(FILE* f, Node* node, int indent)
     print_indent_tree(f, NCAR(node), indent + add);
     while (IS_NOT_NULL(node = NCDR(node))) {
       if (NTYPE(node) != type) {
-	fprintf(f, "ERROR: list/alt right is not a cons. %d\n", NTYPE(node));
-	exit(0);
+        fprintf(f, "ERROR: list/alt right is not a cons. %d\n", NTYPE(node));
+        exit(0);
       }
       print_indent_tree(f, NCAR(node), indent + add);
     }
@@ -6144,12 +6144,12 @@ print_indent_tree(FILE* f, Node* node, int indent)
 
   case NT_STR:
     fprintf(f, "<string%s:%x>",
-	    (NSTRING_IS_RAW(node) ? "-raw" : ""), (int )node);
+            (NSTRING_IS_RAW(node) ? "-raw" : ""), (int )node);
     for (p = NSTR(node)->s; p < NSTR(node)->end; p++) {
       if (*p >= 0x20 && *p < 0x7f)
-	fputc(*p, f);
+        fputc(*p, f);
       else {
-	fprintf(f, " 0x%02x", *p);
+        fprintf(f, " 0x%02x", *p);
       }
     }
     break;
@@ -6160,8 +6160,8 @@ print_indent_tree(FILE* f, Node* node, int indent)
     if (NCCLASS(node)->mbuf) {
       BBuf* bbuf = NCCLASS(node)->mbuf;
       for (i = 0; i < bbuf->used; i++) {
-	if (i > 0) fprintf(f, ",");
-	fprintf(f, "%0x", bbuf->p[i]);
+        if (i > 0) fprintf(f, ",");
+        fprintf(f, "%0x", bbuf->p[i]);
       }
     }
     break;
@@ -6171,9 +6171,9 @@ print_indent_tree(FILE* f, Node* node, int indent)
     switch (NCTYPE(node)->ctype) {
     case ONIGENC_CTYPE_WORD:
       if (NCTYPE(node)->not != 0)
-	fputs("not word",       f);
+        fputs("not word",       f);
       else
-	fputs("word",           f);
+        fputs("word",           f);
       break;
 
     default:
@@ -6220,8 +6220,8 @@ print_indent_tree(FILE* f, Node* node, int indent)
       p = BACKREFS_P(br);
       fprintf(f, "<backref:%x>", (int )node);
       for (i = 0; i < br->back_num; i++) {
-	if (i > 0) fputs(", ", f);
-	fprintf(f, "%d", p[i]);
+        if (i > 0) fputs(", ", f);
+        fprintf(f, "%d", p[i]);
       }
     }
     break;
@@ -6238,8 +6238,8 @@ print_indent_tree(FILE* f, Node* node, int indent)
 
   case NT_QTFR:
     fprintf(f, "<quantifier:%x>{%d,%d}%s\n", (int )node,
-	    NQTFR(node)->lower, NQTFR(node)->upper,
-	    (NQTFR(node)->greedy ? "" : "?"));
+            NQTFR(node)->lower, NQTFR(node)->upper,
+            (NQTFR(node)->greedy ? "" : "?"));
     print_indent_tree(f, NQTFR(node)->target, indent + add);
     break;
 
diff --git a/src/regenc.c b/src/regenc.c
index 70978cde8..3764a694f 100644
--- a/src/regenc.c
+++ b/src/regenc.c
@@ -84,7 +84,7 @@ onigenc_get_right_adjust_char_head(OnigEncoding enc, const UChar* start, const U
 
 extern UChar*
 onigenc_get_right_adjust_char_head_with_prev(OnigEncoding enc,
-				   const UChar* start, const UChar* s, const UChar* end, const UChar** prev)
+                                   const UChar* start, const UChar* s, const UChar* end, const UChar** prev)
 {
   UChar* p = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, start, s, end);
 
@@ -418,8 +418,8 @@ const OnigPairCaseFoldCodes OnigAsciiLowerMap[] = {
 
 extern int
 onigenc_ascii_apply_all_case_fold(OnigCaseFoldType flag ARG_UNUSED,
-				  OnigApplyAllCaseFoldFunc f, void* arg,
-				  OnigEncoding enc ARG_UNUSED)
+                                  OnigApplyAllCaseFoldFunc f, void* arg,
+                                  OnigEncoding enc ARG_UNUSED)
 {
   OnigCodePoint code;
   int i, r;
@@ -462,7 +462,7 @@ onigenc_ascii_get_case_fold_codes_by_str(OnigCaseFoldType flag ARG_UNUSED,
 
 static int
 ss_apply_all_case_fold(OnigCaseFoldType flag ARG_UNUSED,
-		       OnigApplyAllCaseFoldFunc f, void* arg)
+                       OnigApplyAllCaseFoldFunc f, void* arg)
 {
   OnigCodePoint ss[] = { 0x73, 0x73 };
 
@@ -508,7 +508,7 @@ onigenc_get_case_fold_codes_by_str_with_map(int map_size,
     items[0].code_len = 1;
     items[0].code[0] = (OnigCodePoint )(*p + 0x20);
     if (*p == 0x53 && ess_tsett_flag != 0 && end > p + 1
-	&& (*(p+1) == 0x53 || *(p+1) == 0x73)) {
+        && (*(p+1) == 0x53 || *(p+1) == 0x73)) {
       /* SS */
       items[1].byte_len = 2;
       items[1].code_len = 1;
@@ -523,7 +523,7 @@ onigenc_get_case_fold_codes_by_str_with_map(int map_size,
     items[0].code_len = 1;
     items[0].code[0] = (OnigCodePoint )(*p - 0x20);
     if (*p == 0x73 && ess_tsett_flag != 0 && end > p + 1
-	&& (*(p+1) == 0x73 || *(p+1) == 0x53)) {
+        && (*(p+1) == 0x73 || *(p+1) == 0x53)) {
       /* ss */
       items[1].byte_len = 2;
       items[1].code_len = 1;
@@ -561,16 +561,16 @@ onigenc_get_case_fold_codes_by_str_with_map(int map_size,
 
     for (i = 0; i < map_size; i++) {
       if (*p == map[i].from) {
-	items[0].byte_len = 1;
-	items[0].code_len = 1;
-	items[0].code[0] = map[i].to;
-	return 1;
+        items[0].byte_len = 1;
+        items[0].code_len = 1;
+        items[0].code[0] = map[i].to;
+        return 1;
       }
       else if (*p == map[i].to) {
-	items[0].byte_len = 1;
-	items[0].code_len = 1;
-	items[0].code[0] = map[i].from;
-	return 1;
+        items[0].byte_len = 1;
+        items[0].code_len = 1;
+        items[0].code[0] = map[i].from;
+        return 1;
       }
     }
   }
@@ -582,7 +582,7 @@ onigenc_get_case_fold_codes_by_str_with_map(int map_size,
 extern int
 onigenc_not_support_get_ctype_code_range(OnigCtype ctype,
                        OnigCodePoint* sb_out, const OnigCodePoint* ranges[],
-		       OnigEncoding enc)
+                       OnigEncoding enc)
 {
   return ONIG_NO_SUPPORT_CONFIG;
 }
@@ -599,7 +599,7 @@ onigenc_is_mbc_newline_0x0a(const UChar* p, const UChar* end, OnigEncoding enc A
 /* for single byte encodings */
 extern int
 onigenc_ascii_mbc_case_fold(OnigCaseFoldType flag ARG_UNUSED, const UChar** p,
-			    const UChar*end, UChar* lower, OnigEncoding enc ARG_UNUSED)
+                            const UChar*end, UChar* lower, OnigEncoding enc ARG_UNUSED)
 {
   *lower = ONIGENC_ASCII_CODE_TO_LOWER_CASE(**p);
 
@@ -609,14 +609,14 @@ onigenc_ascii_mbc_case_fold(OnigCaseFoldType flag ARG_UNUSED, const UChar** p,
 
 extern int
 onigenc_single_byte_mbc_enc_len(const UChar* p ARG_UNUSED, const UChar* e ARG_UNUSED,
-				OnigEncoding enc ARG_UNUSED)
+                                OnigEncoding enc ARG_UNUSED)
 {
   return 1;
 }
 
 extern OnigCodePoint
 onigenc_single_byte_mbc_to_code(const UChar* p, const UChar* end ARG_UNUSED,
-				OnigEncoding enc ARG_UNUSED)
+                                OnigEncoding enc ARG_UNUSED)
 {
   return (OnigCodePoint )(*p);
 }
@@ -637,21 +637,21 @@ onigenc_single_byte_code_to_mbc(OnigCodePoint code, UChar *buf, OnigEncoding enc
 extern UChar*
 onigenc_single_byte_left_adjust_char_head(const UChar* start ARG_UNUSED, const UChar* s,
                                           const UChar* end,
-					  OnigEncoding enc ARG_UNUSED)
+                                          OnigEncoding enc ARG_UNUSED)
 {
   return (UChar* )s;
 }
 
 extern int
 onigenc_always_true_is_allowed_reverse_match(const UChar* s ARG_UNUSED, const UChar* end ARG_UNUSED,
-					     OnigEncoding enc ARG_UNUSED)
+                                             OnigEncoding enc ARG_UNUSED)
 {
   return TRUE;
 }
 
 extern int
 onigenc_always_false_is_allowed_reverse_match(const UChar* s ARG_UNUSED, const UChar* end ARG_UNUSED,
-					      OnigEncoding enc ARG_UNUSED)
+                                              OnigEncoding enc ARG_UNUSED)
 {
   return FALSE;
 }
@@ -687,7 +687,7 @@ onigenc_mbn_mbc_to_code(OnigEncoding enc, const UChar* p, const UChar* end)
 extern int
 onigenc_mbn_mbc_case_fold(OnigEncoding enc, OnigCaseFoldType flag ARG_UNUSED,
                           const UChar** pp, const UChar* end ARG_UNUSED,
-			  UChar* lower)
+                          UChar* lower)
 {
   int len;
   const UChar *p = *pp;
@@ -796,7 +796,7 @@ onigenc_minimum_property_name_to_ctype(OnigEncoding enc, UChar* p, UChar* end)
 
 extern int
 onigenc_mb2_is_code_ctype(OnigEncoding enc, OnigCodePoint code,
-			  unsigned int ctype)
+                          unsigned int ctype)
 {
   if (code < 128)
     return ONIGENC_IS_ASCII_CODE_CTYPE(code, ctype);
@@ -811,7 +811,7 @@ onigenc_mb2_is_code_ctype(OnigEncoding enc, OnigCodePoint code,
 
 extern int
 onigenc_mb4_is_code_ctype(OnigEncoding enc, OnigCodePoint code,
-			  unsigned int ctype)
+                          unsigned int ctype)
 {
   if (code < 128)
     return ONIGENC_IS_ASCII_CODE_CTYPE(code, ctype);
@@ -890,7 +890,7 @@ onigenc_property_list_add_property(UChar* name, const OnigCodePoint* prop,
 
   *pnum = *pnum + 1;
   onig_st_insert_strend(*table, name, name + strlen((char* )name),
-			(hash_data_type )(*pnum + ONIGENC_MAX_STD_CTYPE));
+                        (hash_data_type )(*pnum + ONIGENC_MAX_STD_CTYPE));
   return 0;
 }
 
diff --git a/src/regenc.h b/src/regenc.h
index 1d8e752bc..4e827d181 100644
--- a/src/regenc.h
+++ b/src/regenc.h
@@ -182,12 +182,12 @@ ONIG_EXTERN const unsigned short OnigEncAsciiCtypeTable[];
 extern int ONIG_ENC_REGISTER(const char *, OnigEncodingType*);
 #define OnigEncodingName(n) encoding_##n
 #define OnigEncodingDeclare(n) static OnigEncodingType OnigEncodingName(n)
-#define OnigEncodingDefine(f,n)			     \
-    OnigEncodingDeclare(n);			     \
-    void Init_##f(void) {			     \
-	ONIG_ENC_REGISTER(OnigEncodingName(n).name,  \
-			  &OnigEncodingName(n));     \
-    }						     \
+#define OnigEncodingDefine(f,n)                      \
+    OnigEncodingDeclare(n);                          \
+    void Init_##f(void) {                            \
+        ONIG_ENC_REGISTER(OnigEncodingName(n).name,  \
+                          &OnigEncodingName(n));     \
+    }                                                \
     OnigEncodingDeclare(n)
 #else
 #define OnigEncodingName(n) OnigEncoding##n
diff --git a/src/regerror.c b/src/regerror.c
index 72db3a502..2ba879f78 100644
--- a/src/regerror.c
+++ b/src/regerror.c
@@ -189,7 +189,7 @@ static void sprint_byte_with_x(char* s, unsigned int v)
 }
 
 static int to_ascii(OnigEncoding enc, UChar *s, UChar *end,
-		    UChar buf[], int buf_size, int *is_over)
+                    UChar buf[], int buf_size, int *is_over)
 {
   int len;
   UChar *p;
@@ -201,24 +201,24 @@ static int to_ascii(OnigEncoding enc, UChar *s, UChar *end,
     while (p < end) {
       code = ONIGENC_MBC_TO_CODE(enc, p, end);
       if (code >= 0x80) {
-	if (code > 0xffff && len + 10 <= buf_size) {
-	  sprint_byte_with_x((char*)(&(buf[len])), (unsigned int)(code >> 24));
-	  sprint_byte((char*)(&(buf[len+4])),      (unsigned int)(code >> 16));
-	  sprint_byte((char*)(&(buf[len+6])),      (unsigned int)(code >>  8));
-	  sprint_byte((char*)(&(buf[len+8])),      (unsigned int)code);
-	  len += 10;
-	}
-	else if (len + 6 <= buf_size) {
-	  sprint_byte_with_x((char*)(&(buf[len])), (unsigned int)(code >> 8));
-	  sprint_byte((char*)(&(buf[len+4])),      (unsigned int)code);
-	  len += 6;
-	}
-	else {
-	  break;
-	}
+        if (code > 0xffff && len + 10 <= buf_size) {
+          sprint_byte_with_x((char*)(&(buf[len])), (unsigned int)(code >> 24));
+          sprint_byte((char*)(&(buf[len+4])),      (unsigned int)(code >> 16));
+          sprint_byte((char*)(&(buf[len+6])),      (unsigned int)(code >>  8));
+          sprint_byte((char*)(&(buf[len+8])),      (unsigned int)code);
+          len += 10;
+        }
+        else if (len + 6 <= buf_size) {
+          sprint_byte_with_x((char*)(&(buf[len])), (unsigned int)(code >> 8));
+          sprint_byte((char*)(&(buf[len+4])),      (unsigned int)code);
+          len += 6;
+        }
+        else {
+          break;
+        }
       }
       else {
-	buf[len++] = (UChar )code;
+        buf[len++] = (UChar )code;
       }
 
       p += enclen(enc, p, end);
@@ -262,27 +262,27 @@ onig_error_code_to_str(UChar* s, int code, ...)
   case ONIGERR_INVALID_CHAR_PROPERTY_NAME:
     einfo = va_arg(vargs, OnigErrorInfo*);
     len = to_ascii(einfo->enc, einfo->par, einfo->par_end,
-		   parbuf, MAX_ERROR_PAR_LEN - 3, &is_over);
+                   parbuf, MAX_ERROR_PAR_LEN - 3, &is_over);
     q = onig_error_code_to_format(code);
     p = s;
     while (*q != '\0') {
       if (*q == '%') {
-	q++;
-	if (*q == 'n') { /* '%n': name */
-	  xmemcpy(p, parbuf, len);
-	  p += len;
-	  if (is_over != 0) {
-	    xmemcpy(p, "...", 3);
-	    p += 3;
-	  }
-	  q++;
-	}
-	else
-	  goto normal_char;
+        q++;
+        if (*q == 'n') { /* '%n': name */
+          xmemcpy(p, parbuf, len);
+          p += len;
+          if (is_over != 0) {
+            xmemcpy(p, "...", 3);
+            p += 3;
+          }
+          q++;
+        }
+        else
+          goto normal_char;
       }
       else {
       normal_char:
-	*p++ = *q++;
+        *p++ = *q++;
       }
     }
     *p = '\0';
@@ -321,13 +321,13 @@ onig_vsnprintf_with_pattern(UChar buf[], int bufsize, OnigEncoding enc,
     p = pat;
     while (p < pat_end) {
       if (*p == '\\') {
-	*s++ = *p++;
-	len = enclen(enc, p, pat_end);
-	while (len-- > 0) *s++ = *p++;
+        *s++ = *p++;
+        len = enclen(enc, p, pat_end);
+        while (len-- > 0) *s++ = *p++;
       }
       else if (*p == '/') {
-	*s++ = (unsigned char )'\\';
-	*s++ = *p++;
+        *s++ = (unsigned char )'\\';
+        *s++ = *p++;
       }
       else if (ONIGENC_IS_MBC_HEAD(enc, p, pat_end)) {
         len = enclen(enc, p, pat_end);
@@ -346,14 +346,14 @@ onig_vsnprintf_with_pattern(UChar buf[], int bufsize, OnigEncoding enc,
         }
       }
       else if (!ONIGENC_IS_CODE_PRINT(enc, *p) &&
-	       !ONIGENC_IS_CODE_SPACE(enc, *p)) {
-	sprint_byte_with_x((char* )bs, (unsigned int )(*p++));
-	len = onigenc_str_bytelen_null(ONIG_ENCODING_ASCII, bs);
+               !ONIGENC_IS_CODE_SPACE(enc, *p)) {
+        sprint_byte_with_x((char* )bs, (unsigned int )(*p++));
+        len = onigenc_str_bytelen_null(ONIG_ENCODING_ASCII, bs);
         bp = bs;
-	while (len-- > 0) *s++ = *bp++;
+        while (len-- > 0) *s++ = *bp++;
       }
       else {
-	*s++ = *p++;
+        *s++ = *p++;
       }
     }
 
@@ -369,7 +369,7 @@ onig_snprintf_with_pattern(UChar buf[], int bufsize, OnigEncoding enc,
   va_list args;
   va_start(args, fmt);
   onig_vsnprintf_with_pattern(buf, bufsize, enc,
-	  pat, pat_end, fmt, args);
+          pat, pat_end, fmt, args);
   va_end(args);
 }
 #endif //INCLUDE_REGEXP
diff --git a/src/regex.h b/src/regex.h
index 0669e6f70..4cdad2a33 100644
--- a/src/regex.h
+++ b/src/regex.h
@@ -1,6 +1,6 @@
 /*
 ** regex.h - Regexp class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/regexec.c b/src/regexec.c
index 3ef38bc8f..9b3929bb0 100644
--- a/src/regexec.c
+++ b/src/regexec.c
@@ -357,7 +357,7 @@ onig_region_copy(OnigRegion* to, OnigRegion* from)
 
 #define STATE_CHECK_BUFF_MALLOC_THRESHOLD_SIZE  16
 
-#define STATE_CHECK_BUFF_INIT(msa, str_len, offset, state_num) do {	\
+#define STATE_CHECK_BUFF_INIT(msa, str_len, offset, state_num) do {     \
   if ((state_num) > 0 && str_len >= STATE_CHECK_STRING_THRESHOLD_LEN) {\
     unsigned int size = (unsigned int )(((str_len) + 1) * (state_num) + 7) >> 3;\
     offset = ((offset) * (state_num)) >> 3;\
@@ -405,7 +405,7 @@ onig_region_copy(OnigRegion* to, OnigRegion* from)
   }\
   else {\
     alloc_addr = (char* )xalloca(sizeof(char*) * (ptr_num)\
-		       + sizeof(OnigStackType) * (stack_num));\
+                       + sizeof(OnigStackType) * (stack_num));\
     stk_alloc  = (OnigStackType* )(alloc_addr + sizeof(char*) * (ptr_num));\
     stk_base   = stk_alloc;\
     stk        = stk_base;\
@@ -437,7 +437,7 @@ onig_set_match_stack_limit_size(unsigned int size)
 
 static int
 stack_double(OnigStackType** arg_stk_base, OnigStackType** arg_stk_end,
-	     OnigStackType** arg_stk, OnigStackType* stk_alloc, OnigMatchArg* msa)
+             OnigStackType** arg_stk, OnigStackType* stk_alloc, OnigMatchArg* msa)
 {
   size_t n;
   OnigStackType *x, *stk_base, *stk_end, *stk;
@@ -477,7 +477,7 @@ stack_double(OnigStackType** arg_stk_base, OnigStackType** arg_stk_end,
   return 0;
 }
 
-#define STACK_ENSURE(n)	do {\
+#define STACK_ENSURE(n) do {\
   if (stk_end - stk < (n)) {\
     int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\
     if (r != 0) { STACK_SAVE; return r; } \
@@ -510,7 +510,7 @@ stack_double(OnigStackType** arg_stk_base, OnigStackType** arg_stk_end,
 #define ELSE_IF_STATE_CHECK_MARK(stk) \
   else if ((stk)->type == STK_STATE_CHECK_MARK) { \
     int x = STATE_CHECK_POS(stk->u.state.pstr, stk->u.state.state_check);\
-    state_check_buff[x/8] |= (1<<(x%8));				\
+    state_check_buff[x/8] |= (1<<(x%8));                                \
   }
 
 #define STACK_PUSH(stack_type,pat,s,sprev) do {\
@@ -882,7 +882,7 @@ stack_double(OnigStackType** arg_stk_base, OnigStackType** arg_stk_end,
             }\
             k++;\
           }\
-	  break;\
+          break;\
         }\
       }\
     }\
@@ -923,7 +923,7 @@ stack_double(OnigStackType** arg_stk_base, OnigStackType** arg_stk_end,
               }\
               k++;\
             }\
-	    break;\
+            break;\
           }\
         }\
         else {\
@@ -986,7 +986,7 @@ stack_double(OnigStackType** arg_stk_base, OnigStackType** arg_stk_end,
 } while(0)
 
 static int string_cmp_ic(OnigEncoding enc, int case_fold_flag,
-			 UChar* s1, UChar** ps2, int mblen, const UChar* text_end)
+                         UChar* s1, UChar** ps2, int mblen, const UChar* text_end)
 {
   UChar buf1[ONIGENC_MBC_CASE_FOLD_MAXLEN];
   UChar buf2[ONIGENC_MBC_CASE_FOLD_MAXLEN];
@@ -1099,9 +1099,9 @@ static int mem_is_in_memp(int mem, int num, UChar* memp)
 }
 
 static int backref_match_at_nested_level(regex_t* reg
-	 , OnigStackType* top, OnigStackType* stk_base
-	 , int ignore_case, int case_fold_flag
-	 , int nest, int mem_num, UChar* memp, UChar** s, const UChar* send)
+         , OnigStackType* top, OnigStackType* stk_base
+         , int ignore_case, int case_fold_flag
+         , int nest, int mem_num, UChar* memp, UChar** s, const UChar* send)
 {
   UChar *ss, *p, *pstart, *pend = NULL_UCHARP;
   int level;
@@ -1119,33 +1119,33 @@ static int backref_match_at_nested_level(regex_t* reg
     }
     else if (level == nest) {
       if (k->type == STK_MEM_START) {
-	if (mem_is_in_memp(k->u.mem.num, mem_num, memp)) {
-	  pstart = k->u.mem.pstr;
-	  if (pend != NULL_UCHARP) {
-	    if (pend - pstart > send - *s) return 0; /* or goto next_mem; */
-	    p  = pstart;
-	    ss = *s;
-
-	    if (ignore_case != 0) {
-	      if (string_cmp_ic(reg->enc, case_fold_flag,
-				pstart, &ss, (int )(pend - pstart), send) == 0)
-		return 0; /* or goto next_mem; */
-	    }
-	    else {
-	      while (p < pend) {
-		if (*p++ != *ss++) return 0; /* or goto next_mem; */
-	      }
-	    }
-
-	    *s = ss;
-	    return 1;
-	  }
-	}
+        if (mem_is_in_memp(k->u.mem.num, mem_num, memp)) {
+          pstart = k->u.mem.pstr;
+          if (pend != NULL_UCHARP) {
+            if (pend - pstart > send - *s) return 0; /* or goto next_mem; */
+            p  = pstart;
+            ss = *s;
+
+            if (ignore_case != 0) {
+              if (string_cmp_ic(reg->enc, case_fold_flag,
+                                pstart, &ss, (int )(pend - pstart), send) == 0)
+                return 0; /* or goto next_mem; */
+            }
+            else {
+              while (p < pend) {
+                if (*p++ != *ss++) return 0; /* or goto next_mem; */
+              }
+            }
+
+            *s = ss;
+            return 1;
+          }
+        }
       }
       else if (k->type == STK_MEM_END) {
-	if (mem_is_in_memp(k->u.mem.num, mem_num, memp)) {
-	  pend = k->u.mem.pstr;
-	}
+        if (mem_is_in_memp(k->u.mem.num, mem_num, memp)) {
+          pend = k->u.mem.pstr;
+        }
       }
     }
     k--;
@@ -1216,7 +1216,7 @@ onig_print_statistics(FILE* f)
   fprintf(f, "   count      prev        time\n");
   for (i = 0; OnigOpInfo[i].opcode >= 0; i++) {
     fprintf(f, "%8d: %8d: %10ld: %s\n",
-	    OpCounter[i], OpPrevCounter[i], OpTime[i], OnigOpInfo[i].name);
+            OpCounter[i], OpPrevCounter[i], OpTime[i], OnigOpInfo[i].name);
   }
   fprintf(f, "\nmax stack depth: %d\n", MaxStackDepth);
 }
@@ -1248,9 +1248,9 @@ typedef struct {
 static long
 match_at(regex_t* reg, const UChar* str, const UChar* end,
 #ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
-	 const UChar* right_range,
+         const UChar* right_range,
 #endif
-	 const UChar* sstart, UChar* sprev, OnigMatchArg* msa)
+         const UChar* sstart, UChar* sprev, OnigMatchArg* msa)
 {
   static const UChar FinishCode[] = { OP_FINISH };
 
@@ -1284,18 +1284,18 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
   mem_start_stk = (OnigStackIndex* )(repeat_stk + reg->num_repeat);
   mem_end_stk   = mem_start_stk + num_mem;
   mem_start_stk--; /* for index start from 1,
-		      mem_start_stk[1]..mem_start_stk[num_mem] */
+                      mem_start_stk[1]..mem_start_stk[num_mem] */
   mem_end_stk--;   /* for index start from 1,
-		      mem_end_stk[1]..mem_end_stk[num_mem] */
+                      mem_end_stk[1]..mem_end_stk[num_mem] */
   for (i = 1; i <= num_mem; i++) {
     mem_start_stk[i] = mem_end_stk[i] = INVALID_STACK_INDEX;
   }
 
 #ifdef ONIG_DEBUG_MATCH
   fprintf(stderr, "match_at: str: %d, end: %d, start: %d, sprev: %d\n",
-	  (int )str, (int )end, (int )sstart, (int )sprev);
+          (int )str, (int )end, (int )sstart, (int )sprev);
   fprintf(stderr, "size: %d, start offset: %d\n",
-	  (int )(end - str), (int )(sstart - str));
+          (int )(end - str), (int )(sstart - str));
 #endif
 
   STACK_PUSH_ENSURED(STK_ALT, (UChar *)FinishCode);  /* bottom stack */
@@ -1309,8 +1309,8 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
       fprintf(stderr, "%4d> \"", (int )(s - str));
       bp = buf;
       for (i = 0, q = s; i < 7 && q < end; i++) {
-	len = enclen(encode, q, end);
-	while (len-- > 0) *bp++ = *q++;
+        len = enclen(encode, q, end);
+        while (len-- > 0) *bp++ = *q++;
       }
       if (q < end) { xmemcpy(bp, "...\"", 4); bp += 4; }
       else         { xmemcpy(bp, "\"",    1); bp += 1; }
@@ -1327,40 +1327,40 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
     case OP_END:  MOP_IN(OP_END);
       n = s - sstart;
       if (n > best_len) {
-	OnigRegion* region;
+        OnigRegion* region;
 #ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
-	if (IS_FIND_LONGEST(option)) {
-	  if (n > msa->best_len) {
-	    msa->best_len = n;
-	    msa->best_s   = (UChar* )sstart;
-	  }
-	  else
-	    goto end_best_len;
+        if (IS_FIND_LONGEST(option)) {
+          if (n > msa->best_len) {
+            msa->best_len = n;
+            msa->best_s   = (UChar* )sstart;
+          }
+          else
+            goto end_best_len;
         }
 #endif
-	best_len = n;
-	region = msa->region;
-	if (region) {
-	    region->beg[0] = sstart - str;
-	    region->end[0] = s      - str;
-	    for (i = 1; i <= num_mem; i++) {
-	      if (mem_end_stk[i] != INVALID_STACK_INDEX) {
-		if (BIT_STATUS_AT(reg->bt_mem_start, i))
-		  region->beg[i] = STACK_AT(mem_start_stk[i])->u.mem.pstr - str;
-		else
-		  region->beg[i] = (UChar* )((void* )mem_start_stk[i]) - str;
-
-		region->end[i] = (BIT_STATUS_AT(reg->bt_mem_end, i)
-				  ? STACK_AT(mem_end_stk[i])->u.mem.pstr
-				  : (UChar* )((void* )mem_end_stk[i])) - str;
-	      }
-	      else {
-		region->beg[i] = region->end[i] = ONIG_REGION_NOTPOS;
-	      }
-	    }
+        best_len = n;
+        region = msa->region;
+        if (region) {
+            region->beg[0] = sstart - str;
+            region->end[0] = s      - str;
+            for (i = 1; i <= num_mem; i++) {
+              if (mem_end_stk[i] != INVALID_STACK_INDEX) {
+                if (BIT_STATUS_AT(reg->bt_mem_start, i))
+                  region->beg[i] = STACK_AT(mem_start_stk[i])->u.mem.pstr - str;
+                else
+                  region->beg[i] = (UChar* )((void* )mem_start_stk[i]) - str;
+
+                region->end[i] = (BIT_STATUS_AT(reg->bt_mem_end, i)
+                                  ? STACK_AT(mem_end_stk[i])->u.mem.pstr
+                                  : (UChar* )((void* )mem_end_stk[i])) - str;
+              }
+              else {
+                region->beg[i] = region->end[i] = ONIG_REGION_NOTPOS;
+              }
+            }
 
 #ifdef USE_CAPTURE_HISTORY
-	    if (reg->capture_history != 0) {
+            if (reg->capture_history != 0) {
               int r;
               OnigCaptureTreeNode* node;
 
@@ -1384,9 +1384,9 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
                 best_len = r; /* error code */
                 goto finish;
               }
-	    }
+            }
 #endif /* USE_CAPTURE_HISTORY */
-	} /* if (region) */
+        } /* if (region) */
       } /* n > best_len */
 
 #ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
@@ -1395,13 +1395,13 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
       MOP_OUT;
 
       if (IS_FIND_CONDITION(option)) {
-	if (IS_FIND_NOT_EMPTY(option) && s == sstart) {
-	  best_len = ONIG_MISMATCH;
-	  goto fail; /* for retry */
-	}
-	if (IS_FIND_LONGEST(option) && DATA_ENSURE_CHECK1) {
-	  goto fail; /* for retry */
-	}
+        if (IS_FIND_NOT_EMPTY(option) && s == sstart) {
+          best_len = ONIG_MISMATCH;
+          goto fail; /* for retry */
+        }
+        if (IS_FIND_LONGEST(option) && DATA_ENSURE_CHECK1) {
+          goto fail; /* for retry */
+        }
       }
 
       /* default behavior: return first-matching result. */
@@ -1417,22 +1417,22 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 
     case OP_EXACT1_IC:  MOP_IN(OP_EXACT1_IC);
       {
-	int len;
-	UChar *q, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN];
-
-	DATA_ENSURE(1);
-	len = ONIGENC_MBC_CASE_FOLD(encode,
-		    /* DISABLE_CASE_FOLD_MULTI_CHAR(case_fold_flag), */
-		    case_fold_flag,
-		    &s, end, lowbuf);
-	DATA_ENSURE(0);
-	q = lowbuf;
-	while (len-- > 0) {
-	  if (*p != *q) {
+        int len;
+        UChar *q, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN];
+
+        DATA_ENSURE(1);
+        len = ONIGENC_MBC_CASE_FOLD(encode,
+                    /* DISABLE_CASE_FOLD_MULTI_CHAR(case_fold_flag), */
+                    case_fold_flag,
+                    &s, end, lowbuf);
+        DATA_ENSURE(0);
+        q = lowbuf;
+        while (len-- > 0) {
+          if (*p != *q) {
             goto fail;
           }
-	  p++; q++;
-	}
+          p++; q++;
+        }
       }
       MOP_OUT;
       break;
@@ -1497,7 +1497,7 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
       GET_LENGTH_INC(tlen, p);
       DATA_ENSURE(tlen);
       while (tlen-- > 0) {
-	if (*p++ != *s++) goto fail;
+        if (*p++ != *s++) goto fail;
       }
       sprev = s - 1;
       MOP_OUT;
@@ -1506,26 +1506,26 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 
     case OP_EXACTN_IC:  MOP_IN(OP_EXACTN_IC);
       {
-	int len;
-	UChar *q, *endp, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN];
+        int len;
+        UChar *q, *endp, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN];
 
-	GET_LENGTH_INC(tlen, p);
-	endp = p + tlen;
+        GET_LENGTH_INC(tlen, p);
+        endp = p + tlen;
 
-	while (p < endp) {
-	  sprev = s;
-	  DATA_ENSURE(1);
-	  len = ONIGENC_MBC_CASE_FOLD(encode,
-		      /* DISABLE_CASE_FOLD_MULTI_CHAR(case_fold_flag), */
-		      case_fold_flag,
-		      &s, end, lowbuf);
-	  DATA_ENSURE(0);
-	  q = lowbuf;
-	  while (len-- > 0) {
-	    if (*p != *q) goto fail;
-	    p++; q++;
-	  }
-	}
+        while (p < endp) {
+          sprev = s;
+          DATA_ENSURE(1);
+          len = ONIGENC_MBC_CASE_FOLD(encode,
+                      /* DISABLE_CASE_FOLD_MULTI_CHAR(case_fold_flag), */
+                      case_fold_flag,
+                      &s, end, lowbuf);
+          DATA_ENSURE(0);
+          q = lowbuf;
+          while (len-- > 0) {
+            if (*p != *q) goto fail;
+            p++; q++;
+          }
+        }
       }
 
       MOP_OUT;
@@ -1579,10 +1579,10 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
       GET_LENGTH_INC(tlen, p);
       DATA_ENSURE(tlen * 2);
       while (tlen-- > 0) {
-	if (*p != *s) goto fail;
-	p++; s++;
-	if (*p != *s) goto fail;
-	p++; s++;
+        if (*p != *s) goto fail;
+        p++; s++;
+        if (*p != *s) goto fail;
+        p++; s++;
       }
       sprev = s - 2;
       MOP_OUT;
@@ -1593,12 +1593,12 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
       GET_LENGTH_INC(tlen, p);
       DATA_ENSURE(tlen * 3);
       while (tlen-- > 0) {
-	if (*p != *s) goto fail;
-	p++; s++;
-	if (*p != *s) goto fail;
-	p++; s++;
-	if (*p != *s) goto fail;
-	p++; s++;
+        if (*p != *s) goto fail;
+        p++; s++;
+        if (*p != *s) goto fail;
+        p++; s++;
+        if (*p != *s) goto fail;
+        p++; s++;
       }
       sprev = s - 3;
       MOP_OUT;
@@ -1611,8 +1611,8 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
       tlen2 *= tlen;
       DATA_ENSURE(tlen2);
       while (tlen2-- > 0) {
-	if (*p != *s) goto fail;
-	p++; s++;
+        if (*p != *s) goto fail;
+        p++; s++;
       }
       sprev = s - tlen;
       MOP_OUT;
@@ -1633,23 +1633,23 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
     cclass_mb:
       GET_LENGTH_INC(tlen, p);
       {
-	OnigCodePoint code;
-	UChar *ss;
-	int mb_len;
+        OnigCodePoint code;
+        UChar *ss;
+        int mb_len;
 
-	DATA_ENSURE(1);
-	mb_len = enclen(encode, s, end);
-	DATA_ENSURE(mb_len);
-	ss = s;
-	s += mb_len;
-	code = ONIGENC_MBC_TO_CODE(encode, ss, s);
+        DATA_ENSURE(1);
+        mb_len = enclen(encode, s, end);
+        DATA_ENSURE(mb_len);
+        ss = s;
+        s += mb_len;
+        code = ONIGENC_MBC_TO_CODE(encode, ss, s);
 
 #ifdef PLATFORM_UNALIGNED_WORD_ACCESS
-	if (! onig_is_in_code_range(p, code)) goto fail;
+        if (! onig_is_in_code_range(p, code)) goto fail;
 #else
-	q = p;
-	ALIGNMENT_RIGHT(q);
-	if (! onig_is_in_code_range(q, code)) goto fail;
+        q = p;
+        ALIGNMENT_RIGHT(q);
+        if (! onig_is_in_code_range(q, code)) goto fail;
 #endif
       }
       p += tlen;
@@ -1659,17 +1659,17 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
     case OP_CCLASS_MIX:  MOP_IN(OP_CCLASS_MIX);
       DATA_ENSURE(1);
       if (ONIGENC_IS_MBC_HEAD(encode, s, end)) {
-	p += SIZE_BITSET;
-	goto cclass_mb;
+        p += SIZE_BITSET;
+        goto cclass_mb;
       }
       else {
-	if (BITSET_AT(((BitSetRef )p), *s) == 0)
-	  goto fail;
+        if (BITSET_AT(((BitSetRef )p), *s) == 0)
+          goto fail;
 
-	p += SIZE_BITSET;
-	GET_LENGTH_INC(tlen, p);
-	p += tlen;
-	s++;
+        p += SIZE_BITSET;
+        GET_LENGTH_INC(tlen, p);
+        p += tlen;
+        s++;
       }
       MOP_OUT;
       break;
@@ -1685,36 +1685,36 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
     case OP_CCLASS_MB_NOT:  MOP_IN(OP_CCLASS_MB_NOT);
       DATA_ENSURE(1);
       if (! ONIGENC_IS_MBC_HEAD(encode, s, end)) {
-	s++;
-	GET_LENGTH_INC(tlen, p);
-	p += tlen;
-	goto cc_mb_not_success;
+        s++;
+        GET_LENGTH_INC(tlen, p);
+        p += tlen;
+        goto cc_mb_not_success;
       }
 
     cclass_mb_not:
       GET_LENGTH_INC(tlen, p);
       {
-	OnigCodePoint code;
-	UChar *ss;
-	int mb_len = enclen(encode, s, end);
+        OnigCodePoint code;
+        UChar *ss;
+        int mb_len = enclen(encode, s, end);
 
-	if (! DATA_ENSURE_CHECK(mb_len)) {
+        if (! DATA_ENSURE_CHECK(mb_len)) {
           DATA_ENSURE(1);
-	  s = (UChar* )end;
-	  p += tlen;
-	  goto cc_mb_not_success;
-	}
+          s = (UChar* )end;
+          p += tlen;
+          goto cc_mb_not_success;
+        }
 
-	ss = s;
-	s += mb_len;
-	code = ONIGENC_MBC_TO_CODE(encode, ss, s);
+        ss = s;
+        s += mb_len;
+        code = ONIGENC_MBC_TO_CODE(encode, ss, s);
 
 #ifdef PLATFORM_UNALIGNED_WORD_ACCESS
-	if (onig_is_in_code_range(p, code)) goto fail;
+        if (onig_is_in_code_range(p, code)) goto fail;
 #else
-	q = p;
-	ALIGNMENT_RIGHT(q);
-	if (onig_is_in_code_range(q, code)) goto fail;
+        q = p;
+        ALIGNMENT_RIGHT(q);
+        if (onig_is_in_code_range(q, code)) goto fail;
 #endif
       }
       p += tlen;
@@ -1726,36 +1726,36 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
     case OP_CCLASS_MIX_NOT:  MOP_IN(OP_CCLASS_MIX_NOT);
       DATA_ENSURE(1);
       if (ONIGENC_IS_MBC_HEAD(encode, s, end)) {
-	p += SIZE_BITSET;
-	goto cclass_mb_not;
+        p += SIZE_BITSET;
+        goto cclass_mb_not;
       }
       else {
-	if (BITSET_AT(((BitSetRef )p), *s) != 0)
-	  goto fail;
+        if (BITSET_AT(((BitSetRef )p), *s) != 0)
+          goto fail;
 
-	p += SIZE_BITSET;
-	GET_LENGTH_INC(tlen, p);
-	p += tlen;
-	s++;
+        p += SIZE_BITSET;
+        GET_LENGTH_INC(tlen, p);
+        p += tlen;
+        s++;
       }
       MOP_OUT;
       break;
 
     case OP_CCLASS_NODE:  MOP_IN(OP_CCLASS_NODE);
       {
-	OnigCodePoint code;
+        OnigCodePoint code;
         void *node;
         int mb_len;
         UChar *ss;
 
         DATA_ENSURE(1);
         GET_POINTER_INC(node, p);
-	mb_len = enclen(encode, s, end);
-	ss = s;
-	s += mb_len;
-	DATA_ENSURE(0);
-	code = ONIGENC_MBC_TO_CODE(encode, ss, s);
-	if (onig_is_code_in_cc_len(mb_len, code, node) == 0) goto fail;
+        mb_len = enclen(encode, s, end);
+        ss = s;
+        s += mb_len;
+        DATA_ENSURE(0);
+        code = ONIGENC_MBC_TO_CODE(encode, ss, s);
+        if (onig_is_code_in_cc_len(mb_len, code, node) == 0) goto fail;
       }
       MOP_OUT;
       break;
@@ -1779,8 +1779,8 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 
     case OP_ANYCHAR_STAR:  MOP_IN(OP_ANYCHAR_STAR);
       while (DATA_ENSURE_CHECK1) {
-	STACK_PUSH_ALT(p, s, sprev);
-	n = enclen(encode, s, end);
+        STACK_PUSH_ALT(p, s, sprev);
+        n = enclen(encode, s, end);
         DATA_ENSURE(n);
         if (ONIGENC_IS_MBC_NEWLINE(encode, s, end))  goto fail;
         sprev = s;
@@ -1791,27 +1791,27 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 
     case OP_ANYCHAR_ML_STAR:  MOP_IN(OP_ANYCHAR_ML_STAR);
       while (DATA_ENSURE_CHECK1) {
-	STACK_PUSH_ALT(p, s, sprev);
-	n = enclen(encode, s, end);
-	if (n > 1) {
-	  DATA_ENSURE(n);
-	  sprev = s;
-	  s += n;
-	}
-	else {
-	  sprev = s;
-	  s++;
-	}
+        STACK_PUSH_ALT(p, s, sprev);
+        n = enclen(encode, s, end);
+        if (n > 1) {
+          DATA_ENSURE(n);
+          sprev = s;
+          s += n;
+        }
+        else {
+          sprev = s;
+          s++;
+        }
       }
       MOP_OUT;
       break;
 
     case OP_ANYCHAR_STAR_PEEK_NEXT:  MOP_IN(OP_ANYCHAR_STAR_PEEK_NEXT);
       while (DATA_ENSURE_CHECK1) {
-	if (*p == *s) {
-	  STACK_PUSH_ALT(p + 1, s, sprev);
-	}
-	n = enclen(encode, s, end);
+        if (*p == *s) {
+          STACK_PUSH_ALT(p + 1, s, sprev);
+        }
+        n = enclen(encode, s, end);
         DATA_ENSURE(n);
         if (ONIGENC_IS_MBC_NEWLINE(encode, s, end))  goto fail;
         sprev = s;
@@ -1823,19 +1823,19 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 
     case OP_ANYCHAR_ML_STAR_PEEK_NEXT:MOP_IN(OP_ANYCHAR_ML_STAR_PEEK_NEXT);
       while (DATA_ENSURE_CHECK1) {
-	if (*p == *s) {
-	  STACK_PUSH_ALT(p + 1, s, sprev);
-	}
-	n = enclen(encode, s, end);
-	if (n > 1) {
-	  DATA_ENSURE(n);
-	  sprev = s;
-	  s += n;
-	}
-	else {
-	  sprev = s;
-	  s++;
-	}
+        if (*p == *s) {
+          STACK_PUSH_ALT(p + 1, s, sprev);
+        }
+        n = enclen(encode, s, end);
+        if (n > 1) {
+          DATA_ENSURE(n);
+          sprev = s;
+          s += n;
+        }
+        else {
+          sprev = s;
+          s++;
+        }
       }
       p++;
       MOP_OUT;
@@ -1845,11 +1845,11 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
     case OP_STATE_CHECK_ANYCHAR_STAR:  MOP_IN(OP_STATE_CHECK_ANYCHAR_STAR);
       GET_STATE_CHECK_NUM_INC(mem, p);
       while (DATA_ENSURE_CHECK1) {
-	STATE_CHECK_VAL(scv, mem);
-	if (scv) goto fail;
+        STATE_CHECK_VAL(scv, mem);
+        if (scv) goto fail;
 
-	STACK_PUSH_ALT_WITH_STATE_CHECK(p, s, sprev, mem);
-	n = enclen(encode, s, end);
+        STACK_PUSH_ALT_WITH_STATE_CHECK(p, s, sprev, mem);
+        n = enclen(encode, s, end);
         DATA_ENSURE(n);
         if (ONIGENC_IS_MBC_NEWLINE(encode, s, end))  goto fail;
         sprev = s;
@@ -1863,20 +1863,20 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 
       GET_STATE_CHECK_NUM_INC(mem, p);
       while (DATA_ENSURE_CHECK1) {
-	STATE_CHECK_VAL(scv, mem);
-	if (scv) goto fail;
-
-	STACK_PUSH_ALT_WITH_STATE_CHECK(p, s, sprev, mem);
-	n = enclen(encode, s, end);
-	if (n > 1) {
-	  DATA_ENSURE(n);
-	  sprev = s;
-	  s += n;
-	}
-	else {
-	  sprev = s;
-	  s++;
-	}
+        STATE_CHECK_VAL(scv, mem);
+        if (scv) goto fail;
+
+        STACK_PUSH_ALT_WITH_STATE_CHECK(p, s, sprev, mem);
+        n = enclen(encode, s, end);
+        if (n > 1) {
+          DATA_ENSURE(n);
+          sprev = s;
+          s += n;
+        }
+        else {
+          sprev = s;
+          s++;
+        }
       }
       MOP_OUT;
       break;
@@ -1885,7 +1885,7 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
     case OP_WORD:  MOP_IN(OP_WORD);
       DATA_ENSURE(1);
       if (! ONIGENC_IS_MBC_WORD(encode, s, end))
-	goto fail;
+        goto fail;
 
       s += enclen(encode, s, end);
       MOP_OUT;
@@ -1894,7 +1894,7 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
     case OP_NOT_WORD:  MOP_IN(OP_NOT_WORD);
       DATA_ENSURE(1);
       if (ONIGENC_IS_MBC_WORD(encode, s, end))
-	goto fail;
+        goto fail;
 
       s += enclen(encode, s, end);
       MOP_OUT;
@@ -1902,18 +1902,18 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 
     case OP_WORD_BOUND:  MOP_IN(OP_WORD_BOUND);
       if (ON_STR_BEGIN(s)) {
-	DATA_ENSURE(1);
-	if (! ONIGENC_IS_MBC_WORD(encode, s, end))
-	  goto fail;
+        DATA_ENSURE(1);
+        if (! ONIGENC_IS_MBC_WORD(encode, s, end))
+          goto fail;
       }
       else if (ON_STR_END(s)) {
-	if (! ONIGENC_IS_MBC_WORD(encode, sprev, end))
-	  goto fail;
+        if (! ONIGENC_IS_MBC_WORD(encode, sprev, end))
+          goto fail;
       }
       else {
-	if (ONIGENC_IS_MBC_WORD(encode, s, end)
-	    == ONIGENC_IS_MBC_WORD(encode, sprev, end))
-	  goto fail;
+        if (ONIGENC_IS_MBC_WORD(encode, s, end)
+            == ONIGENC_IS_MBC_WORD(encode, sprev, end))
+          goto fail;
       }
       MOP_OUT;
       continue;
@@ -1921,17 +1921,17 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 
     case OP_NOT_WORD_BOUND:  MOP_IN(OP_NOT_WORD_BOUND);
       if (ON_STR_BEGIN(s)) {
-	if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_WORD(encode, s, end))
-	  goto fail;
+        if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_WORD(encode, s, end))
+          goto fail;
       }
       else if (ON_STR_END(s)) {
-	if (ONIGENC_IS_MBC_WORD(encode, sprev, end))
-	  goto fail;
+        if (ONIGENC_IS_MBC_WORD(encode, sprev, end))
+          goto fail;
       }
       else {
-	if (ONIGENC_IS_MBC_WORD(encode, s, end)
-	    != ONIGENC_IS_MBC_WORD(encode, sprev, end))
-	  goto fail;
+        if (ONIGENC_IS_MBC_WORD(encode, s, end)
+            != ONIGENC_IS_MBC_WORD(encode, sprev, end))
+          goto fail;
       }
       MOP_OUT;
       continue;
@@ -1940,20 +1940,20 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 #ifdef USE_WORD_BEGIN_END
     case OP_WORD_BEGIN:  MOP_IN(OP_WORD_BEGIN);
       if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_WORD(encode, s, end)) {
-	if (ON_STR_BEGIN(s) || !ONIGENC_IS_MBC_WORD(encode, sprev, end)) {
-	  MOP_OUT;
-	  continue;
-	}
+        if (ON_STR_BEGIN(s) || !ONIGENC_IS_MBC_WORD(encode, sprev, end)) {
+          MOP_OUT;
+          continue;
+        }
       }
       goto fail;
       break;
 
     case OP_WORD_END:  MOP_IN(OP_WORD_END);
       if (!ON_STR_BEGIN(s) && ONIGENC_IS_MBC_WORD(encode, sprev, end)) {
-	if (ON_STR_END(s) || !ONIGENC_IS_MBC_WORD(encode, s, end)) {
-	  MOP_OUT;
-	  continue;
-	}
+        if (ON_STR_END(s) || !ONIGENC_IS_MBC_WORD(encode, s, end)) {
+          MOP_OUT;
+          continue;
+        }
       }
       goto fail;
       break;
@@ -1975,13 +1975,13 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 
     case OP_BEGIN_LINE:  MOP_IN(OP_BEGIN_LINE);
       if (ON_STR_BEGIN(s)) {
-	if (IS_NOTBOL(msa->options)) goto fail;
-	MOP_OUT;
-	continue;
+        if (IS_NOTBOL(msa->options)) goto fail;
+        MOP_OUT;
+        continue;
       }
       else if (ONIGENC_IS_MBC_NEWLINE(encode, sprev, end) && !ON_STR_END(s)) {
-	MOP_OUT;
-	continue;
+        MOP_OUT;
+        continue;
       }
       goto fail;
       break;
@@ -1989,23 +1989,23 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
     case OP_END_LINE:  MOP_IN(OP_END_LINE);
       if (ON_STR_END(s)) {
 #ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
-	if (IS_EMPTY_STR || !ONIGENC_IS_MBC_NEWLINE(encode, sprev, end)) {
+        if (IS_EMPTY_STR || !ONIGENC_IS_MBC_NEWLINE(encode, sprev, end)) {
 #endif
-	  if (IS_NOTEOL(msa->options)) goto fail;
-	  MOP_OUT;
-	  continue;
+          if (IS_NOTEOL(msa->options)) goto fail;
+          MOP_OUT;
+          continue;
 #ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
-	}
+        }
 #endif
       }
       else if (ONIGENC_IS_MBC_NEWLINE(encode, s, end)) {
-	MOP_OUT;
-	continue;
+        MOP_OUT;
+        continue;
       }
 #ifdef USE_CRNL_AS_LINE_TERMINATOR
       else if (ONIGENC_IS_MBC_CRNL(encode, s, end)) {
-	MOP_OUT;
-	continue;
+        MOP_OUT;
+        continue;
       }
 #endif
       goto fail;
@@ -2014,24 +2014,24 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
     case OP_SEMI_END_BUF:  MOP_IN(OP_SEMI_END_BUF);
       if (ON_STR_END(s)) {
 #ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
-	if (IS_EMPTY_STR || !ONIGENC_IS_MBC_NEWLINE(encode, sprev, end)) {
+        if (IS_EMPTY_STR || !ONIGENC_IS_MBC_NEWLINE(encode, sprev, end)) {
 #endif
-	  if (IS_NOTEOL(msa->options)) goto fail;
-	  MOP_OUT;
-	  continue;
+          if (IS_NOTEOL(msa->options)) goto fail;
+          MOP_OUT;
+          continue;
 #ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
-	}
+        }
 #endif
       }
       else if (ONIGENC_IS_MBC_NEWLINE(encode, s, end) &&
-	       ON_STR_END(s + enclen(encode, s, end))) {
-	MOP_OUT;
-	continue;
+               ON_STR_END(s + enclen(encode, s, end))) {
+        MOP_OUT;
+        continue;
       }
 #ifdef USE_CRNL_AS_LINE_TERMINATOR
       else if (ONIGENC_IS_MBC_CRNL(encode, s, end)) {
         UChar* ss = s + enclen(encode, s);
-	ss += enclen(encode, ss);
+        ss += enclen(encode, ss);
         if (ON_STR_END(ss)) {
           MOP_OUT;
           continue;
@@ -2043,7 +2043,7 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 
     case OP_BEGIN_POSITION:  MOP_IN(OP_BEGIN_POSITION);
       if (s != msa->start)
-	goto fail;
+        goto fail;
 
       MOP_OUT;
       continue;
@@ -2093,9 +2093,9 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
       STACK_GET_MEM_START(mem, stkp);
 
       if (BIT_STATUS_AT(reg->bt_mem_start, mem))
-	mem_start_stk[mem] = GET_STACK_INDEX(stkp);
+        mem_start_stk[mem] = GET_STACK_INDEX(stkp);
       else
-	mem_start_stk[mem] = (OnigStackIndex )((void* )stkp->u.mem.pstr);
+        mem_start_stk[mem] = (OnigStackIndex )((void* )stkp->u.mem.pstr);
 
       STACK_PUSH_MEM_END_MARK(mem);
       MOP_OUT;
@@ -2117,169 +2117,169 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
       GET_MEMNUM_INC(mem, p);
     backref:
       {
-	int len;
-	UChar *pstart, *pend;
-
-	/* if you want to remove following line,
-	   you should check in parse and compile time. */
-	if (mem > num_mem) goto fail;
-	if (mem_end_stk[mem]   == INVALID_STACK_INDEX) goto fail;
-	if (mem_start_stk[mem] == INVALID_STACK_INDEX) goto fail;
-
-	if (BIT_STATUS_AT(reg->bt_mem_start, mem))
-	  pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
-	else
-	  pstart = (UChar* )((void* )mem_start_stk[mem]);
-
-	pend = (BIT_STATUS_AT(reg->bt_mem_end, mem)
-		? STACK_AT(mem_end_stk[mem])->u.mem.pstr
-		: (UChar* )((void* )mem_end_stk[mem]));
-	n = pend - pstart;
-	DATA_ENSURE(n);
-	sprev = s;
-	STRING_CMP(pstart, s, n);
-	while (sprev + (len = enclen(encode, sprev, end)) < s)
-	  sprev += len;
+        int len;
+        UChar *pstart, *pend;
+
+        /* if you want to remove following line,
+           you should check in parse and compile time. */
+        if (mem > num_mem) goto fail;
+        if (mem_end_stk[mem]   == INVALID_STACK_INDEX) goto fail;
+        if (mem_start_stk[mem] == INVALID_STACK_INDEX) goto fail;
+
+        if (BIT_STATUS_AT(reg->bt_mem_start, mem))
+          pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
+        else
+          pstart = (UChar* )((void* )mem_start_stk[mem]);
+
+        pend = (BIT_STATUS_AT(reg->bt_mem_end, mem)
+                ? STACK_AT(mem_end_stk[mem])->u.mem.pstr
+                : (UChar* )((void* )mem_end_stk[mem]));
+        n = pend - pstart;
+        DATA_ENSURE(n);
+        sprev = s;
+        STRING_CMP(pstart, s, n);
+        while (sprev + (len = enclen(encode, sprev, end)) < s)
+          sprev += len;
 
-	MOP_OUT;
-	continue;
+        MOP_OUT;
+        continue;
       }
       break;
 
     case OP_BACKREFN_IC:  MOP_IN(OP_BACKREFN_IC);
       GET_MEMNUM_INC(mem, p);
       {
-	int len;
-	UChar *pstart, *pend;
-
-	/* if you want to remove following line,
-	   you should check in parse and compile time. */
-	if (mem > num_mem) goto fail;
-	if (mem_end_stk[mem]   == INVALID_STACK_INDEX) goto fail;
-	if (mem_start_stk[mem] == INVALID_STACK_INDEX) goto fail;
-
-	if (BIT_STATUS_AT(reg->bt_mem_start, mem))
-	  pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
-	else
-	  pstart = (UChar* )((void* )mem_start_stk[mem]);
-
-	pend = (BIT_STATUS_AT(reg->bt_mem_end, mem)
-		? STACK_AT(mem_end_stk[mem])->u.mem.pstr
-		: (UChar* )((void* )mem_end_stk[mem]));
-	n = pend - pstart;
-	DATA_ENSURE(n);
-	sprev = s;
-	STRING_CMP_IC(case_fold_flag, pstart, &s, n, end);
-	while (sprev + (len = enclen(encode, sprev, end)) < s)
-	  sprev += len;
+        int len;
+        UChar *pstart, *pend;
+
+        /* if you want to remove following line,
+           you should check in parse and compile time. */
+        if (mem > num_mem) goto fail;
+        if (mem_end_stk[mem]   == INVALID_STACK_INDEX) goto fail;
+        if (mem_start_stk[mem] == INVALID_STACK_INDEX) goto fail;
+
+        if (BIT_STATUS_AT(reg->bt_mem_start, mem))
+          pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
+        else
+          pstart = (UChar* )((void* )mem_start_stk[mem]);
+
+        pend = (BIT_STATUS_AT(reg->bt_mem_end, mem)
+                ? STACK_AT(mem_end_stk[mem])->u.mem.pstr
+                : (UChar* )((void* )mem_end_stk[mem]));
+        n = pend - pstart;
+        DATA_ENSURE(n);
+        sprev = s;
+        STRING_CMP_IC(case_fold_flag, pstart, &s, n, end);
+        while (sprev + (len = enclen(encode, sprev, end)) < s)
+          sprev += len;
 
-	MOP_OUT;
-	continue;
+        MOP_OUT;
+        continue;
       }
       break;
 
     case OP_BACKREF_MULTI:  MOP_IN(OP_BACKREF_MULTI);
       {
-	int len, is_fail;
-	UChar *pstart, *pend, *swork;
-
-	GET_LENGTH_INC(tlen, p);
-	for (i = 0; i < tlen; i++) {
-	  GET_MEMNUM_INC(mem, p);
-
-	  if (mem_end_stk[mem]   == INVALID_STACK_INDEX) continue;
-	  if (mem_start_stk[mem] == INVALID_STACK_INDEX) continue;
-
-	  if (BIT_STATUS_AT(reg->bt_mem_start, mem))
-	    pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
-	  else
-	    pstart = (UChar* )((void* )mem_start_stk[mem]);
-
-	  pend = (BIT_STATUS_AT(reg->bt_mem_end, mem)
-		  ? STACK_AT(mem_end_stk[mem])->u.mem.pstr
-		  : (UChar* )((void* )mem_end_stk[mem]));
-	  n = pend - pstart;
-	  DATA_ENSURE(n);
-	  sprev = s;
-	  swork = s;
-	  STRING_CMP_VALUE(pstart, swork, n, is_fail);
-	  if (is_fail) continue;
-	  s = swork;
-	  while (sprev + (len = enclen(encode, sprev, end)) < s)
-	    sprev += len;
-
-	  p += (SIZE_MEMNUM * (tlen - i - 1));
-	  break; /* success */
-	}
-	if (i == tlen) goto fail;
-	MOP_OUT;
-	continue;
+        int len, is_fail;
+        UChar *pstart, *pend, *swork;
+
+        GET_LENGTH_INC(tlen, p);
+        for (i = 0; i < tlen; i++) {
+          GET_MEMNUM_INC(mem, p);
+
+          if (mem_end_stk[mem]   == INVALID_STACK_INDEX) continue;
+          if (mem_start_stk[mem] == INVALID_STACK_INDEX) continue;
+
+          if (BIT_STATUS_AT(reg->bt_mem_start, mem))
+            pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
+          else
+            pstart = (UChar* )((void* )mem_start_stk[mem]);
+
+          pend = (BIT_STATUS_AT(reg->bt_mem_end, mem)
+                  ? STACK_AT(mem_end_stk[mem])->u.mem.pstr
+                  : (UChar* )((void* )mem_end_stk[mem]));
+          n = pend - pstart;
+          DATA_ENSURE(n);
+          sprev = s;
+          swork = s;
+          STRING_CMP_VALUE(pstart, swork, n, is_fail);
+          if (is_fail) continue;
+          s = swork;
+          while (sprev + (len = enclen(encode, sprev, end)) < s)
+            sprev += len;
+
+          p += (SIZE_MEMNUM * (tlen - i - 1));
+          break; /* success */
+        }
+        if (i == tlen) goto fail;
+        MOP_OUT;
+        continue;
       }
       break;
 
     case OP_BACKREF_MULTI_IC:  MOP_IN(OP_BACKREF_MULTI_IC);
       {
-	int len, is_fail;
-	UChar *pstart, *pend, *swork;
-
-	GET_LENGTH_INC(tlen, p);
-	for (i = 0; i < tlen; i++) {
-	  GET_MEMNUM_INC(mem, p);
-
-	  if (mem_end_stk[mem]   == INVALID_STACK_INDEX) continue;
-	  if (mem_start_stk[mem] == INVALID_STACK_INDEX) continue;
-
-	  if (BIT_STATUS_AT(reg->bt_mem_start, mem))
-	    pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
-	  else
-	    pstart = (UChar* )((void* )mem_start_stk[mem]);
-
-	  pend = (BIT_STATUS_AT(reg->bt_mem_end, mem)
-		  ? STACK_AT(mem_end_stk[mem])->u.mem.pstr
-		  : (UChar* )((void* )mem_end_stk[mem]));
-	  n = pend - pstart;
-	  DATA_ENSURE(n);
-	  sprev = s;
-	  swork = s;
-	  STRING_CMP_VALUE_IC(case_fold_flag, pstart, &swork, n, end, is_fail);
-	  if (is_fail) continue;
-	  s = swork;
-	  while (sprev + (len = enclen(encode, sprev, end)) < s)
-	    sprev += len;
-
-	  p += (SIZE_MEMNUM * (tlen - i - 1));
-	  break; /* success */
-	}
-	if (i == tlen) goto fail;
-	MOP_OUT;
-	continue;
+        int len, is_fail;
+        UChar *pstart, *pend, *swork;
+
+        GET_LENGTH_INC(tlen, p);
+        for (i = 0; i < tlen; i++) {
+          GET_MEMNUM_INC(mem, p);
+
+          if (mem_end_stk[mem]   == INVALID_STACK_INDEX) continue;
+          if (mem_start_stk[mem] == INVALID_STACK_INDEX) continue;
+
+          if (BIT_STATUS_AT(reg->bt_mem_start, mem))
+            pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
+          else
+            pstart = (UChar* )((void* )mem_start_stk[mem]);
+
+          pend = (BIT_STATUS_AT(reg->bt_mem_end, mem)
+                  ? STACK_AT(mem_end_stk[mem])->u.mem.pstr
+                  : (UChar* )((void* )mem_end_stk[mem]));
+          n = pend - pstart;
+          DATA_ENSURE(n);
+          sprev = s;
+          swork = s;
+          STRING_CMP_VALUE_IC(case_fold_flag, pstart, &swork, n, end, is_fail);
+          if (is_fail) continue;
+          s = swork;
+          while (sprev + (len = enclen(encode, sprev, end)) < s)
+            sprev += len;
+
+          p += (SIZE_MEMNUM * (tlen - i - 1));
+          break; /* success */
+        }
+        if (i == tlen) goto fail;
+        MOP_OUT;
+        continue;
       }
       break;
 
 #ifdef USE_BACKREF_WITH_LEVEL
     case OP_BACKREF_WITH_LEVEL:
       {
-	int len;
-	OnigOptionType ic;
-	LengthType level;
+        int len;
+        OnigOptionType ic;
+        LengthType level;
 
-	GET_OPTION_INC(ic,    p);
-	GET_LENGTH_INC(level, p);
-	GET_LENGTH_INC(tlen,  p);
+        GET_OPTION_INC(ic,    p);
+        GET_LENGTH_INC(level, p);
+        GET_LENGTH_INC(tlen,  p);
 
-	sprev = s;
-	if (backref_match_at_nested_level(reg, stk, stk_base, ic
-		  , case_fold_flag, (int )level, (int )tlen, p, &s, end)) {
-	  while (sprev + (len = enclen(encode, sprev, end)) < s)
-	    sprev += len;
+        sprev = s;
+        if (backref_match_at_nested_level(reg, stk, stk_base, ic
+                  , case_fold_flag, (int )level, (int )tlen, p, &s, end)) {
+          while (sprev + (len = enclen(encode, sprev, end)) < s)
+            sprev += len;
 
-	  p += (SIZE_MEMNUM * tlen);
-	}
-	else
-	  goto fail;
+          p += (SIZE_MEMNUM * tlen);
+        }
+        else
+          goto fail;
 
-	MOP_OUT;
-	continue;
+        MOP_OUT;
+        continue;
       }
 
       break;
@@ -2294,33 +2294,33 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 
     case OP_NULL_CHECK_END:  MOP_IN(OP_NULL_CHECK_END);
       {
-	int isnull;
+        int isnull;
 
-	GET_MEMNUM_INC(mem, p); /* mem: null check id */
-	STACK_NULL_CHECK(isnull, mem, s);
-	if (isnull) {
+        GET_MEMNUM_INC(mem, p); /* mem: null check id */
+        STACK_NULL_CHECK(isnull, mem, s);
+        if (isnull) {
 #ifdef ONIG_DEBUG_MATCH
-	  fprintf(stderr, "NULL_CHECK_END: skip  id:%d, s:%d\n",
-		  (int )mem, (int )s);
+          fprintf(stderr, "NULL_CHECK_END: skip  id:%d, s:%d\n",
+                  (int )mem, (int )s);
 #endif
-	null_check_found:
-	  /* empty loop founded, skip next instruction */
-	  switch (*p++) {
-	  case OP_JUMP:
-	  case OP_PUSH:
-	    p += SIZE_RELADDR;
-	    break;
-	  case OP_REPEAT_INC:
-	  case OP_REPEAT_INC_NG:
-	  case OP_REPEAT_INC_SG:
-	  case OP_REPEAT_INC_NG_SG:
-	    p += SIZE_MEMNUM;
-	    break;
-	  default:
-	    goto unexpected_bytecode_error;
-	    break;
-	  }
-	}
+        null_check_found:
+          /* empty loop founded, skip next instruction */
+          switch (*p++) {
+          case OP_JUMP:
+          case OP_PUSH:
+            p += SIZE_RELADDR;
+            break;
+          case OP_REPEAT_INC:
+          case OP_REPEAT_INC_NG:
+          case OP_REPEAT_INC_SG:
+          case OP_REPEAT_INC_NG_SG:
+            p += SIZE_MEMNUM;
+            break;
+          default:
+            goto unexpected_bytecode_error;
+            break;
+          }
+        }
       }
       MOP_OUT;
       continue;
@@ -2329,18 +2329,18 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 #ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
     case OP_NULL_CHECK_END_MEMST:  MOP_IN(OP_NULL_CHECK_END_MEMST);
       {
-	int isnull;
+        int isnull;
 
-	GET_MEMNUM_INC(mem, p); /* mem: null check id */
-	STACK_NULL_CHECK_MEMST(isnull, mem, s, reg);
-	if (isnull) {
+        GET_MEMNUM_INC(mem, p); /* mem: null check id */
+        STACK_NULL_CHECK_MEMST(isnull, mem, s, reg);
+        if (isnull) {
 #ifdef ONIG_DEBUG_MATCH
-	  fprintf(stderr, "NULL_CHECK_END_MEMST: skip  id:%d, s:%d\n",
-		  (int )mem, (int )s);
+          fprintf(stderr, "NULL_CHECK_END_MEMST: skip  id:%d, s:%d\n",
+                  (int )mem, (int )s);
 #endif
-	  if (isnull == -1) goto fail;
-	  goto 	null_check_found;
-	}
+          if (isnull == -1) goto fail;
+          goto  null_check_found;
+        }
       }
       MOP_OUT;
       continue;
@@ -2351,25 +2351,25 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
     case OP_NULL_CHECK_END_MEMST_PUSH:
       MOP_IN(OP_NULL_CHECK_END_MEMST_PUSH);
       {
-	int isnull;
+        int isnull;
 
-	GET_MEMNUM_INC(mem, p); /* mem: null check id */
+        GET_MEMNUM_INC(mem, p); /* mem: null check id */
 #ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
-	STACK_NULL_CHECK_MEMST_REC(isnull, mem, s, reg);
+        STACK_NULL_CHECK_MEMST_REC(isnull, mem, s, reg);
 #else
-	STACK_NULL_CHECK_REC(isnull, mem, s);
+        STACK_NULL_CHECK_REC(isnull, mem, s);
 #endif
-	if (isnull) {
+        if (isnull) {
 #ifdef ONIG_DEBUG_MATCH
-	  fprintf(stderr, "NULL_CHECK_END_MEMST_PUSH: skip  id:%d, s:%d\n",
-		  (int )mem, (int )s);
+          fprintf(stderr, "NULL_CHECK_END_MEMST_PUSH: skip  id:%d, s:%d\n",
+                  (int )mem, (int )s);
 #endif
-	  if (isnull == -1) goto fail;
-	  goto 	null_check_found;
-	}
-	else {
-	  STACK_PUSH_NULL_CHECK_END(mem);
-	}
+          if (isnull == -1) goto fail;
+          goto  null_check_found;
+        }
+        else {
+          STACK_PUSH_NULL_CHECK_END(mem);
+        }
       }
       MOP_OUT;
       continue;
@@ -2408,10 +2408,10 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
       GET_RELADDR_INC(addr, p);
       STATE_CHECK_VAL(scv, mem);
       if (scv) {
-	p += addr;
+        p += addr;
       }
       else {
-	STACK_PUSH_ALT_WITH_STATE_CHECK(p + addr, s, sprev, mem);
+        STACK_PUSH_ALT_WITH_STATE_CHECK(p + addr, s, sprev, mem);
       }
       MOP_OUT;
       continue;
@@ -2437,10 +2437,10 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
     case OP_PUSH_OR_JUMP_EXACT1:  MOP_IN(OP_PUSH_OR_JUMP_EXACT1);
       GET_RELADDR_INC(addr, p);
       if (*p == *s && DATA_ENSURE_CHECK1) {
-	p++;
-	STACK_PUSH_ALT(p + addr, s, sprev);
-	MOP_OUT;
-	continue;
+        p++;
+        STACK_PUSH_ALT(p + addr, s, sprev);
+        MOP_OUT;
+        continue;
       }
       p += (addr + 1);
       MOP_OUT;
@@ -2450,10 +2450,10 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
     case OP_PUSH_IF_PEEK_NEXT:  MOP_IN(OP_PUSH_IF_PEEK_NEXT);
       GET_RELADDR_INC(addr, p);
       if (*p == *s) {
-	p++;
-	STACK_PUSH_ALT(p + addr, s, sprev);
-	MOP_OUT;
-	continue;
+        p++;
+        STACK_PUSH_ALT(p + addr, s, sprev);
+        MOP_OUT;
+        continue;
       }
       p++;
       MOP_OUT;
@@ -2462,16 +2462,16 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 
     case OP_REPEAT:  MOP_IN(OP_REPEAT);
       {
-	GET_MEMNUM_INC(mem, p);    /* mem: OP_REPEAT ID */
-	GET_RELADDR_INC(addr, p);
+        GET_MEMNUM_INC(mem, p);    /* mem: OP_REPEAT ID */
+        GET_RELADDR_INC(addr, p);
 
-	STACK_ENSURE(1);
-	repeat_stk[mem] = GET_STACK_INDEX(stk);
-	STACK_PUSH_REPEAT(mem, p);
+        STACK_ENSURE(1);
+        repeat_stk[mem] = GET_STACK_INDEX(stk);
+        STACK_PUSH_REPEAT(mem, p);
 
-	if (reg->repeat_range[mem].lower == 0) {
-	  STACK_PUSH_ALT(p + addr, s, sprev);
-	}
+        if (reg->repeat_range[mem].lower == 0) {
+          STACK_PUSH_ALT(p + addr, s, sprev);
+        }
       }
       MOP_OUT;
       continue;
@@ -2479,17 +2479,17 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 
     case OP_REPEAT_NG:  MOP_IN(OP_REPEAT_NG);
       {
-	GET_MEMNUM_INC(mem, p);    /* mem: OP_REPEAT ID */
-	GET_RELADDR_INC(addr, p);
+        GET_MEMNUM_INC(mem, p);    /* mem: OP_REPEAT ID */
+        GET_RELADDR_INC(addr, p);
 
-	STACK_ENSURE(1);
-	repeat_stk[mem] = GET_STACK_INDEX(stk);
-	STACK_PUSH_REPEAT(mem, p);
+        STACK_ENSURE(1);
+        repeat_stk[mem] = GET_STACK_INDEX(stk);
+        STACK_PUSH_REPEAT(mem, p);
 
-	if (reg->repeat_range[mem].lower == 0) {
-	  STACK_PUSH_ALT(p, s, sprev);
-	  p += addr;
-	}
+        if (reg->repeat_range[mem].lower == 0) {
+          STACK_PUSH_ALT(p, s, sprev);
+          p += addr;
+        }
       }
       MOP_OUT;
       continue;
@@ -2567,9 +2567,9 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 
     case OP_POP_POS:  MOP_IN(OP_POP_POS);
       {
-	STACK_POS_END(stkp);
-	s     = stkp->u.state.pstr;
-	sprev = stkp->u.state.pstr_prev;
+        STACK_POS_END(stkp);
+        s     = stkp->u.state.pstr;
+        sprev = stkp->u.state.pstr_prev;
       }
       MOP_OUT;
       continue;
@@ -2613,15 +2613,15 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
       GET_LENGTH_INC(tlen, p);
       q = (UChar* )ONIGENC_STEP_BACK(encode, str, s, end, (int )tlen);
       if (IS_NULL(q)) {
-	/* too short case -> success. ex. /(?<!XXX)a/.match("a")
-	   If you want to change to fail, replace following line. */
-	p += addr;
-	/* goto fail; */
+        /* too short case -> success. ex. /(?<!XXX)a/.match("a")
+           If you want to change to fail, replace following line. */
+        p += addr;
+        /* goto fail; */
       }
       else {
-	STACK_PUSH_LOOK_BEHIND_NOT(p + addr, s, sprev);
-	s = q;
-	sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s, end);
+        STACK_PUSH_LOOK_BEHIND_NOT(p + addr, s, sprev);
+        s = q;
+        sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s, end);
       }
       MOP_OUT;
       continue;
@@ -2702,7 +2702,7 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
 
 static UChar*
 slow_search(OnigEncoding enc, UChar* target, UChar* target_end,
-	    const UChar* text, const UChar* text_end, UChar* text_range)
+            const UChar* text, const UChar* text_end, UChar* text_range)
 {
   UChar *t, *p, *s, *end;
 
@@ -2718,10 +2718,10 @@ slow_search(OnigEncoding enc, UChar* target, UChar* target_end,
 
     while (s < end) {
       if (*s == *target) {
-	p = s + 1;
-	t = target + 1;
-	if (target_end == t || memcmp(t, p, target_end - t) == 0)
-	  return s;
+        p = s + 1;
+        t = target + 1;
+        if (target_end == t || memcmp(t, p, target_end - t) == 0)
+          return s;
       }
       s += n;
     }
@@ -2732,7 +2732,7 @@ slow_search(OnigEncoding enc, UChar* target, UChar* target_end,
       p = s + 1;
       t = target + 1;
       if (target_end == t || memcmp(t, p, target_end - t) == 0)
-	return s;
+        return s;
     }
     s += enclen(enc, s, text_end);
   }
@@ -2743,7 +2743,7 @@ slow_search(OnigEncoding enc, UChar* target, UChar* target_end,
 static int
 str_lower_case_match(OnigEncoding enc, int case_fold_flag,
                      const UChar* t, const UChar* tend,
-		     const UChar* p, const UChar* end)
+                     const UChar* p, const UChar* end)
 {
   int lowlen;
   UChar *q, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN];
@@ -2752,7 +2752,7 @@ str_lower_case_match(OnigEncoding enc, int case_fold_flag,
     lowlen = ONIGENC_MBC_CASE_FOLD(enc, case_fold_flag, &p, end, lowbuf);
     q = lowbuf;
     while (lowlen > 0) {
-      if (*t++ != *q++)	return 0;
+      if (*t++ != *q++) return 0;
       lowlen--;
     }
   }
@@ -2762,8 +2762,8 @@ str_lower_case_match(OnigEncoding enc, int case_fold_flag,
 
 static UChar*
 slow_search_ic(OnigEncoding enc, int case_fold_flag,
-	       UChar* target, UChar* target_end,
-	       const UChar* text, const UChar* text_end, UChar* text_range)
+               UChar* target, UChar* target_end,
+               const UChar* text, const UChar* text_end, UChar* text_range)
 {
   UChar *s, *end;
 
@@ -2776,7 +2776,7 @@ slow_search_ic(OnigEncoding enc, int case_fold_flag,
 
   while (s < end) {
     if (str_lower_case_match(enc, case_fold_flag, target, target_end,
-			     s, text_end))
+                             s, text_end))
       return s;
 
     s += enclen(enc, s, text_end);
@@ -2787,8 +2787,8 @@ slow_search_ic(OnigEncoding enc, int case_fold_flag,
 
 static UChar*
 slow_search_backward(OnigEncoding enc, UChar* target, UChar* target_end,
-		     const UChar* text, const UChar* adjust_text,
-		     const UChar* text_end, const UChar* text_start)
+                     const UChar* text, const UChar* adjust_text,
+                     const UChar* text_end, const UChar* text_start)
 {
   UChar *t, *p, *s;
 
@@ -2804,12 +2804,12 @@ slow_search_backward(OnigEncoding enc, UChar* target, UChar* target_end,
       p = s + 1;
       t = target + 1;
       while (t < target_end) {
-	if (*t != *p++)
-	  break;
-	t++;
+        if (*t != *p++)
+          break;
+        t++;
       }
       if (t == target_end)
-	return s;
+        return s;
     }
     s = (UChar* )onigenc_get_prev_char_head(enc, adjust_text, s, text_end);
   }
@@ -2819,9 +2819,9 @@ slow_search_backward(OnigEncoding enc, UChar* target, UChar* target_end,
 
 static UChar*
 slow_search_backward_ic(OnigEncoding enc, int case_fold_flag,
-			UChar* target, UChar* target_end,
-			const UChar* text, const UChar* adjust_text,
-			const UChar* text_end, const UChar* text_start)
+                        UChar* target, UChar* target_end,
+                        const UChar* text, const UChar* adjust_text,
+                        const UChar* text_end, const UChar* text_start)
 {
   UChar *s;
 
@@ -2845,8 +2845,8 @@ slow_search_backward_ic(OnigEncoding enc, int case_fold_flag,
 
 static UChar*
 bm_search_notrev(regex_t* reg, const UChar* target, const UChar* target_end,
-		 const UChar* text, const UChar* text_end,
-		 const UChar* text_range)
+                 const UChar* text, const UChar* text_end,
+                 const UChar* text_range)
 {
   const UChar *s, *se, *t, *p, *end;
   const UChar *tail;
@@ -2854,7 +2854,7 @@ bm_search_notrev(regex_t* reg, const UChar* target, const UChar* target_end,
 
 #ifdef ONIG_DEBUG_SEARCH
   fprintf(stderr, "bm_search_notrev: text: %d, text_end: %d, text_range: %d\n",
-	  (int )text, (int )text_end, (int )text_range);
+          (int )text, (int )text_end, (int )text_range);
 #endif
 
   tail = target_end - 1;
@@ -2870,8 +2870,8 @@ bm_search_notrev(regex_t* reg, const UChar* target, const UChar* target_end,
       p = se = s + tlen1;
       t = tail;
       while (*p == *t) {
-	if (t == target) return (UChar* )s;
-	p--; t--;
+        if (t == target) return (UChar* )s;
+        p--; t--;
       }
       skip = reg->map[*se];
       t = s;
@@ -2885,8 +2885,8 @@ bm_search_notrev(regex_t* reg, const UChar* target, const UChar* target_end,
       p = se = s + tlen1;
       t = tail;
       while (*p == *t) {
-	if (t == target) return (UChar* )s;
-	p--; t--;
+        if (t == target) return (UChar* )s;
+        p--; t--;
       }
       skip = reg->int_map[*se];
       t = s;
@@ -2901,7 +2901,7 @@ bm_search_notrev(regex_t* reg, const UChar* target, const UChar* target_end,
 
 static UChar*
 bm_search(regex_t* reg, const UChar* target, const UChar* target_end,
-	  const UChar* text, const UChar* text_end, const UChar* text_range)
+          const UChar* text, const UChar* text_end, const UChar* text_range)
 {
   const UChar *s, *t, *p, *end;
   const UChar *tail;
@@ -2917,8 +2917,8 @@ bm_search(regex_t* reg, const UChar* target, const UChar* target_end,
       p = s;
       t = tail;
       while (*p == *t) {
-	if (t == target) return (UChar* )p;
-	p--; t--;
+        if (t == target) return (UChar* )p;
+        p--; t--;
       }
       s += reg->map[*s];
     }
@@ -2928,8 +2928,8 @@ bm_search(regex_t* reg, const UChar* target, const UChar* target_end,
       p = s;
       t = tail;
       while (*p == *t) {
-	if (t == target) return (UChar* )p;
-	p--; t--;
+        if (t == target) return (UChar* )p;
+        p--; t--;
       }
       s += reg->int_map[*s];
     }
@@ -2939,7 +2939,7 @@ bm_search(regex_t* reg, const UChar* target, const UChar* target_end,
 
 static int
 set_bm_backward_skip(UChar* s, UChar* end, OnigEncoding enc ARG_UNUSED,
-		     int** skip)
+                     int** skip)
 {
   int i, len;
 
@@ -2960,8 +2960,8 @@ set_bm_backward_skip(UChar* s, UChar* end, OnigEncoding enc ARG_UNUSED,
 
 static UChar*
 bm_search_backward(regex_t* reg, const UChar* target, const UChar* target_end,
-		   const UChar* text, const UChar* adjust_text,
-		   const UChar* text_end, const UChar* text_start)
+                   const UChar* text, const UChar* adjust_text,
+                   const UChar* text_end, const UChar* text_start)
 {
   const UChar *s, *t, *p;
 
@@ -2989,7 +2989,7 @@ bm_search_backward(regex_t* reg, const UChar* target, const UChar* target_end,
 
 static UChar*
 map_search(OnigEncoding enc, UChar map[],
-	   const UChar* text, const UChar* text_range, const UChar* text_end)
+           const UChar* text, const UChar* text_range, const UChar* text_end)
 {
   const UChar *s = text;
 
@@ -3003,8 +3003,8 @@ map_search(OnigEncoding enc, UChar map[],
 
 static UChar*
 map_search_backward(OnigEncoding enc, UChar map[],
-		    const UChar* text, const UChar* adjust_text,
-		    const UChar* text_start, const UChar* text_end)
+                    const UChar* text, const UChar* adjust_text,
+                    const UChar* text_start, const UChar* text_end)
 {
   const UChar *s = text_start;
 
@@ -3018,7 +3018,7 @@ map_search_backward(OnigEncoding enc, UChar map[],
 
 extern long
 onig_match(regex_t* reg, const UChar* str, const UChar* end, const UChar* at, OnigRegion* region,
-	    OnigOptionType option)
+            OnigOptionType option)
 {
   long r;
   UChar *prev;
@@ -3041,7 +3041,7 @@ onig_match(regex_t* reg, const UChar* str, const UChar* end, const UChar* at, On
     n = 0;
     while (ONIG_STATE(reg) < ONIG_STATE_NORMAL) {
       if (++n > THREAD_PASS_LIMIT_COUNT)
-	return ONIGERR_OVER_THREAD_PASS_LIMIT_COUNT;
+        return ONIGERR_OVER_THREAD_PASS_LIMIT_COUNT;
       THREAD_PASS;
     }
     goto start;
@@ -3068,9 +3068,9 @@ onig_match(regex_t* reg, const UChar* str, const UChar* end, const UChar* at, On
     prev = (UChar* )onigenc_get_prev_char_head(reg->enc, str, at, end);
     r = match_at(reg, str, end,
 #ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
-		 end,
+                 end,
 #endif
-		 at, prev, &msa);
+                 at, prev, &msa);
   }
 
   MATCH_ARG_FREE(msa);
@@ -3080,13 +3080,13 @@ onig_match(regex_t* reg, const UChar* str, const UChar* end, const UChar* at, On
 
 static int
 forward_search_range(regex_t* reg, const UChar* str, const UChar* end, UChar* s,
-		     UChar* range, UChar** low, UChar** high, UChar** low_prev)
+                     UChar* range, UChar** low, UChar** high, UChar** low_prev)
 {
   UChar *p, *pprev = (UChar* )NULL;
 
 #ifdef ONIG_DEBUG_SEARCH
   fprintf(stderr, "forward_search_range: str: %d, end: %d, s: %d, range: %d\n",
-	  (int )str, (int )end, (int )s, (int )range);
+          (int )str, (int )end, (int )s, (int )range);
 #endif
 
   p = s;
@@ -3136,58 +3136,58 @@ forward_search_range(regex_t* reg, const UChar* str, const UChar* end, UChar* s,
 
       switch (reg->sub_anchor) {
       case ANCHOR_BEGIN_LINE:
-	if (!ON_STR_BEGIN(p)) {
-	  prev = onigenc_get_prev_char_head(reg->enc,
-					    (pprev ? pprev : str), p, end);
-	  if (!ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end))
-	    goto retry_gate;
-	}
-	break;
+        if (!ON_STR_BEGIN(p)) {
+          prev = onigenc_get_prev_char_head(reg->enc,
+                                            (pprev ? pprev : str), p, end);
+          if (!ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end))
+            goto retry_gate;
+        }
+        break;
 
       case ANCHOR_END_LINE:
-	if (ON_STR_END(p)) {
+        if (ON_STR_END(p)) {
 #ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
-	  prev = (UChar* )onigenc_get_prev_char_head(reg->enc,
-					    (pprev ? pprev : str), p);
-	  if (prev && ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end))
-	    goto retry_gate;
+          prev = (UChar* )onigenc_get_prev_char_head(reg->enc,
+                                            (pprev ? pprev : str), p);
+          if (prev && ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end))
+            goto retry_gate;
 #endif
-	}
-	else if (! ONIGENC_IS_MBC_NEWLINE(reg->enc, p, end)
+        }
+        else if (! ONIGENC_IS_MBC_NEWLINE(reg->enc, p, end)
 #ifdef USE_CRNL_AS_LINE_TERMINATOR
               && ! ONIGENC_IS_MBC_CRNL(reg->enc, p, end)
 #endif
                 )
-	  goto retry_gate;
-	break;
+          goto retry_gate;
+        break;
       }
     }
 
     if (reg->dmax == 0) {
       *low = p;
       if (low_prev) {
-	if (*low > s)
-	  *low_prev = onigenc_get_prev_char_head(reg->enc, s, p, end);
-	else
-	  *low_prev = onigenc_get_prev_char_head(reg->enc,
-						 (pprev ? pprev : str), p, end);
+        if (*low > s)
+          *low_prev = onigenc_get_prev_char_head(reg->enc, s, p, end);
+        else
+          *low_prev = onigenc_get_prev_char_head(reg->enc,
+                                                 (pprev ? pprev : str), p, end);
       }
     }
     else {
       if (reg->dmax != ONIG_INFINITE_DISTANCE) {
-	*low = p - reg->dmax;
-	if (*low > s) {
-	  *low = onigenc_get_right_adjust_char_head_with_prev(reg->enc, s,
-							      *low, end, (const UChar** )low_prev);
-	  if (low_prev && IS_NULL(*low_prev))
-	    *low_prev = onigenc_get_prev_char_head(reg->enc,
-						   (pprev ? pprev : s), *low, end);
-	}
-	else {
-	  if (low_prev)
-	    *low_prev = onigenc_get_prev_char_head(reg->enc,
-					       (pprev ? pprev : str), *low, end);
-	}
+        *low = p - reg->dmax;
+        if (*low > s) {
+          *low = onigenc_get_right_adjust_char_head_with_prev(reg->enc, s,
+                                                              *low, end, (const UChar** )low_prev);
+          if (low_prev && IS_NULL(*low_prev))
+            *low_prev = onigenc_get_prev_char_head(reg->enc,
+                                                   (pprev ? pprev : s), *low, end);
+        }
+        else {
+          if (low_prev)
+            *low_prev = onigenc_get_prev_char_head(reg->enc,
+                                               (pprev ? pprev : str), *low, end);
+        }
       }
     }
     /* no needs to adjust *high, *high is used as range check only */
@@ -3196,7 +3196,7 @@ forward_search_range(regex_t* reg, const UChar* str, const UChar* end, UChar* s,
 #ifdef ONIG_DEBUG_SEARCH
     fprintf(stderr,
     "forward_search_range success: low: %d, high: %d, dmin: %d, dmax: %d\n",
-	    (int )(*low - str), (int )(*high - str), reg->dmin, reg->dmax);
+            (int )(*low - str), (int )(*high - str), reg->dmin, reg->dmax);
 #endif
     return 1; /* success */
   }
@@ -3208,8 +3208,8 @@ forward_search_range(regex_t* reg, const UChar* str, const UChar* end, UChar* s,
 
 static long
 backward_search_range(regex_t* reg, const UChar* str, const UChar* end,
-		      UChar* s, const UChar* range, UChar* adjrange,
-		      UChar** low, UChar** high)
+                      UChar* s, const UChar* range, UChar* adjrange,
+                      UChar** low, UChar** high)
 {
   int r;
   UChar *p;
@@ -3222,7 +3222,7 @@ backward_search_range(regex_t* reg, const UChar* str, const UChar* end,
   case ONIG_OPTIMIZE_EXACT:
   exact_method:
     p = slow_search_backward(reg->enc, reg->exact, reg->exact_end,
-			     range, adjrange, end, p);
+                             range, adjrange, end, p);
     break;
 
   case ONIG_OPTIMIZE_EXACT_IC:
@@ -3235,14 +3235,14 @@ backward_search_range(regex_t* reg, const UChar* str, const UChar* end,
   case ONIG_OPTIMIZE_EXACT_BM_NOT_REV:
     if (IS_NULL(reg->int_map_backward)) {
       if (s - range < BM_BACKWARD_SEARCH_LENGTH_THRESHOLD)
-	goto exact_method;
+        goto exact_method;
 
       r = set_bm_backward_skip(reg->exact, reg->exact_end, reg->enc,
-			       &(reg->int_map_backward));
+                               &(reg->int_map_backward));
       if (r) return r;
     }
     p = bm_search_backward(reg, reg->exact, reg->exact_end, range, adjrange,
-			   end, p);
+                           end, p);
     break;
 
   case ONIG_OPTIMIZE_MAP:
@@ -3256,36 +3256,36 @@ backward_search_range(regex_t* reg, const UChar* str, const UChar* end,
 
       switch (reg->sub_anchor) {
       case ANCHOR_BEGIN_LINE:
-	if (!ON_STR_BEGIN(p)) {
-	  prev = onigenc_get_prev_char_head(reg->enc, str, p, end);
-	  if (!ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end)) {
-	    p = prev;
-	    goto retry;
-	  }
-	}
-	break;
+        if (!ON_STR_BEGIN(p)) {
+          prev = onigenc_get_prev_char_head(reg->enc, str, p, end);
+          if (!ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end)) {
+            p = prev;
+            goto retry;
+          }
+        }
+        break;
 
       case ANCHOR_END_LINE:
-	if (ON_STR_END(p)) {
+        if (ON_STR_END(p)) {
 #ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
-	  prev = onigenc_get_prev_char_head(reg->enc, adjrange, p);
-	  if (IS_NULL(prev)) goto fail;
-	  if (ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end)) {
-	    p = prev;
-	    goto retry;
-	  }
+          prev = onigenc_get_prev_char_head(reg->enc, adjrange, p);
+          if (IS_NULL(prev)) goto fail;
+          if (ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end)) {
+            p = prev;
+            goto retry;
+          }
 #endif
-	}
-	else if (! ONIGENC_IS_MBC_NEWLINE(reg->enc, p, end)
+        }
+        else if (! ONIGENC_IS_MBC_NEWLINE(reg->enc, p, end)
 #ifdef USE_CRNL_AS_LINE_TERMINATOR
               && ! ONIGENC_IS_MBC_CRNL(reg->enc, p, end)
 #endif
                 ) {
-	  p = onigenc_get_prev_char_head(reg->enc, adjrange, p, end);
-	  if (IS_NULL(p)) goto fail;
-	  goto retry;
-	}
-	break;
+          p = onigenc_get_prev_char_head(reg->enc, adjrange, p, end);
+          if (IS_NULL(p)) goto fail;
+          goto retry;
+        }
+        break;
       }
     }
 
@@ -3298,7 +3298,7 @@ backward_search_range(regex_t* reg, const UChar* str, const UChar* end,
 
 #ifdef ONIG_DEBUG_SEARCH
     fprintf(stderr, "backward_search_range: low: %d, high: %d\n",
-	    (int )(*low - str), (int )(*high - str));
+            (int )(*low - str), (int )(*high - str));
 #endif
     return 1; /* success */
   }
@@ -3313,7 +3313,7 @@ backward_search_range(regex_t* reg, const UChar* str, const UChar* end,
 
 extern long
 onig_search(regex_t* reg, const UChar* str, const UChar* end,
-	    const UChar* start, const UChar* range, OnigRegion* region, OnigOptionType option)
+            const UChar* start, const UChar* range, OnigRegion* region, OnigOptionType option)
 {
   int r;
   UChar *s, *prev;
@@ -3340,7 +3340,7 @@ onig_search(regex_t* reg, const UChar* str, const UChar* end,
     n = 0;
     while (ONIG_STATE(reg) < ONIG_STATE_NORMAL) {
       if (++n > THREAD_PASS_LIMIT_COUNT)
-	return ONIGERR_OVER_THREAD_PASS_LIMIT_COUNT;
+        return ONIGERR_OVER_THREAD_PASS_LIMIT_COUNT;
       THREAD_PASS;
     }
     goto start;
@@ -3418,23 +3418,23 @@ onig_search(regex_t* reg, const UChar* str, const UChar* end,
       /* search start-position only */
     begin_position:
       if (range > start)
-	range = start + 1;
+        range = start + 1;
       else
-	range = start;
+        range = start;
     }
     else if (reg->anchor & ANCHOR_BEGIN_BUF) {
       /* search str-position only */
       if (range > start) {
-	if (start != str) goto mismatch_no_msa;
-	range = str + 1;
+        if (start != str) goto mismatch_no_msa;
+        range = str + 1;
       }
       else {
-	if (range <= str) {
-	  start = str;
-	  range = str;
-	}
-	else
-	  goto mismatch_no_msa;
+        if (range <= str) {
+          start = str;
+          range = str;
+        }
+        else
+          goto mismatch_no_msa;
       }
     }
     else if (reg->anchor & ANCHOR_END_BUF) {
@@ -3442,32 +3442,32 @@ onig_search(regex_t* reg, const UChar* str, const UChar* end,
 
     end_buf:
       if ((OnigDistance )(max_semi_end - str) < reg->anchor_dmin)
-	goto mismatch_no_msa;
+        goto mismatch_no_msa;
 
       if (range > start) {
-	if ((OnigDistance )(min_semi_end - start) > reg->anchor_dmax) {
-	  start = min_semi_end - reg->anchor_dmax;
-	  if (start < end)
-	    start = onigenc_get_right_adjust_char_head(reg->enc, str, start, end);
-	  else { /* match with empty at end */
-	    start = onigenc_get_prev_char_head(reg->enc, str, end, end);
-	  }
-	}
-	if ((OnigDistance )(max_semi_end - (range - 1)) < reg->anchor_dmin) {
-	  range = max_semi_end - reg->anchor_dmin + 1;
-	}
-
-	if (start >= range) goto mismatch_no_msa;
+        if ((OnigDistance )(min_semi_end - start) > reg->anchor_dmax) {
+          start = min_semi_end - reg->anchor_dmax;
+          if (start < end)
+            start = onigenc_get_right_adjust_char_head(reg->enc, str, start, end);
+          else { /* match with empty at end */
+            start = onigenc_get_prev_char_head(reg->enc, str, end, end);
+          }
+        }
+        if ((OnigDistance )(max_semi_end - (range - 1)) < reg->anchor_dmin) {
+          range = max_semi_end - reg->anchor_dmin + 1;
+        }
+
+        if (start >= range) goto mismatch_no_msa;
       }
       else {
-	if ((OnigDistance )(min_semi_end - range) > reg->anchor_dmax) {
-	  range = min_semi_end - reg->anchor_dmax;
-	}
-	if ((OnigDistance )(max_semi_end - start) < reg->anchor_dmin) {
-	  start = max_semi_end - reg->anchor_dmin;
-	  start = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, start, end);
-	}
-	if (range > start) goto mismatch_no_msa;
+        if ((OnigDistance )(min_semi_end - range) > reg->anchor_dmax) {
+          range = min_semi_end - reg->anchor_dmax;
+        }
+        if ((OnigDistance )(max_semi_end - start) < reg->anchor_dmin) {
+          start = max_semi_end - reg->anchor_dmin;
+          start = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, start, end);
+        }
+        if (range > start) goto mismatch_no_msa;
       }
     }
     else if (reg->anchor & ANCHOR_SEMI_END_BUF) {
@@ -3475,22 +3475,22 @@ onig_search(regex_t* reg, const UChar* str, const UChar* end,
 
       max_semi_end = (UChar* )end;
       if (ONIGENC_IS_MBC_NEWLINE(reg->enc, pre_end, end)) {
-	min_semi_end = pre_end;
+        min_semi_end = pre_end;
 
 #ifdef USE_CRNL_AS_LINE_TERMINATOR
-	pre_end = ONIGENC_STEP_BACK(reg->enc, str, pre_end, end, 1);
-	if (IS_NOT_NULL(pre_end) &&
-	    ONIGENC_IS_MBC_CRNL(reg->enc, pre_end, end)) {
-	  min_semi_end = pre_end;
-	}
+        pre_end = ONIGENC_STEP_BACK(reg->enc, str, pre_end, end, 1);
+        if (IS_NOT_NULL(pre_end) &&
+            ONIGENC_IS_MBC_CRNL(reg->enc, pre_end, end)) {
+          min_semi_end = pre_end;
+        }
 #endif
-	if (min_semi_end > str && start <= min_semi_end) {
-	  goto end_buf;
-	}
+        if (min_semi_end > str && start <= min_semi_end) {
+          goto end_buf;
+        }
       }
       else {
-	min_semi_end = (UChar* )end;
-	goto end_buf;
+        min_semi_end = (UChar* )end;
+        goto end_buf;
       }
     }
     else if ((reg->anchor & ANCHOR_ANYCHAR_STAR_ML)) {
@@ -3522,7 +3522,7 @@ onig_search(regex_t* reg, const UChar* str, const UChar* end,
 
 #ifdef ONIG_DEBUG_SEARCH
   fprintf(stderr, "onig_search(apply anchor): end: %d, start: %d, range: %d\n",
-	  (int )(end - str), (int )(start - str), (int )(range - str));
+          (int )(end - str), (int )(start - str), (int )(range - str));
 #endif
 
   MATCH_ARG_INIT(msa, option, region, orig_start);
@@ -3545,36 +3545,36 @@ onig_search(regex_t* reg, const UChar* str, const UChar* end,
 
       sch_range = (UChar* )range;
       if (reg->dmax != 0) {
-	if (reg->dmax == ONIG_INFINITE_DISTANCE)
-	  sch_range = (UChar* )end;
-	else {
-	  sch_range += reg->dmax;
-	  if (sch_range > end) sch_range = (UChar* )end;
-	}
+        if (reg->dmax == ONIG_INFINITE_DISTANCE)
+          sch_range = (UChar* )end;
+        else {
+          sch_range += reg->dmax;
+          if (sch_range > end) sch_range = (UChar* )end;
+        }
       }
 
       if ((end - start) < reg->threshold_len)
         goto mismatch;
 
       if (reg->dmax != ONIG_INFINITE_DISTANCE) {
-	do {
-	  if (! forward_search_range(reg, str, end, s, sch_range,
-				     &low, &high, &low_prev)) goto mismatch;
-	  if (s < low) {
-	    s    = low;
-	    prev = low_prev;
-	  }
-	  while (s <= high) {
-	    MATCH_AND_RETURN_CHECK(orig_range);
-	    prev = s;
-	    s += enclen(reg->enc, s, end);
-	  }
-	} while (s < range);
-	goto mismatch;
+        do {
+          if (! forward_search_range(reg, str, end, s, sch_range,
+                                     &low, &high, &low_prev)) goto mismatch;
+          if (s < low) {
+            s    = low;
+            prev = low_prev;
+          }
+          while (s <= high) {
+            MATCH_AND_RETURN_CHECK(orig_range);
+            prev = s;
+            s += enclen(reg->enc, s, end);
+          }
+        } while (s < range);
+        goto mismatch;
       }
       else { /* check only. */
-	if (! forward_search_range(reg, str, end, s, sch_range,
-				   &low, &high, (UChar** )NULL)) goto mismatch;
+        if (! forward_search_range(reg, str, end, s, sch_range,
+                                   &low, &high, (UChar** )NULL)) goto mismatch;
 
         if ((reg->anchor & ANCHOR_ANYCHAR_STAR) != 0) {
           do {
@@ -3600,54 +3600,54 @@ onig_search(regex_t* reg, const UChar* str, const UChar* end,
   else {  /* backward search */
 #ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
     if (orig_start < end)
-	orig_start += enclen(reg->enc, orig_start, end); /* is upper range */
+        orig_start += enclen(reg->enc, orig_start, end); /* is upper range */
 #endif
 
     if (reg->optimize != ONIG_OPTIMIZE_NONE) {
       UChar *low, *high, *adjrange, *sch_start;
 
       if (range < end)
-	adjrange = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, range, end);
+        adjrange = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, range, end);
       else
-	adjrange = (UChar* )end;
+        adjrange = (UChar* )end;
 
       if (reg->dmax != ONIG_INFINITE_DISTANCE &&
-	  (end - range) >= reg->threshold_len) {
-	do {
-	  sch_start = s + reg->dmax;
-	  if (sch_start > end) sch_start = (UChar* )end;
-	  if (backward_search_range(reg, str, end, sch_start, range, adjrange,
-				    &low, &high) <= 0)
-	    goto mismatch;
-
-	  if (s > high)
-	    s = high;
-
-	  while (s >= low) {
-	    prev = onigenc_get_prev_char_head(reg->enc, str, s, end);
-	    MATCH_AND_RETURN_CHECK(orig_start);
-	    s = prev;
-	  }
-	} while (s >= range);
-	goto mismatch;
+          (end - range) >= reg->threshold_len) {
+        do {
+          sch_start = s + reg->dmax;
+          if (sch_start > end) sch_start = (UChar* )end;
+          if (backward_search_range(reg, str, end, sch_start, range, adjrange,
+                                    &low, &high) <= 0)
+            goto mismatch;
+
+          if (s > high)
+            s = high;
+
+          while (s >= low) {
+            prev = onigenc_get_prev_char_head(reg->enc, str, s, end);
+            MATCH_AND_RETURN_CHECK(orig_start);
+            s = prev;
+          }
+        } while (s >= range);
+        goto mismatch;
       }
       else { /* check only. */
-	if ((end - range) < reg->threshold_len) goto mismatch;
-
-	sch_start = s;
-	if (reg->dmax != 0) {
-	  if (reg->dmax == ONIG_INFINITE_DISTANCE)
-	    sch_start = (UChar* )end;
-	  else {
-	    sch_start += reg->dmax;
-	    if (sch_start > end) sch_start = (UChar* )end;
-	    else
-	      sch_start = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc,
-						    start, sch_start, end);
-	  }
-	}
-	if (backward_search_range(reg, str, end, sch_start, range, adjrange,
-				  &low, &high) <= 0) goto mismatch;
+        if ((end - range) < reg->threshold_len) goto mismatch;
+
+        sch_start = s;
+        if (reg->dmax != 0) {
+          if (reg->dmax == ONIG_INFINITE_DISTANCE)
+            sch_start = (UChar* )end;
+          else {
+            sch_start += reg->dmax;
+            if (sch_start > end) sch_start = (UChar* )end;
+            else
+              sch_start = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc,
+                                                    start, sch_start, end);
+          }
+        }
+        if (backward_search_range(reg, str, end, sch_start, range, adjrange,
+                                  &low, &high) <= 0) goto mismatch;
       }
     }
 
diff --git a/src/regint.h b/src/regint.h
index bf19eee1a..23e3a8c05 100644
--- a/src/regint.h
+++ b/src/regint.h
@@ -284,7 +284,7 @@ typedef unsigned int  BitStatusType;
   ((n) < (int )BIT_STATUS_BITS_NUM  ?  ((stats) & (1 << n)) : ((stats) & 1))
 
 #define BIT_STATUS_ON_AT(stats,n) do {\
-    if ((n) < (int )BIT_STATUS_BITS_NUM)	\
+    if ((n) < (int )BIT_STATUS_BITS_NUM)        \
     (stats) |= (1 << (n));\
   else\
     (stats) |= 1;\
@@ -347,7 +347,7 @@ typedef Bits*          BitSetRef;
 
 #define BITSET_CLEAR(bs) do {\
   int i;\
-  for (i = 0; i < (int )BITSET_SIZE; i++) { (bs)[i] = 0; }	\
+  for (i = 0; i < (int )BITSET_SIZE; i++) { (bs)[i] = 0; }      \
 } while (0)
 
 #define BS_ROOM(bs,pos)            (bs)[pos / BITS_IN_ROOM]
@@ -814,8 +814,8 @@ extern int onig_st_insert_strend(hash_table_type* table, const UChar* str_key, c
 /* encoding property management */
 #define PROPERTY_LIST_ADD_PROP(Name, CR) \
   r = onigenc_property_list_add_property((UChar* )Name, CR,\
-	      &PropertyNameTable, &PropertyList, &PropertyListNum,\
-	      &PropertyListSize);\
+              &PropertyNameTable, &PropertyList, &PropertyListNum,\
+              &PropertyListSize);\
   if (r != 0) goto end
 
 #define PROPERTY_LIST_INIT_CHECK \
diff --git a/src/regparse.c b/src/regparse.c
index c07d5c35e..ee933662c 100644
--- a/src/regparse.c
+++ b/src/regparse.c
@@ -271,7 +271,7 @@ strdup_with_null(OnigEncoding enc, UChar* s, UChar* end)
 
 static UChar*
 strcat_capa(UChar* dest, UChar* dest_end, const UChar* src, const UChar* src_end,
-	      int capa)
+              int capa)
 {
   UChar* r;
 
@@ -288,7 +288,7 @@ strcat_capa(UChar* dest, UChar* dest_end, const UChar* src, const UChar* src_end
 /* dest on static area */
 static UChar*
 strcat_capa_from_static(UChar* dest, UChar* dest_end,
-			const UChar* src, const UChar* src_end, int capa)
+                        const UChar* src, const UChar* src_end, int capa)
 {
   UChar* r;
 
@@ -363,7 +363,7 @@ onig_st_init_strend_table_with_size(st_index_t size)
 
 extern int
 onig_st_lookup_strend(hash_table_type* table, const UChar* str_key,
-		      const UChar* end_key, hash_data_type *value)
+                      const UChar* end_key, hash_data_type *value)
 {
   st_str_end_key key;
 
@@ -375,7 +375,7 @@ onig_st_lookup_strend(hash_table_type* table, const UChar* str_key,
 
 extern int
 onig_st_insert_strend(hash_table_type* table, const UChar* str_key,
-		      const UChar* end_key, hash_data_type value)
+                      const UChar* end_key, hash_data_type value)
 {
   st_str_end_key* key;
   int result;
@@ -514,8 +514,8 @@ i_names(UChar* key ARG_UNUSED, NameEntry* e, INamesArg* arg)
   int r = (*(arg->func))(e->name,
                          e->name + e->name_len,
                          e->back_num,
-			 (e->back_num > 1 ? e->back_refs : &(e->back_ref1)),
-			 arg->reg, arg->arg);
+                         (e->back_num > 1 ? e->back_refs : &(e->back_ref1)),
+                         arg->reg, arg->arg);
   if (r != 0) {
     arg->ret = r;
     return ST_STOP;
@@ -605,16 +605,16 @@ onig_print_names(FILE* fp, regex_t* reg)
       e = &(t->e[i]);
       fprintf(fp, "%s: ", e->name);
       if (e->back_num == 0) {
-	fputs("-", fp);
+        fputs("-", fp);
       }
       else if (e->back_num == 1) {
-	fprintf(fp, "%d", e->back_ref1);
+        fprintf(fp, "%d", e->back_ref1);
       }
       else {
-	for (j = 0; j < e->back_num; j++) {
-	  if (j > 0) fprintf(fp, ", ");
-	  fprintf(fp, "%d", e->back_refs[j]);
-	}
+        for (j = 0; j < e->back_num; j++) {
+          if (j > 0) fprintf(fp, ", ");
+          fprintf(fp, "%d", e->back_refs[j]);
+        }
       }
       fputs("\n", fp);
     }
@@ -635,13 +635,13 @@ names_clear(regex_t* reg)
     for (i = 0; i < t->num; i++) {
       e = &(t->e[i]);
       if (IS_NOT_NULL(e->name)) {
-	xfree(e->name);
-	e->name       = NULL;
-	e->name_len   = 0;
-	e->back_num   = 0;
-	e->back_alloc = 0;
-	if (IS_NOT_NULL(e->back_refs)) xfree(e->back_refs);
-	e->back_refs = (int* )NULL;
+        xfree(e->name);
+        e->name       = NULL;
+        e->name_len   = 0;
+        e->back_num   = 0;
+        e->back_alloc = 0;
+        if (IS_NOT_NULL(e->back_refs)) xfree(e->back_refs);
+        e->back_refs = (int* )NULL;
       }
     }
     if (IS_NOT_NULL(t->e)) {
@@ -680,7 +680,7 @@ name_find(regex_t* reg, UChar* name, UChar* name_end)
     for (i = 0; i < t->num; i++) {
       e = &(t->e[i]);
       if (len == e->name_len && onig_strncmp(name, e->name, len) == 0)
-	return e;
+        return e;
     }
   }
   return (NameEntry* )NULL;
@@ -698,8 +698,8 @@ onig_foreach_name(regex_t* reg,
     for (i = 0; i < t->num; i++) {
       e = &(t->e[i]);
       r = (*func)(e->name, e->name + e->name_len, e->back_num,
-		  (e->back_num > 1 ? e->back_refs : &(e->back_ref1)),
-		  reg, arg);
+                  (e->back_num > 1 ? e->back_refs : &(e->back_ref1)),
+                  reg, arg);
       if (r != 0) return r;
     }
   }
@@ -764,8 +764,8 @@ name_add(regex_t* reg, UChar* name, UChar* name_end, int backref, ScanEnv* env)
 
       t->e = (NameEntry* )xmalloc(sizeof(NameEntry) * alloc);
       if (IS_NULL(t->e)) {
-	xfree(t);
-	return ONIGERR_MEMORY;
+        xfree(t);
+        return ONIGERR_MEMORY;
       }
       t->alloc = alloc;
       reg->name_table = t;
@@ -781,11 +781,11 @@ name_add(regex_t* reg, UChar* name, UChar* name_end, int backref, ScanEnv* env)
 
     clear:
       for (i = t->num; i < t->alloc; i++) {
-	t->e[i].name       = NULL;
-	t->e[i].name_len   = 0;
-	t->e[i].back_num   = 0;
-	t->e[i].back_alloc = 0;
-	t->e[i].back_refs  = (int* )NULL;
+        t->e[i].name       = NULL;
+        t->e[i].name_len   = 0;
+        t->e[i].back_num   = 0;
+        t->e[i].back_alloc = 0;
+        t->e[i].back_refs  = (int* )NULL;
       }
     }
     e = &(t->e[t->num]);
@@ -799,7 +799,7 @@ name_add(regex_t* reg, UChar* name, UChar* name_end, int backref, ScanEnv* env)
   if (e->back_num >= 1 &&
       ! IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME)) {
     onig_scan_env_set_error_string(env, ONIGERR_MULTIPLEX_DEFINED_NAME,
-				    name, name_end);
+                                    name, name_end);
     return ONIGERR_MULTIPLEX_DEFINED_NAME;
   }
 
@@ -818,10 +818,10 @@ name_add(regex_t* reg, UChar* name, UChar* name_end, int backref, ScanEnv* env)
     }
     else {
       if (e->back_num > e->back_alloc) {
-	alloc = e->back_alloc * 2;
-	e->back_refs = (int* )xrealloc(e->back_refs, sizeof(int) * alloc);
-	CHECK_NULL_RETURN_MEMERR(e->back_refs);
-	e->back_alloc = alloc;
+        alloc = e->back_alloc * 2;
+        e->back_refs = (int* )xrealloc(e->back_refs, sizeof(int) * alloc);
+        CHECK_NULL_RETURN_MEMERR(e->back_refs);
+        e->back_alloc = alloc;
       }
       e->back_refs[e->back_num - 1] = backref;
     }
@@ -832,7 +832,7 @@ name_add(regex_t* reg, UChar* name, UChar* name_end, int backref, ScanEnv* env)
 
 extern int
 onig_name_to_group_numbers(regex_t* reg, const UChar* name,
-			   const UChar* name_end, int** nums)
+                           const UChar* name_end, int** nums)
 {
   NameEntry* e = name_find(reg, name, name_end);
 
@@ -854,7 +854,7 @@ onig_name_to_group_numbers(regex_t* reg, const UChar* name,
 
 extern int
 onig_name_to_backref_number(regex_t* reg, const UChar* name,
-			    const UChar* name_end, OnigRegion *region)
+                            const UChar* name_end, OnigRegion *region)
 {
   int i, n, *nums;
 
@@ -868,8 +868,8 @@ onig_name_to_backref_number(regex_t* reg, const UChar* name,
   else {
     if (IS_NOT_NULL(region)) {
       for (i = n - 1; i >= 0; i--) {
-	if (region->beg[nums[i]] != ONIG_REGION_NOTPOS)
-	  return nums[i];
+        if (region->beg[nums[i]] != ONIG_REGION_NOTPOS)
+          return nums[i];
       }
     }
     return nums[n - 1];
@@ -880,14 +880,14 @@ onig_name_to_backref_number(regex_t* reg, const UChar* name,
 
 extern int
 onig_name_to_group_numbers(regex_t* reg, const UChar* name,
-			   const UChar* name_end, int** nums)
+                           const UChar* name_end, int** nums)
 {
   return ONIG_NO_SUPPORT_CONFIG;
 }
 
 extern int
 onig_name_to_backref_number(regex_t* reg, const UChar* name,
-			    const UChar* name_end, OnigRegion* region)
+                            const UChar* name_end, OnigRegion* region)
 {
   return ONIG_NO_SUPPORT_CONFIG;
 }
@@ -967,19 +967,19 @@ scan_env_add_mem_entry(ScanEnv* env)
   if (need >= SCANENV_MEMNODES_SIZE) {
     if (env->mem_alloc <= need) {
       if (IS_NULL(env->mem_nodes_dynamic)) {
-	alloc = INIT_SCANENV_MEMNODES_ALLOC_SIZE;
-	p = (Node** )xmalloc(sizeof(Node*) * alloc);
-	xmemcpy(p, env->mem_nodes_static,
-		sizeof(Node*) * SCANENV_MEMNODES_SIZE);
+        alloc = INIT_SCANENV_MEMNODES_ALLOC_SIZE;
+        p = (Node** )xmalloc(sizeof(Node*) * alloc);
+        xmemcpy(p, env->mem_nodes_static,
+                sizeof(Node*) * SCANENV_MEMNODES_SIZE);
       }
       else {
-	alloc = env->mem_alloc * 2;
-	p = (Node** )xrealloc(env->mem_nodes_dynamic, sizeof(Node*) * alloc);
+        alloc = env->mem_alloc * 2;
+        p = (Node** )xrealloc(env->mem_nodes_dynamic, sizeof(Node*) * alloc);
       }
       CHECK_NULL_RETURN_MEMERR(p);
 
       for (i = env->num_mem + 1; i < alloc; i++)
-	p[i] = NULL_NODE;
+        p[i] = NULL_NODE;
 
       env->mem_nodes_dynamic = p;
       env->mem_alloc = alloc;
@@ -1018,7 +1018,7 @@ onig_node_free(Node* node)
   switch (NTYPE(node)) {
   case NT_STR:
     if (NSTR(node)->capa != 0 &&
-	IS_NOT_NULL(NSTR(node)->s) && NSTR(node)->s != NSTR(node)->buf) {
+        IS_NOT_NULL(NSTR(node)->s) && NSTR(node)->s != NSTR(node)->buf) {
       xfree(NSTR(node)->s);
     }
     break;
@@ -1031,11 +1031,11 @@ onig_node_free(Node* node)
 
 #ifdef USE_PARSE_TREE_NODE_RECYCLE
       {
-	FreeNode* n = (FreeNode* )node;
+        FreeNode* n = (FreeNode* )node;
 
         THREAD_ATOMIC_START;
-	n->next = FreeNodeList;
-	FreeNodeList = n;
+        n->next = FreeNodeList;
+        FreeNodeList = n;
         THREAD_ATOMIC_END;
       }
 #else
@@ -1152,7 +1152,7 @@ node_new_cclass(void)
 
 static Node*
 node_new_cclass_by_codepoint_range(int not, OnigCodePoint sb_out,
-				   const OnigCodePoint ranges[])
+                                   const OnigCodePoint ranges[])
 {
   int n, i;
   CClassNode* cc;
@@ -1170,7 +1170,7 @@ node_new_cclass_by_codepoint_range(int not, OnigCodePoint sb_out,
     for (i = 0; i < n; i++) {
       for (j  = ONIGENC_CODE_RANGE_FROM(ranges, i);
            j <= (OnigCodePoint )ONIGENC_CODE_RANGE_TO(ranges, i); j++) {
-	if (j >= sb_out) goto sb_end;
+        if (j >= sb_out) goto sb_end;
 
         BITSET_SET_BIT(cc->bs, j);
       }
@@ -1286,9 +1286,9 @@ onig_node_new_anchor(int type)
 static Node*
 node_new_backref(int back_num, int* backrefs, int by_name,
 #ifdef USE_BACKREF_WITH_LEVEL
-		 int exist_level, int nest_level,
+                 int exist_level, int nest_level,
 #endif
-		 ScanEnv* env)
+                 ScanEnv* env)
 {
   int i;
   Node* node = node_new();
@@ -1311,7 +1311,7 @@ node_new_backref(int back_num, int* backrefs, int by_name,
 
   for (i = 0; i < back_num; i++) {
     if (backrefs[i] <= env->num_mem &&
-	IS_NULL(SCANENV_MEM_NODES(env)[backrefs[i]])) {
+        IS_NULL(SCANENV_MEM_NODES(env)[backrefs[i]])) {
       NBREF(node)->state |= NST_RECURSION;   /* /...(\1).../ */
       break;
     }
@@ -1436,18 +1436,18 @@ onig_node_str_cat(Node* node, const UChar* s, const UChar* end)
       ptrdiff_t capa = len + addlen + NODE_STR_MARGIN;
 
       if (capa <= NSTR(node)->capa) {
-	onig_strcpy(NSTR(node)->s + len, s, end);
+        onig_strcpy(NSTR(node)->s + len, s, end);
       }
       else {
-	if (NSTR(node)->s == NSTR(node)->buf)
-	  p = strcat_capa_from_static(NSTR(node)->s, NSTR(node)->end,
-				      s, end, capa);
-	else
-	  p = strcat_capa(NSTR(node)->s, NSTR(node)->end, s, end, capa);
+        if (NSTR(node)->s == NSTR(node)->buf)
+          p = strcat_capa_from_static(NSTR(node)->s, NSTR(node)->end,
+                                      s, end, capa);
+        else
+          p = strcat_capa(NSTR(node)->s, NSTR(node)->end, s, end, capa);
 
-	CHECK_NULL_RETURN_MEMERR(p);
-	NSTR(node)->s    = p;
-	NSTR(node)->capa = capa;
+        CHECK_NULL_RETURN_MEMERR(p);
+        NSTR(node)->s    = p;
+        NSTR(node)->capa = capa;
       }
     }
     else {
@@ -1557,7 +1557,7 @@ str_node_split_last_char(StrNode* sn, OnigEncoding enc)
     if (p && p > sn->s) { /* can be splitted. */
       n = node_new_str(p, sn->end);
       if ((sn->flag & NSTR_RAW) != 0)
-	NSTRING_SET_RAW(n);
+        NSTRING_SET_RAW(n);
       sn->end = (UChar* )p;
     }
   }
@@ -1587,7 +1587,7 @@ onig_scan_unsigned_number(UChar** src, const UChar* end, OnigEncoding enc)
     if (ONIGENC_IS_CODE_DIGIT(enc, c)) {
       val = (unsigned int )DIGITVAL(c);
       if ((INT_MAX_LIMIT - val) / 10UL < num)
-	return -1;  /* overflow */
+        return -1;  /* overflow */
 
       num = num * 10 + val;
     }
@@ -1602,7 +1602,7 @@ onig_scan_unsigned_number(UChar** src, const UChar* end, OnigEncoding enc)
 
 static int
 scan_unsigned_hexadecimal_number(UChar** src, UChar* end, int maxlen,
-				 OnigEncoding enc)
+                                 OnigEncoding enc)
 {
   OnigCodePoint c;
   unsigned int num, val;
@@ -1615,7 +1615,7 @@ scan_unsigned_hexadecimal_number(UChar** src, UChar* end, int maxlen,
     if (ONIGENC_IS_CODE_XDIGIT(enc, c)) {
       val = (unsigned int )XDIGITVAL(enc,c);
       if ((INT_MAX_LIMIT - val) / 16UL < num)
-	return -1;  /* overflow */
+        return -1;  /* overflow */
 
       num = (num << 4) + XDIGITVAL(enc,c);
     }
@@ -1630,7 +1630,7 @@ scan_unsigned_hexadecimal_number(UChar** src, UChar* end, int maxlen,
 
 static int
 scan_unsigned_octal_number(UChar** src, UChar* end, int maxlen,
-			   OnigEncoding enc)
+                           OnigEncoding enc)
 {
   OnigCodePoint c;
   unsigned int num, val;
@@ -1643,7 +1643,7 @@ scan_unsigned_octal_number(UChar** src, UChar* end, int maxlen,
     if (ONIGENC_IS_CODE_DIGIT(enc, c) && c < '8') {
       val = ODIGITVAL(c);
       if ((INT_MAX_LIMIT - val) / 8UL < num)
-	return -1;  /* overflow */
+        return -1;  /* overflow */
 
       num = (num << 3) + val;
     }
@@ -1684,7 +1684,7 @@ new_code_range(BBuf** pbuf)
 
 static int
 add_code_range_to_buf0(BBuf** pbuf, ScanEnv* env, OnigCodePoint from, OnigCodePoint to,
-	int checkdup)
+        int checkdup)
 {
   int r, inc_n, pos;
   int low, high, bound, x;
@@ -1851,10 +1851,10 @@ or_code_range_buf(OnigEncoding enc, BBuf* bbuf1, int not1,
     }
     else {
       if (not2 == 0) {
-	return bbuf_clone(pbuf, bbuf2);
+        return bbuf_clone(pbuf, bbuf2);
       }
       else {
-	return not_code_range_buf(enc, bbuf2, pbuf, env);
+        return not_code_range_buf(enc, bbuf2, pbuf, env);
       }
     }
   }
@@ -1885,7 +1885,7 @@ or_code_range_buf(OnigEncoding enc, BBuf* bbuf1, int not1,
 
 static int
 and_code_range1(BBuf** pbuf, ScanEnv* env, OnigCodePoint from1, OnigCodePoint to1,
-	        OnigCodePoint* data, int n)
+                OnigCodePoint* data, int n)
 {
   int i, r;
   OnigCodePoint from2, to2;
@@ -1896,19 +1896,19 @@ and_code_range1(BBuf** pbuf, ScanEnv* env, OnigCodePoint from1, OnigCodePoint to
     if (from2 < from1) {
       if (to2 < from1) continue;
       else {
-	from1 = to2 + 1;
+        from1 = to2 + 1;
       }
     }
     else if (from2 <= to1) {
       if (to2 < to1) {
-	if (from1 <= from2 - 1) {
-	  r = add_code_range_to_buf(pbuf, env, from1, from2-1);
-	  if (r != 0) return r;
-	}
-	from1 = to2 + 1;
+        if (from1 <= from2 - 1) {
+          r = add_code_range_to_buf(pbuf, env, from1, from2-1);
+          if (r != 0) return r;
+        }
+        from1 = to2 + 1;
       }
       else {
-	to1 = from2 - 1;
+        to1 = from2 - 1;
       }
     }
     else {
@@ -1957,14 +1957,14 @@ and_code_range_buf(BBuf* bbuf1, int not1, BBuf* bbuf2, int not2, BBuf** pbuf, Sc
       from1 = data1[i*2];
       to1   = data1[i*2+1];
       for (j = 0; j < n2; j++) {
-	from2 = data2[j*2];
-	to2   = data2[j*2+1];
-	if (from2 > to1) break;
-	if (to2 < from1) continue;
-	from = MAX(from1, from2);
-	to   = MIN(to1, to2);
-	r = add_code_range_to_buf(pbuf, env, from, to);
-	if (r != 0) return r;
+        from2 = data2[j*2];
+        to2   = data2[j*2+1];
+        if (from2 > to1) break;
+        if (to2 < from1) continue;
+        from = MAX(from1, from2);
+        to   = MIN(to1, to2);
+        r = add_code_range_to_buf(pbuf, env, from, to);
+        if (r != 0) return r;
       }
     }
   }
@@ -2020,15 +2020,15 @@ and_cclass(CClassNode* dest, CClassNode* cc, ScanEnv* env)
     else {
       r = and_code_range_buf(buf1, not1, buf2, not2, &pbuf, env);
       if (r == 0 && not1 != 0) {
-	BBuf *tbuf = 0;
-	r = not_code_range_buf(enc, pbuf, &tbuf, env);
-	bbuf_free(pbuf);
-	pbuf = tbuf;
+        BBuf *tbuf = 0;
+        r = not_code_range_buf(enc, pbuf, &tbuf, env);
+        bbuf_free(pbuf);
+        pbuf = tbuf;
       }
     }
     if (r != 0) {
-	bbuf_free(pbuf);
-	return r;
+        bbuf_free(pbuf);
+        return r;
     }
 
     dest->mbuf = pbuf;
@@ -2078,15 +2078,15 @@ or_cclass(CClassNode* dest, CClassNode* cc, ScanEnv* env)
     else {
       r = or_code_range_buf(enc, buf1, not1, buf2, not2, &pbuf, env);
       if (r == 0 && not1 != 0) {
-	BBuf *tbuf = 0;
-	r = not_code_range_buf(enc, pbuf, &tbuf, env);
-	bbuf_free(pbuf);
-	pbuf = tbuf;
+        BBuf *tbuf = 0;
+        r = not_code_range_buf(enc, pbuf, &tbuf, env);
+        bbuf_free(pbuf);
+        pbuf = tbuf;
       }
     }
     if (r != 0) {
-	bbuf_free(pbuf);
-	return r;
+        bbuf_free(pbuf);
+        return r;
     }
 
     dest->mbuf = pbuf;
@@ -2113,12 +2113,12 @@ conv_backslash_value(int c, ScanEnv* env)
     case 'e': return '\033';
     case 'v':
       if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ESC_V_VTAB))
-	return '\v';
+        return '\v';
       break;
 
     default:
       if (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z'))
-	  UNKNOWN_ESC_WARN(env, c);
+          UNKNOWN_ESC_WARN(env, c);
       break;
     }
   }
@@ -2343,7 +2343,7 @@ fetch_range_quantifier(UChar** src, UChar* end, OnigToken* tok, ScanEnv* env)
 
     if (p == prev) {
       if (non_low != 0)
-	goto invalid;
+        goto invalid;
       up = REPEAT_INFINITE;  /* {n,} : {n,infinite} */
     }
   }
@@ -2403,8 +2403,8 @@ fetch_escaped_value(UChar** src, UChar* end, ScanEnv* env)
       if (PEND) return ONIGERR_END_PATTERN_AT_META;
       PFETCH(c);
       if (c == MC_ESC(env->syntax)) {
-	v = fetch_escaped_value(&p, end, env);
-	if (v < 0) return v;
+        v = fetch_escaped_value(&p, end, env);
+        if (v < 0) return v;
         c = (OnigCodePoint )v;
       }
       c = ((c & 0xff) | 0x80);
@@ -2429,7 +2429,7 @@ fetch_escaped_value(UChar** src, UChar* end, ScanEnv* env)
       if (PEND) return ONIGERR_END_PATTERN_AT_CONTROL;
       PFETCH(c);
       if (c == '?') {
-	c = 0177;
+        c = 0177;
       }
       else {
         if (c == MC_ESC(env->syntax)) {
@@ -2437,7 +2437,7 @@ fetch_escaped_value(UChar** src, UChar* end, ScanEnv* env)
           if (v < 0) return v;
           c = (OnigCodePoint )v;
         }
-	c &= 0x9f;
+        c &= 0x9f;
       }
       break;
     }
@@ -2479,8 +2479,8 @@ get_name_end_code_point(OnigCodePoint start)
 */
 static int
 fetch_name_with_level(OnigCodePoint start_code, UChar** src, UChar* end,
-		      UChar** rname_end, ScanEnv* env,
-		      int* rback_num, int* rlevel)
+                      UChar** rname_end, ScanEnv* env,
+                      int* rback_num, int* rlevel)
 {
   int r, sign, is_num, exist_level;
   OnigCodePoint end_code;
@@ -2525,17 +2525,17 @@ fetch_name_with_level(OnigCodePoint start_code, UChar** src, UChar* end,
     name_end = p;
     PFETCH(c);
     if (c == end_code || c == ')' || c == '+' || c == '-') {
-      if (is_num == 2) 	r = ONIGERR_INVALID_GROUP_NAME;
+      if (is_num == 2)  r = ONIGERR_INVALID_GROUP_NAME;
       break;
     }
 
     if (is_num != 0) {
       if (ONIGENC_IS_CODE_DIGIT(enc, c)) {
-	is_num = 1;
+        is_num = 1;
       }
       else {
-	r = ONIGERR_INVALID_GROUP_NAME;
-	is_num = 0;
+        r = ONIGERR_INVALID_GROUP_NAME;
+        is_num = 0;
       }
     }
     else if (!ONIGENC_IS_CODE_WORD(enc, c)) {
@@ -2558,7 +2558,7 @@ fetch_name_with_level(OnigCodePoint start_code, UChar** src, UChar* end,
 
       PFETCH(c);
       if (c == end_code)
-	goto end;
+        goto end;
     }
 
   err:
@@ -2593,7 +2593,7 @@ fetch_name_with_level(OnigCodePoint start_code, UChar** src, UChar* end,
 */
 static int
 fetch_name(OnigCodePoint start_code, UChar** src, UChar* end,
-	   UChar** rname_end, ScanEnv* env, int* rback_num, int ref)
+           UChar** rname_end, ScanEnv* env, int* rback_num, int ref)
 {
   int r, is_num, sign;
   OnigCodePoint end_code;
@@ -2623,21 +2623,21 @@ fetch_name(OnigCodePoint start_code, UChar** src, UChar* end,
 
     if (ONIGENC_IS_CODE_DIGIT(enc, c)) {
       if (ref == 1)
-	is_num = 1;
+        is_num = 1;
       else {
-	r = ONIGERR_INVALID_GROUP_NAME;
-	is_num = 0;
+        r = ONIGERR_INVALID_GROUP_NAME;
+        is_num = 0;
       }
     }
     else if (c == '-') {
       if (ref == 1) {
-	is_num = 2;
-	sign = -1;
-	pnum_head = p;
+        is_num = 2;
+        sign = -1;
+        pnum_head = p;
       }
       else {
-	r = ONIGERR_INVALID_GROUP_NAME;
-	is_num = 0;
+        r = ONIGERR_INVALID_GROUP_NAME;
+        is_num = 0;
       }
     }
     else if (!ONIGENC_IS_CODE_WORD(enc, c)) {
@@ -2650,27 +2650,27 @@ fetch_name(OnigCodePoint start_code, UChar** src, UChar* end,
       name_end = p;
       PFETCH(c);
       if (c == end_code || c == ')') {
-	if (is_num == 2) 	r = ONIGERR_INVALID_GROUP_NAME;
-	break;
+        if (is_num == 2)        r = ONIGERR_INVALID_GROUP_NAME;
+        break;
       }
 
       if (is_num != 0) {
-	if (ONIGENC_IS_CODE_DIGIT(enc, c)) {
-	  is_num = 1;
-	}
-	else {
-	  if (!ONIGENC_IS_CODE_WORD(enc, c))
-	    r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME;
-	  else
-	    r = ONIGERR_INVALID_GROUP_NAME;
-
-	  is_num = 0;
-	}
+        if (ONIGENC_IS_CODE_DIGIT(enc, c)) {
+          is_num = 1;
+        }
+        else {
+          if (!ONIGENC_IS_CODE_WORD(enc, c))
+            r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME;
+          else
+            r = ONIGERR_INVALID_GROUP_NAME;
+
+          is_num = 0;
+        }
       }
       else {
-	if (!ONIGENC_IS_CODE_WORD(enc, c)) {
-	  r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME;
-	}
+        if (!ONIGENC_IS_CODE_WORD(enc, c)) {
+          r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME;
+        }
       }
     }
 
@@ -2683,8 +2683,8 @@ fetch_name(OnigCodePoint start_code, UChar** src, UChar* end,
       *rback_num = onig_scan_unsigned_number(&pnum_head, name_end, enc);
       if (*rback_num < 0) return ONIGERR_TOO_BIG_NUMBER;
       else if (*rback_num == 0) {
-	r = ONIGERR_INVALID_GROUP_NAME;
-	goto err;
+        r = ONIGERR_INVALID_GROUP_NAME;
+        goto err;
       }
 
       *rback_num *= sign;
@@ -2699,7 +2699,7 @@ fetch_name(OnigCodePoint start_code, UChar** src, UChar* end,
       name_end = p;
       PFETCH(c);
       if (c == end_code || c == ')')
-	break;
+        break;
     }
     if (PEND)
       name_end = end;
@@ -2712,7 +2712,7 @@ fetch_name(OnigCodePoint start_code, UChar** src, UChar* end,
 #else
 static int
 fetch_name(OnigCodePoint start_code, UChar** src, UChar* end,
-	   UChar** rname_end, ScanEnv* env, int* rback_num, int ref)
+           UChar** rname_end, ScanEnv* env, int* rback_num, int ref)
 {
   int r, is_num, sign;
   OnigCodePoint end_code;
@@ -2798,8 +2798,8 @@ onig_syntax_warn(ScanEnv *env, const char *fmt, ...)
     UChar buf[WARN_BUFSIZE];
     va_start(args, fmt);
     onig_vsnprintf_with_pattern(buf, WARN_BUFSIZE, env->enc,
-		env->pattern, env->pattern_end,
-		(const UChar *)fmt, args);
+                env->pattern, env->pattern_end,
+                (const UChar *)fmt, args);
     va_end(args);
     if (env->sourcefile == NULL)
       mrb_warn("%s", (char *)buf);
@@ -2849,7 +2849,7 @@ UNKNOWN_ESC_WARN(ScanEnv *env, int c)
 
 static UChar*
 find_str_position(OnigCodePoint s[], int n, UChar* from, UChar* to,
-		  UChar **next, OnigEncoding enc)
+                  UChar **next, OnigEncoding enc)
 {
   int i;
   OnigCodePoint x;
@@ -2861,14 +2861,14 @@ find_str_position(OnigCodePoint s[], int n, UChar* from, UChar* to,
     q = p + enclen(enc, p, to);
     if (x == s[0]) {
       for (i = 1; i < n && q < to; i++) {
-	x = ONIGENC_MBC_TO_CODE(enc, q, to);
-	if (x != s[i]) break;
-	q += enclen(enc, q, to);
+        x = ONIGENC_MBC_TO_CODE(enc, q, to);
+        if (x != s[i]) break;
+        q += enclen(enc, q, to);
       }
       if (i >= n) {
-	if (IS_NOT_NULL(next))
-	  *next = q;
-	return p;
+        if (IS_NOT_NULL(next))
+          *next = q;
+        return p;
       }
     }
     p = q;
@@ -2878,7 +2878,7 @@ find_str_position(OnigCodePoint s[], int n, UChar* from, UChar* to,
 
 static int
 str_exist_check_with_esc(OnigCodePoint s[], int n, UChar* from, UChar* to,
-		 OnigCodePoint bad, OnigEncoding enc, const OnigSyntaxType* syn)
+                 OnigCodePoint bad, OnigEncoding enc, const OnigSyntaxType* syn)
 {
   int i, in_esc;
   OnigCodePoint x;
@@ -2895,19 +2895,19 @@ str_exist_check_with_esc(OnigCodePoint s[], int n, UChar* from, UChar* to,
       x = ONIGENC_MBC_TO_CODE(enc, p, to);
       q = p + enclen(enc, p, to);
       if (x == s[0]) {
-	for (i = 1; i < n && q < to; i++) {
-	  x = ONIGENC_MBC_TO_CODE(enc, q, to);
-	  if (x != s[i]) break;
-	  q += enclen(enc, q, to);
-	}
-	if (i >= n) return 1;
-	p += enclen(enc, p, to);
+        for (i = 1; i < n && q < to; i++) {
+          x = ONIGENC_MBC_TO_CODE(enc, q, to);
+          if (x != s[i]) break;
+          q += enclen(enc, q, to);
+        }
+        if (i >= n) return 1;
+        p += enclen(enc, p, to);
       }
       else {
-	x = ONIGENC_MBC_TO_CODE(enc, p, to);
-	if (x == bad) return 0;
-	else if (x == MC_ESC(syn)) in_esc = 1;
-	p = q;
+        x = ONIGENC_MBC_TO_CODE(enc, p, to);
+        if (x == bad) return 0;
+        else if (x == MC_ESC(syn)) in_esc = 1;
+        p = q;
       }
     }
   }
@@ -2999,22 +2999,22 @@ fetch_token_in_cc(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
     case 'P':
       c2 = PPEEK;
       if (c2 == '{' &&
-	  IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY)) {
-	PINC;
-	tok->type = TK_CHAR_PROPERTY;
-	tok->u.prop.not = (c == 'P' ? 1 : 0);
-
-	if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT)) {
-	  PFETCH(c2);
-	  if (c2 == '^') {
-	    tok->u.prop.not = (tok->u.prop.not == 0 ? 1 : 0);
-	  }
-	  else
-	    PUNFETCH;
-	}
+          IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY)) {
+        PINC;
+        tok->type = TK_CHAR_PROPERTY;
+        tok->u.prop.not = (c == 'P' ? 1 : 0);
+
+        if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT)) {
+          PFETCH(c2);
+          if (c2 == '^') {
+            tok->u.prop.not = (tok->u.prop.not == 0 ? 1 : 0);
+          }
+          else
+            PUNFETCH;
+        }
       }
       else {
-	  onig_syntax_warn(env, "invalid Unicode Property \\%c", c);
+          onig_syntax_warn(env, "invalid Unicode Property \\%c", c);
       }
       break;
 
@@ -3023,35 +3023,35 @@ fetch_token_in_cc(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
 
       prev = p;
       if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_BRACE_HEX8)) {
-	PINC;
-	num = scan_unsigned_hexadecimal_number(&p, end, 8, enc);
-	if (num < 0) return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE;
-	if (!PEND) {
+        PINC;
+        num = scan_unsigned_hexadecimal_number(&p, end, 8, enc);
+        if (num < 0) return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE;
+        if (!PEND) {
           c2 = PPEEK;
           if (ONIGENC_IS_CODE_XDIGIT(enc, c2))
             return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE;
         }
 
-	if (p > prev + enclen(enc, prev, end) && !PEND && (PPEEK_IS('}'))) {
-	  PINC;
-	  tok->type   = TK_CODE_POINT;
-	  tok->base   = 16;
-	  tok->u.code = (OnigCodePoint )num;
-	}
-	else {
-	  /* can't read nothing or invalid format */
-	  p = prev;
-	}
+        if (p > prev + enclen(enc, prev, end) && !PEND && (PPEEK_IS('}'))) {
+          PINC;
+          tok->type   = TK_CODE_POINT;
+          tok->base   = 16;
+          tok->u.code = (OnigCodePoint )num;
+        }
+        else {
+          /* can't read nothing or invalid format */
+          p = prev;
+        }
       }
       else if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_HEX2)) {
-	num = scan_unsigned_hexadecimal_number(&p, end, 2, enc);
-	if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
-	if (p == prev) {  /* can't read nothing. */
-	  num = 0; /* but, it's not error */
-	}
-	tok->type = TK_RAW_BYTE;
-	tok->base = 16;
-	tok->u.c  = num;
+        num = scan_unsigned_hexadecimal_number(&p, end, 2, enc);
+        if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
+        if (p == prev) {  /* can't read nothing. */
+          num = 0; /* but, it's not error */
+        }
+        tok->type = TK_RAW_BYTE;
+        tok->base = 16;
+        tok->u.c  = num;
       }
       break;
 
@@ -3060,30 +3060,30 @@ fetch_token_in_cc(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
 
       prev = p;
       if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_U_HEX4)) {
-	num = scan_unsigned_hexadecimal_number(&p, end, 4, enc);
-	if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
-	if (p == prev) {  /* can't read nothing. */
-	  num = 0; /* but, it's not error */
-	}
-	tok->type   = TK_CODE_POINT;
-	tok->base   = 16;
-	tok->u.code = (OnigCodePoint )num;
+        num = scan_unsigned_hexadecimal_number(&p, end, 4, enc);
+        if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
+        if (p == prev) {  /* can't read nothing. */
+          num = 0; /* but, it's not error */
+        }
+        tok->type   = TK_CODE_POINT;
+        tok->base   = 16;
+        tok->u.code = (OnigCodePoint )num;
       }
       break;
 
     case '0':
     case '1': case '2': case '3': case '4': case '5': case '6': case '7':
       if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_OCTAL3)) {
-	PUNFETCH;
-	prev = p;
-	num = scan_unsigned_octal_number(&p, end, 3, enc);
-	if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
-	if (p == prev) {  /* can't read nothing. */
-	  num = 0; /* but, it's not error */
-	}
-	tok->type = TK_RAW_BYTE;
-	tok->base = 8;
-	tok->u.c  = num;
+        PUNFETCH;
+        prev = p;
+        num = scan_unsigned_octal_number(&p, end, 3, enc);
+        if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
+        if (p == prev) {  /* can't read nothing. */
+          num = 0; /* but, it's not error */
+        }
+        tok->type = TK_RAW_BYTE;
+        tok->base = 8;
+        tok->u.c  = num;
       }
       break;
 
@@ -3092,8 +3092,8 @@ fetch_token_in_cc(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
       num = fetch_escaped_value(&p, end, env);
       if (num < 0) return num;
       if (tok->u.c != num) {
-	tok->u.code = (OnigCodePoint )num;
-	tok->type   = TK_CODE_POINT;
+        tok->u.code = (OnigCodePoint )num;
+        tok->type   = TK_CODE_POINT;
       }
       break;
     }
@@ -3105,26 +3105,26 @@ fetch_token_in_cc(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
       PINC;
       if (str_exist_check_with_esc(send, 2, p, end,
                                    (OnigCodePoint )']', enc, syn)) {
-	tok->type = TK_POSIX_BRACKET_OPEN;
+        tok->type = TK_POSIX_BRACKET_OPEN;
       }
       else {
-	PUNFETCH;
-	goto cc_in_cc;
+        PUNFETCH;
+        goto cc_in_cc;
       }
     }
     else {
     cc_in_cc:
       if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_CCLASS_SET_OP)) {
-	tok->type = TK_CC_CC_OPEN;
+        tok->type = TK_CC_CC_OPEN;
       }
       else {
-	CC_ESC_WARN(env, (UChar* )"[");
+        CC_ESC_WARN(env, (UChar* )"[");
       }
     }
   }
   else if (c == '&') {
     if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_CCLASS_SET_OP) &&
-	!PEND && (PPEEK_IS('&'))) {
+        !PEND && (PPEEK_IS('&'))) {
       PINC;
       tok->type = TK_CC_AND;
     }
@@ -3189,26 +3189,26 @@ fetch_token(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
       tok->u.repeat.upper = 1;
     greedy_check:
       if (!PEND && PPEEK_IS('?') &&
-	  IS_SYNTAX_OP(syn, ONIG_SYN_OP_QMARK_NON_GREEDY)) {
-	PFETCH(c);
-	tok->u.repeat.greedy     = 0;
-	tok->u.repeat.possessive = 0;
+          IS_SYNTAX_OP(syn, ONIG_SYN_OP_QMARK_NON_GREEDY)) {
+        PFETCH(c);
+        tok->u.repeat.greedy     = 0;
+        tok->u.repeat.possessive = 0;
       }
       else {
       possessive_check:
-	if (!PEND && PPEEK_IS('+') &&
-	    ((IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_PLUS_POSSESSIVE_REPEAT) &&
-	      tok->type != TK_INTERVAL)  ||
-	     (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_PLUS_POSSESSIVE_INTERVAL) &&
-	      tok->type == TK_INTERVAL))) {
-	  PFETCH(c);
-	  tok->u.repeat.greedy     = 1;
-	  tok->u.repeat.possessive = 1;
-	}
-	else {
-	  tok->u.repeat.greedy     = 1;
-	  tok->u.repeat.possessive = 0;
-	}
+        if (!PEND && PPEEK_IS('+') &&
+            ((IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_PLUS_POSSESSIVE_REPEAT) &&
+              tok->type != TK_INTERVAL)  ||
+             (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_PLUS_POSSESSIVE_INTERVAL) &&
+              tok->type == TK_INTERVAL))) {
+          PFETCH(c);
+          tok->u.repeat.greedy     = 1;
+          tok->u.repeat.possessive = 1;
+        }
+        else {
+          tok->u.repeat.greedy     = 1;
+          tok->u.repeat.possessive = 0;
+        }
       }
       break;
 
@@ -3218,10 +3218,10 @@ fetch_token(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
       if (r < 0) return r;  /* error */
       if (r == 0) goto greedy_check;
       else if (r == 2) { /* {n} */
-	if (IS_SYNTAX_BV(syn, ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY))
-	  goto possessive_check;
+        if (IS_SYNTAX_BV(syn, ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY))
+          goto possessive_check;
 
-	goto greedy_check;
+        goto greedy_check;
       }
       /* r == 1 : normal char */
       break;
@@ -3364,33 +3364,33 @@ fetch_token(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
 
       prev = p;
       if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_BRACE_HEX8)) {
-	PINC;
-	num = scan_unsigned_hexadecimal_number(&p, end, 8, enc);
-	if (num < 0) return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE;
-	if (!PEND) {
+        PINC;
+        num = scan_unsigned_hexadecimal_number(&p, end, 8, enc);
+        if (num < 0) return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE;
+        if (!PEND) {
           if (ONIGENC_IS_CODE_XDIGIT(enc, PPEEK))
             return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE;
         }
 
-	if ((p > prev + enclen(enc, prev, end)) && !PEND && PPEEK_IS('}')) {
-	  PINC;
-	  tok->type   = TK_CODE_POINT;
-	  tok->u.code = (OnigCodePoint )num;
-	}
-	else {
-	  /* can't read nothing or invalid format */
-	  p = prev;
-	}
+        if ((p > prev + enclen(enc, prev, end)) && !PEND && PPEEK_IS('}')) {
+          PINC;
+          tok->type   = TK_CODE_POINT;
+          tok->u.code = (OnigCodePoint )num;
+        }
+        else {
+          /* can't read nothing or invalid format */
+          p = prev;
+        }
       }
       else if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_HEX2)) {
-	num = scan_unsigned_hexadecimal_number(&p, end, 2, enc);
-	if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
-	if (p == prev) {  /* can't read nothing. */
-	  num = 0; /* but, it's not error */
-	}
-	tok->type = TK_RAW_BYTE;
-	tok->base = 16;
-	tok->u.c  = num;
+        num = scan_unsigned_hexadecimal_number(&p, end, 2, enc);
+        if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
+        if (p == prev) {  /* can't read nothing. */
+          num = 0; /* but, it's not error */
+        }
+        tok->type = TK_RAW_BYTE;
+        tok->base = 16;
+        tok->u.c  = num;
       }
       break;
 
@@ -3399,14 +3399,14 @@ fetch_token(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
 
       prev = p;
       if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_U_HEX4)) {
-	num = scan_unsigned_hexadecimal_number(&p, end, 4, enc);
-	if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
-	if (p == prev) {  /* can't read nothing. */
-	  num = 0; /* but, it's not error */
-	}
-	tok->type   = TK_CODE_POINT;
-	tok->base   = 16;
-	tok->u.code = (OnigCodePoint )num;
+        num = scan_unsigned_hexadecimal_number(&p, end, 4, enc);
+        if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
+        if (p == prev) {  /* can't read nothing. */
+          num = 0; /* but, it's not error */
+        }
+        tok->type   = TK_CODE_POINT;
+        tok->base   = 16;
+        tok->u.code = (OnigCodePoint )num;
       }
       break;
 
@@ -3420,119 +3420,119 @@ fetch_token(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
       }
 
       if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_DECIMAL_BACKREF) &&
-	  (num <= env->num_mem || num <= 9)) { /* This spec. from GNU regex */
-	if (IS_SYNTAX_BV(syn, ONIG_SYN_STRICT_CHECK_BACKREF)) {
-	  if (num > env->num_mem || IS_NULL(SCANENV_MEM_NODES(env)[num]))
-	    return ONIGERR_INVALID_BACKREF;
-	}
-
-	tok->type = TK_BACKREF;
-	tok->u.backref.num     = 1;
-	tok->u.backref.ref1    = num;
-	tok->u.backref.by_name = 0;
+          (num <= env->num_mem || num <= 9)) { /* This spec. from GNU regex */
+        if (IS_SYNTAX_BV(syn, ONIG_SYN_STRICT_CHECK_BACKREF)) {
+          if (num > env->num_mem || IS_NULL(SCANENV_MEM_NODES(env)[num]))
+            return ONIGERR_INVALID_BACKREF;
+        }
+
+        tok->type = TK_BACKREF;
+        tok->u.backref.num     = 1;
+        tok->u.backref.ref1    = num;
+        tok->u.backref.by_name = 0;
 #ifdef USE_BACKREF_WITH_LEVEL
-	tok->u.backref.exist_level = 0;
+        tok->u.backref.exist_level = 0;
 #endif
-	break;
+        break;
       }
 
     skip_backref:
       if (c == '8' || c == '9') {
-	/* normal char */
-	p = prev; PINC;
-	break;
+        /* normal char */
+        p = prev; PINC;
+        break;
       }
 
       p = prev;
       /* fall through */
     case '0':
       if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_OCTAL3)) {
-	prev = p;
-	num = scan_unsigned_octal_number(&p, end, (c == '0' ? 2:3), enc);
-	if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
-	if (p == prev) {  /* can't read nothing. */
-	  num = 0; /* but, it's not error */
-	}
-	tok->type = TK_RAW_BYTE;
-	tok->base = 8;
-	tok->u.c  = num;
+        prev = p;
+        num = scan_unsigned_octal_number(&p, end, (c == '0' ? 2:3), enc);
+        if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
+        if (p == prev) {  /* can't read nothing. */
+          num = 0; /* but, it's not error */
+        }
+        tok->type = TK_RAW_BYTE;
+        tok->base = 8;
+        tok->u.c  = num;
       }
       else if (c != '0') {
-	PINC;
+        PINC;
       }
       break;
 
 #ifdef USE_NAMED_GROUP
     case 'k':
       if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_K_NAMED_BACKREF)) {
-	PFETCH(c);
-	if (c == '<' || c == '\'') {
-	  UChar* name_end;
-	  int* backs;
-	  int back_num;
+        PFETCH(c);
+        if (c == '<' || c == '\'') {
+          UChar* name_end;
+          int* backs;
+          int back_num;
 
-	  prev = p;
+          prev = p;
 
 #ifdef USE_BACKREF_WITH_LEVEL
-	  name_end = NULL_UCHARP; /* no need. escape gcc warning. */
-	  r = fetch_name_with_level((OnigCodePoint )c, &p, end, &name_end,
-				    env, &back_num, &tok->u.backref.level);
-	  if (r == 1) tok->u.backref.exist_level = 1;
-	  else        tok->u.backref.exist_level = 0;
+          name_end = NULL_UCHARP; /* no need. escape gcc warning. */
+          r = fetch_name_with_level((OnigCodePoint )c, &p, end, &name_end,
+                                    env, &back_num, &tok->u.backref.level);
+          if (r == 1) tok->u.backref.exist_level = 1;
+          else        tok->u.backref.exist_level = 0;
 #else
-	  r = fetch_name(&p, end, &name_end, env, &back_num, 1);
+          r = fetch_name(&p, end, &name_end, env, &back_num, 1);
 #endif
-	  if (r < 0) return r;
-
-	  if (back_num != 0) {
-	    if (back_num < 0) {
-	      back_num = BACKREF_REL_TO_ABS(back_num, env);
-	      if (back_num <= 0)
-		return ONIGERR_INVALID_BACKREF;
-	    }
-
-	    if (IS_SYNTAX_BV(syn, ONIG_SYN_STRICT_CHECK_BACKREF)) {
-	      if (back_num > env->num_mem ||
-		  IS_NULL(SCANENV_MEM_NODES(env)[back_num]))
-		return ONIGERR_INVALID_BACKREF;
-	    }
-	    tok->type = TK_BACKREF;
-	    tok->u.backref.by_name = 0;
-	    tok->u.backref.num  = 1;
-	    tok->u.backref.ref1 = back_num;
-	  }
-	  else {
-	    num = onig_name_to_group_numbers(env->reg, prev, name_end, &backs);
-	    if (num <= 0) {
-	      onig_scan_env_set_error_string(env,
-			     ONIGERR_UNDEFINED_NAME_REFERENCE, prev, name_end);
-	      return ONIGERR_UNDEFINED_NAME_REFERENCE;
-	    }
-	    if (IS_SYNTAX_BV(syn, ONIG_SYN_STRICT_CHECK_BACKREF)) {
-	      int i;
-	      for (i = 0; i < num; i++) {
-		if (backs[i] > env->num_mem ||
-		    IS_NULL(SCANENV_MEM_NODES(env)[backs[i]]))
-		  return ONIGERR_INVALID_BACKREF;
-	      }
-	    }
-
-	    tok->type = TK_BACKREF;
-	    tok->u.backref.by_name = 1;
-	    if (num == 1) {
-	      tok->u.backref.num  = 1;
-	      tok->u.backref.ref1 = backs[0];
-	    }
-	    else {
-	      tok->u.backref.num  = num;
-	      tok->u.backref.refs = backs;
-	    }
-	  }
-	}
-	else {
-	    PUNFETCH;
-	    onig_syntax_warn(env, "invalid back reference");
-	}
+          if (r < 0) return r;
+
+          if (back_num != 0) {
+            if (back_num < 0) {
+              back_num = BACKREF_REL_TO_ABS(back_num, env);
+              if (back_num <= 0)
+                return ONIGERR_INVALID_BACKREF;
+            }
+
+            if (IS_SYNTAX_BV(syn, ONIG_SYN_STRICT_CHECK_BACKREF)) {
+              if (back_num > env->num_mem ||
+                  IS_NULL(SCANENV_MEM_NODES(env)[back_num]))
+                return ONIGERR_INVALID_BACKREF;
+            }
+            tok->type = TK_BACKREF;
+            tok->u.backref.by_name = 0;
+            tok->u.backref.num  = 1;
+            tok->u.backref.ref1 = back_num;
+          }
+          else {
+            num = onig_name_to_group_numbers(env->reg, prev, name_end, &backs);
+            if (num <= 0) {
+              onig_scan_env_set_error_string(env,
+                             ONIGERR_UNDEFINED_NAME_REFERENCE, prev, name_end);
+              return ONIGERR_UNDEFINED_NAME_REFERENCE;
+            }
+            if (IS_SYNTAX_BV(syn, ONIG_SYN_STRICT_CHECK_BACKREF)) {
+              int i;
+              for (i = 0; i < num; i++) {
+                if (backs[i] > env->num_mem ||
+                    IS_NULL(SCANENV_MEM_NODES(env)[backs[i]]))
+                  return ONIGERR_INVALID_BACKREF;
+              }
+            }
+
+            tok->type = TK_BACKREF;
+            tok->u.backref.by_name = 1;
+            if (num == 1) {
+              tok->u.backref.num  = 1;
+              tok->u.backref.ref1 = backs[0];
+            }
+            else {
+              tok->u.backref.num  = num;
+              tok->u.backref.refs = backs;
+            }
+          }
+        }
+        else {
+            PUNFETCH;
+            onig_syntax_warn(env, "invalid back reference");
+        }
       }
       break;
 #endif
@@ -3540,53 +3540,53 @@ fetch_token(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
 #ifdef USE_SUBEXP_CALL
     case 'g':
       if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_G_SUBEXP_CALL)) {
-	PFETCH(c);
-	if (c == '<' || c == '\'') {
-	  int gnum;
-	  UChar* name_end;
-
-	  prev = p;
-	  r = fetch_name((OnigCodePoint )c, &p, end, &name_end, env, &gnum, 1);
-	  if (r < 0) return r;
-
-	  tok->type = TK_CALL;
-	  tok->u.call.name     = prev;
-	  tok->u.call.name_end = name_end;
-	  tok->u.call.gnum     = gnum;
-	}
-	else {
-	    onig_syntax_warn(env, "invalid subexp call");
-	    PUNFETCH;
-	}
+        PFETCH(c);
+        if (c == '<' || c == '\'') {
+          int gnum;
+          UChar* name_end;
+
+          prev = p;
+          r = fetch_name((OnigCodePoint )c, &p, end, &name_end, env, &gnum, 1);
+          if (r < 0) return r;
+
+          tok->type = TK_CALL;
+          tok->u.call.name     = prev;
+          tok->u.call.name_end = name_end;
+          tok->u.call.gnum     = gnum;
+        }
+        else {
+            onig_syntax_warn(env, "invalid subexp call");
+            PUNFETCH;
+        }
       }
       break;
 #endif
 
     case 'Q':
       if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_CAPITAL_Q_QUOTE)) {
-	tok->type = TK_QUOTE_OPEN;
+        tok->type = TK_QUOTE_OPEN;
       }
       break;
 
     case 'p':
     case 'P':
       if (PPEEK_IS('{') &&
-	  IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY)) {
-	PINC;
-	tok->type = TK_CHAR_PROPERTY;
-	tok->u.prop.not = (c == 'P' ? 1 : 0);
-
-	if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT)) {
-	  PFETCH(c);
-	  if (c == '^') {
-	    tok->u.prop.not = (tok->u.prop.not == 0 ? 1 : 0);
-	  }
-	  else
-	    PUNFETCH;
-	}
+          IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY)) {
+        PINC;
+        tok->type = TK_CHAR_PROPERTY;
+        tok->u.prop.not = (c == 'P' ? 1 : 0);
+
+        if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT)) {
+          PFETCH(c);
+          if (c == '^') {
+            tok->u.prop.not = (tok->u.prop.not == 0 ? 1 : 0);
+          }
+          else
+            PUNFETCH;
+        }
       }
       else {
-	  onig_syntax_warn(env, "invalid Unicode Property \\%c", c);
+          onig_syntax_warn(env, "invalid Unicode Property \\%c", c);
       }
       break;
 
@@ -3596,11 +3596,11 @@ fetch_token(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
       if (num < 0) return num;
       /* set_raw: */
       if (tok->u.c != num) {
-	tok->type = TK_CODE_POINT;
-	tok->u.code = (OnigCodePoint )num;
+        tok->type = TK_CODE_POINT;
+        tok->u.code = (OnigCodePoint )num;
       }
       else { /* string */
-	p = tok->backp + enclen(enc, tok->backp, end);
+        p = tok->backp + enclen(enc, tok->backp, end);
       }
       break;
     }
@@ -3611,18 +3611,18 @@ fetch_token(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
 
 #ifdef USE_VARIABLE_META_CHARS
     if ((c != ONIG_INEFFECTIVE_META_CHAR) &&
-	IS_SYNTAX_OP(syn, ONIG_SYN_OP_VARIABLE_META_CHARACTERS)) {
+        IS_SYNTAX_OP(syn, ONIG_SYN_OP_VARIABLE_META_CHARACTERS)) {
       if (c == MC_ANYCHAR(syn))
-	goto any_char;
+        goto any_char;
       else if (c == MC_ANYTIME(syn))
-	goto anytime;
+        goto anytime;
       else if (c == MC_ZERO_OR_ONE_TIME(syn))
-	goto zero_or_one_time;
+        goto zero_or_one_time;
       else if (c == MC_ONE_OR_MORE_TIME(syn))
-	goto one_or_more_time;
+        goto one_or_more_time;
       else if (c == MC_ANYCHAR_ANYTIME(syn)) {
-	tok->type = TK_ANYCHAR_ANYTIME;
-	goto out;
+        tok->type = TK_ANYCHAR_ANYTIME;
+        goto out;
       }
     }
 #endif
@@ -3675,10 +3675,10 @@ fetch_token(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
       if (r < 0) return r;  /* error */
       if (r == 0) goto greedy_check;
       else if (r == 2) { /* {n} */
-	if (IS_SYNTAX_BV(syn, ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY))
-	  goto possessive_check;
+        if (IS_SYNTAX_BV(syn, ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY))
+          goto possessive_check;
 
-	goto greedy_check;
+        goto greedy_check;
       }
       /* r == 1 : normal char */
       break;
@@ -3722,14 +3722,14 @@ fetch_token(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
       if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_LINE_ANCHOR)) break;
       tok->type = TK_ANCHOR;
       tok->u.subtype = (IS_SINGLELINE(env->option)
-			? ANCHOR_BEGIN_BUF : ANCHOR_BEGIN_LINE);
+                        ? ANCHOR_BEGIN_BUF : ANCHOR_BEGIN_LINE);
       break;
 
     case '$':
       if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_LINE_ANCHOR)) break;
       tok->type = TK_ANCHOR;
       tok->u.subtype = (IS_SINGLELINE(env->option)
-			? ANCHOR_SEMI_END_BUF : ANCHOR_END_LINE);
+                        ? ANCHOR_SEMI_END_BUF : ANCHOR_END_LINE);
       break;
 
     case '[':
@@ -3739,24 +3739,24 @@ fetch_token(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
 
     case ']':
       if (*src > env->pattern)   /* /].../ is allowed. */
-	CLOSE_BRACKET_WITHOUT_ESC_WARN(env, (UChar* )"]");
+        CLOSE_BRACKET_WITHOUT_ESC_WARN(env, (UChar* )"]");
       break;
 
     case '#':
       if (IS_EXTEND(env->option)) {
-	while (!PEND) {
-	  PFETCH(c);
-	  if (ONIGENC_IS_CODE_NEWLINE(enc, c))
-	    break;
-	}
-	goto start;
-	break;
+        while (!PEND) {
+          PFETCH(c);
+          if (ONIGENC_IS_CODE_NEWLINE(enc, c))
+            break;
+        }
+        goto start;
+        break;
       }
       break;
 
     case ' ': case '\t': case '\n': case '\r': case '\f':
       if (IS_EXTEND(env->option))
-	goto start;
+        goto start;
       break;
 
     default:
@@ -3786,16 +3786,16 @@ add_ctype_to_cc_by_range(CClassNode* cc, int ctype ARG_UNUSED, int not,
     for (i = 0; i < n; i++) {
       for (j  = ONIGENC_CODE_RANGE_FROM(mbr, i);
            j <= ONIGENC_CODE_RANGE_TO(mbr, i); j++) {
-	if (j >= sb_out) {
-	  if (j > ONIGENC_CODE_RANGE_FROM(mbr, i)) {
-	    r = add_code_range_to_buf(&(cc->mbuf), env, j,
-				      ONIGENC_CODE_RANGE_TO(mbr, i));
-	    if (r != 0) return r;
-	    i++;
-	  }
-
-	  goto sb_end;
-	}
+        if (j >= sb_out) {
+          if (j > ONIGENC_CODE_RANGE_FROM(mbr, i)) {
+            r = add_code_range_to_buf(&(cc->mbuf), env, j,
+                                      ONIGENC_CODE_RANGE_TO(mbr, i));
+            if (r != 0) return r;
+            i++;
+          }
+
+          goto sb_end;
+        }
         BITSET_SET_BIT_CHKDUP(cc->bs, j);
       }
     }
@@ -3813,11 +3813,11 @@ add_ctype_to_cc_by_range(CClassNode* cc, int ctype ARG_UNUSED, int not,
 
     for (i = 0; i < n; i++) {
       for (j = prev;
-	   j < ONIGENC_CODE_RANGE_FROM(mbr, i); j++) {
-	if (j >= sb_out) {
-	  goto sb_end2;
-	}
-	BITSET_SET_BIT_CHKDUP(cc->bs, j);
+           j < ONIGENC_CODE_RANGE_FROM(mbr, i); j++) {
+        if (j >= sb_out) {
+          goto sb_end2;
+        }
+        BITSET_SET_BIT_CHKDUP(cc->bs, j);
       }
       prev = ONIGENC_CODE_RANGE_TO(mbr, i) + 1;
     }
@@ -3830,9 +3830,9 @@ add_ctype_to_cc_by_range(CClassNode* cc, int ctype ARG_UNUSED, int not,
 
     for (i = 0; i < n; i++) {
       if (prev < ONIGENC_CODE_RANGE_FROM(mbr, i)) {
-	r = add_code_range_to_buf(&(cc->mbuf), env, prev,
+        r = add_code_range_to_buf(&(cc->mbuf), env, prev,
                                   ONIGENC_CODE_RANGE_FROM(mbr, i) - 1);
-	if (r != 0) return r;
+        if (r != 0) return r;
       }
       prev = ONIGENC_CODE_RANGE_TO(mbr, i) + 1;
     }
@@ -3860,15 +3860,15 @@ add_ctype_to_cc(CClassNode* cc, int ctype, int not, ScanEnv* env)
     ctype ^= ONIGENC_CTYPE_SPECIAL_MASK;
     if (not != 0) {
       for (c = 0; c < SINGLE_BYTE_SIZE; c++) {
-	if (! ONIGENC_IS_ASCII_CODE_CTYPE((OnigCodePoint )c, ctype))
-	  BITSET_SET_BIT_CHKDUP(cc->bs, c);
+        if (! ONIGENC_IS_ASCII_CODE_CTYPE((OnigCodePoint )c, ctype))
+          BITSET_SET_BIT_CHKDUP(cc->bs, c);
       }
       ADD_ALL_MULTI_BYTE_RANGE(enc, cc->mbuf);
     }
     else {
       for (c = 0; c < SINGLE_BYTE_SIZE; c++) {
-	if (ONIGENC_IS_ASCII_CODE_CTYPE((OnigCodePoint )c, ctype))
-	  BITSET_SET_BIT_CHKDUP(cc->bs, c);
+        if (ONIGENC_IS_ASCII_CODE_CTYPE((OnigCodePoint )c, ctype))
+          BITSET_SET_BIT_CHKDUP(cc->bs, c);
       }
     }
     return 0;
@@ -3898,15 +3898,15 @@ add_ctype_to_cc(CClassNode* cc, int ctype, int not, ScanEnv* env)
   case ONIGENC_CTYPE_ALNUM:
     if (not != 0) {
       for (c = 0; c < SINGLE_BYTE_SIZE; c++) {
-	if (! ONIGENC_IS_CODE_CTYPE(enc, (OnigCodePoint )c, ctype))
-	  BITSET_SET_BIT_CHKDUP(cc->bs, c);
+        if (! ONIGENC_IS_CODE_CTYPE(enc, (OnigCodePoint )c, ctype))
+          BITSET_SET_BIT_CHKDUP(cc->bs, c);
       }
       ADD_ALL_MULTI_BYTE_RANGE(enc, cc->mbuf);
     }
     else {
       for (c = 0; c < SINGLE_BYTE_SIZE; c++) {
-	if (ONIGENC_IS_CODE_CTYPE(enc, (OnigCodePoint )c, ctype))
-	  BITSET_SET_BIT_CHKDUP(cc->bs, c);
+        if (ONIGENC_IS_CODE_CTYPE(enc, (OnigCodePoint )c, ctype))
+          BITSET_SET_BIT_CHKDUP(cc->bs, c);
       }
     }
     break;
@@ -3915,14 +3915,14 @@ add_ctype_to_cc(CClassNode* cc, int ctype, int not, ScanEnv* env)
   case ONIGENC_CTYPE_PRINT:
     if (not != 0) {
       for (c = 0; c < SINGLE_BYTE_SIZE; c++) {
-	if (! ONIGENC_IS_CODE_CTYPE(enc, (OnigCodePoint )c, ctype))
-	  BITSET_SET_BIT_CHKDUP(cc->bs, c);
+        if (! ONIGENC_IS_CODE_CTYPE(enc, (OnigCodePoint )c, ctype))
+          BITSET_SET_BIT_CHKDUP(cc->bs, c);
       }
     }
     else {
       for (c = 0; c < SINGLE_BYTE_SIZE; c++) {
-	if (ONIGENC_IS_CODE_CTYPE(enc, (OnigCodePoint )c, ctype))
-	  BITSET_SET_BIT_CHKDUP(cc->bs, c);
+        if (ONIGENC_IS_CODE_CTYPE(enc, (OnigCodePoint )c, ctype))
+          BITSET_SET_BIT_CHKDUP(cc->bs, c);
       }
       ADD_ALL_MULTI_BYTE_RANGE(enc, cc->mbuf);
     }
@@ -3931,15 +3931,15 @@ add_ctype_to_cc(CClassNode* cc, int ctype, int not, ScanEnv* env)
   case ONIGENC_CTYPE_WORD:
     if (not == 0) {
       for (c = 0; c < SINGLE_BYTE_SIZE; c++) {
-	if (IS_CODE_SB_WORD(enc, c)) BITSET_SET_BIT_CHKDUP(cc->bs, c);
+        if (IS_CODE_SB_WORD(enc, c)) BITSET_SET_BIT_CHKDUP(cc->bs, c);
       }
       ADD_ALL_MULTI_BYTE_RANGE(enc, cc->mbuf);
     }
     else {
       for (c = 0; c < SINGLE_BYTE_SIZE; c++) {
         if ((ONIGENC_CODE_TO_MBCLEN(enc, c) > 0) /* check invalid code point */
-	    && ! ONIGENC_IS_CODE_WORD(enc, c))
-	  BITSET_SET_BIT_CHKDUP(cc->bs, c);
+            && ! ONIGENC_IS_CODE_WORD(enc, c))
+          BITSET_SET_BIT_CHKDUP(cc->bs, c);
       }
     }
     break;
@@ -3997,7 +3997,7 @@ parse_posix_bracket(CClassNode* cc, UChar** src, UChar* end, ScanEnv* env)
     if (onigenc_with_ascii_strncmp(enc, p, end, pb->name, pb->len) == 0) {
       p = (UChar* )onigenc_step(enc, p, end, pb->len);
       if (onigenc_with_ascii_strncmp(enc, p, end, (UChar* )":]", 2) != 0)
-	return ONIGERR_INVALID_POSIX_BRACKET_TYPE;
+        return ONIGERR_INVALID_POSIX_BRACKET_TYPE;
 
       r = add_ctype_to_cc(cc, pb->ctype, not, env);
       if (r != 0) return r;
@@ -4020,7 +4020,7 @@ parse_posix_bracket(CClassNode* cc, UChar** src, UChar* end, ScanEnv* env)
     if (! PEND) {
       PFETCH(c);
       if (c == ']')
-	return ONIGERR_INVALID_POSIX_BRACKET_TYPE;
+        return ONIGERR_INVALID_POSIX_BRACKET_TYPE;
     }
   }
 
@@ -4061,7 +4061,7 @@ fetch_char_property_to_ctype(UChar** src, UChar* end, ScanEnv* env)
 
 static int
 parse_char_property(Node** np, OnigToken* tok, UChar** src, UChar* end,
-		    ScanEnv* env)
+                    ScanEnv* env)
 {
   int r, ctype;
   CClassNode* cc;
@@ -4095,7 +4095,7 @@ enum CCVALTYPE {
 
 static int
 next_state_class(CClassNode* cc, OnigCodePoint* vs, enum CCVALTYPE* type,
-		 enum CCSTATE* state, ScanEnv* env)
+                 enum CCSTATE* state, ScanEnv* env)
 {
   int r;
 
@@ -4118,9 +4118,9 @@ next_state_class(CClassNode* cc, OnigCodePoint* vs, enum CCVALTYPE* type,
 
 static int
 next_state_val(CClassNode* cc, OnigCodePoint *vs, OnigCodePoint v,
-	       int* vs_israw, int v_israw,
-	       enum CCVALTYPE intype, enum CCVALTYPE* type,
-	       enum CCSTATE* state, ScanEnv* env)
+               int* vs_israw, int v_israw,
+               enum CCVALTYPE intype, enum CCVALTYPE* type,
+               enum CCSTATE* state, ScanEnv* env)
 {
   int r;
 
@@ -4140,29 +4140,29 @@ next_state_val(CClassNode* cc, OnigCodePoint *vs, OnigCodePoint v,
         if (*vs > 0xff || v > 0xff)
           return ONIGERR_INVALID_CODE_POINT_VALUE;
 
-	if (*vs > v) {
-	  if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC))
-	    goto ccs_range_end;
-	  else
-	    return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS;
-	}
-	bitset_set_range(env, cc->bs, (int )*vs, (int )v);
+        if (*vs > v) {
+          if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC))
+            goto ccs_range_end;
+          else
+            return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS;
+        }
+        bitset_set_range(env, cc->bs, (int )*vs, (int )v);
       }
       else {
-	r = add_code_range(&(cc->mbuf), env, *vs, v);
-	if (r < 0) return r;
+        r = add_code_range(&(cc->mbuf), env, *vs, v);
+        if (r < 0) return r;
       }
     }
     else {
-	if (*vs > v) {
-	  if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC))
-	    goto ccs_range_end;
-	  else
-	    return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS;
-	}
-	bitset_set_range(env, cc->bs, (int )*vs, (int )(v < 0xff ? v : 0xff));
-	r = add_code_range(&(cc->mbuf), env, (OnigCodePoint )*vs, v);
-	if (r < 0) return r;
+        if (*vs > v) {
+          if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC))
+            goto ccs_range_end;
+          else
+            return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS;
+        }
+        bitset_set_range(env, cc->bs, (int )*vs, (int )(v < 0xff ? v : 0xff));
+        r = add_code_range(&(cc->mbuf), env, (OnigCodePoint )*vs, v);
+        if (r < 0) return r;
     }
   ccs_range_end:
     *state = CCS_COMPLETE;
@@ -4185,7 +4185,7 @@ next_state_val(CClassNode* cc, OnigCodePoint *vs, OnigCodePoint v,
 
 static int
 code_exist_check(OnigCodePoint c, UChar* from, UChar* end, int ignore_escaped,
-		 ScanEnv* env)
+                 ScanEnv* env)
 {
   int in_esc;
   OnigCodePoint code;
@@ -4209,7 +4209,7 @@ code_exist_check(OnigCodePoint c, UChar* from, UChar* end, int ignore_escaped,
 
 static int
 parse_char_class(Node** np, OnigToken* tok, UChar** src, UChar* end,
-		 ScanEnv* env)
+                 ScanEnv* env)
 {
   int r, neg, len, fetched, and_start;
   OnigCodePoint v, vs;
@@ -4255,16 +4255,16 @@ parse_char_class(Node** np, OnigToken* tok, UChar** src, UChar* end,
     switch (r) {
     case TK_CHAR:
       if ((tok->u.code >= SINGLE_BYTE_SIZE) ||
-	  (len = ONIGENC_CODE_TO_MBCLEN(env->enc, tok->u.c)) > 1) {
-	in_type = CCV_CODE_POINT;
+          (len = ONIGENC_CODE_TO_MBCLEN(env->enc, tok->u.c)) > 1) {
+        in_type = CCV_CODE_POINT;
       }
       else if (len < 0) {
-	r = len;
-	goto err;
+        r = len;
+        goto err;
       }
       else {
       sb_char:
-	in_type = CCV_SB;
+        in_type = CCV_SB;
       }
       v = (OnigCodePoint )tok->u.c;
       in_israw = 0;
@@ -4274,53 +4274,53 @@ parse_char_class(Node** np, OnigToken* tok, UChar** src, UChar* end,
     case TK_RAW_BYTE:
       /* tok->base != 0 : octal or hexadec. */
       if (! ONIGENC_IS_SINGLEBYTE(env->enc) && tok->base != 0) {
-	UChar buf[ONIGENC_CODE_TO_MBC_MAXLEN];
-	UChar* bufe = buf + ONIGENC_CODE_TO_MBC_MAXLEN;
-	UChar* psave = p;
-	int i, base = tok->base;
-
-	buf[0] = tok->u.c;
-	for (i = 1; i < ONIGENC_MBC_MAXLEN(env->enc); i++) {
-	  r = fetch_token_in_cc(tok, &p, end, env);
-	  if (r < 0) goto err;
-	  if (r != TK_RAW_BYTE || tok->base != base) {
-	    fetched = 1;
-	    break;
-	  }
-	  buf[i] = tok->u.c;
-	}
-
-	if (i < ONIGENC_MBC_MINLEN(env->enc)) {
-	  r = ONIGERR_TOO_SHORT_MULTI_BYTE_STRING;
-	  goto err;
-	}
-
-	len = enclen(env->enc, buf, buf+i);
-	if (i < len) {
-	  r = ONIGERR_TOO_SHORT_MULTI_BYTE_STRING;
-	  goto err;
-	}
-	else if (i > len) { /* fetch back */
-	  p = psave;
-	  for (i = 1; i < len; i++) {
-	    r = fetch_token_in_cc(tok, &p, end, env);
-	  }
-	  fetched = 0;
-	}
-
-	if (i == 1) {
-	  v = (OnigCodePoint )buf[0];
-	  goto raw_single;
-	}
-	else {
-	  v = ONIGENC_MBC_TO_CODE(env->enc, buf, bufe);
-	  in_type = CCV_CODE_POINT;
-	}
+        UChar buf[ONIGENC_CODE_TO_MBC_MAXLEN];
+        UChar* bufe = buf + ONIGENC_CODE_TO_MBC_MAXLEN;
+        UChar* psave = p;
+        int i, base = tok->base;
+
+        buf[0] = tok->u.c;
+        for (i = 1; i < ONIGENC_MBC_MAXLEN(env->enc); i++) {
+          r = fetch_token_in_cc(tok, &p, end, env);
+          if (r < 0) goto err;
+          if (r != TK_RAW_BYTE || tok->base != base) {
+            fetched = 1;
+            break;
+          }
+          buf[i] = tok->u.c;
+        }
+
+        if (i < ONIGENC_MBC_MINLEN(env->enc)) {
+          r = ONIGERR_TOO_SHORT_MULTI_BYTE_STRING;
+          goto err;
+        }
+
+        len = enclen(env->enc, buf, buf+i);
+        if (i < len) {
+          r = ONIGERR_TOO_SHORT_MULTI_BYTE_STRING;
+          goto err;
+        }
+        else if (i > len) { /* fetch back */
+          p = psave;
+          for (i = 1; i < len; i++) {
+            r = fetch_token_in_cc(tok, &p, end, env);
+          }
+          fetched = 0;
+        }
+
+        if (i == 1) {
+          v = (OnigCodePoint )buf[0];
+          goto raw_single;
+        }
+        else {
+          v = ONIGENC_MBC_TO_CODE(env->enc, buf, bufe);
+          in_type = CCV_CODE_POINT;
+        }
       }
       else {
-	v = (OnigCodePoint )tok->u.c;
+        v = (OnigCodePoint )tok->u.c;
       raw_single:
-	in_type = CCV_SB;
+        in_type = CCV_SB;
       }
       in_israw = 1;
       goto val_entry2;
@@ -4332,13 +4332,13 @@ parse_char_class(Node** np, OnigToken* tok, UChar** src, UChar* end,
     val_entry:
       len = ONIGENC_CODE_TO_MBCLEN(env->enc, v);
       if (len < 0) {
-	r = len;
-	goto err;
+        r = len;
+        goto err;
       }
       in_type = (len == 1 ? CCV_SB : CCV_CODE_POINT);
     val_entry2:
       r = next_state_val(cc, &vs, v, &val_israw, in_israw, in_type, &val_type,
-			 &state, env);
+                         &state, env);
       if (r != 0) goto err;
       break;
 
@@ -4346,11 +4346,11 @@ parse_char_class(Node** np, OnigToken* tok, UChar** src, UChar* end,
       r = parse_posix_bracket(cc, &p, end, env);
       if (r < 0) goto err;
       if (r == 1) {  /* is not POSIX bracket */
-	CC_ESC_WARN(env, (UChar* )"[");
-	p = tok->backp;
-	v = (OnigCodePoint )tok->u.c;
-	in_israw = 0;
-	goto val_entry;
+        CC_ESC_WARN(env, (UChar* )"[");
+        p = tok->backp;
+        v = (OnigCodePoint )tok->u.c;
+        in_israw = 0;
+        goto val_entry;
       }
       goto next_class;
       break;
@@ -4366,106 +4366,106 @@ parse_char_class(Node** np, OnigToken* tok, UChar** src, UChar* end,
 
     case TK_CHAR_PROPERTY:
       {
-	int ctype;
+        int ctype;
 
-	ctype = fetch_char_property_to_ctype(&p, end, env);
-	if (ctype < 0) return ctype;
-	r = add_ctype_to_cc(cc, ctype, tok->u.prop.not, env);
-	if (r != 0) return r;
-	goto next_class;
+        ctype = fetch_char_property_to_ctype(&p, end, env);
+        if (ctype < 0) return ctype;
+        r = add_ctype_to_cc(cc, ctype, tok->u.prop.not, env);
+        if (r != 0) return r;
+        goto next_class;
       }
       break;
 
     case TK_CC_RANGE:
       if (state == CCS_VALUE) {
-	r = fetch_token_in_cc(tok, &p, end, env);
-	if (r < 0) goto err;
-	fetched = 1;
-	if (r == TK_CC_CLOSE) { /* allow [x-] */
-	range_end_val:
-	  v = (OnigCodePoint )'-';
-	  in_israw = 0;
-	  goto val_entry;
-	}
-	else if (r == TK_CC_AND) {
-	  CC_ESC_WARN(env, (UChar* )"-");
-	  goto range_end_val;
-	}
-	state = CCS_RANGE;
+        r = fetch_token_in_cc(tok, &p, end, env);
+        if (r < 0) goto err;
+        fetched = 1;
+        if (r == TK_CC_CLOSE) { /* allow [x-] */
+        range_end_val:
+          v = (OnigCodePoint )'-';
+          in_israw = 0;
+          goto val_entry;
+        }
+        else if (r == TK_CC_AND) {
+          CC_ESC_WARN(env, (UChar* )"-");
+          goto range_end_val;
+        }
+        state = CCS_RANGE;
       }
       else if (state == CCS_START) {
-	/* [-xa] is allowed */
-	v = (OnigCodePoint )tok->u.c;
-	in_israw = 0;
+        /* [-xa] is allowed */
+        v = (OnigCodePoint )tok->u.c;
+        in_israw = 0;
 
-	r = fetch_token_in_cc(tok, &p, end, env);
-	if (r < 0) goto err;
-	fetched = 1;
-	/* [--x] or [a&&-x] is warned. */
-	if (r == TK_CC_RANGE || and_start != 0)
-	  CC_ESC_WARN(env, (UChar* )"-");
+        r = fetch_token_in_cc(tok, &p, end, env);
+        if (r < 0) goto err;
+        fetched = 1;
+        /* [--x] or [a&&-x] is warned. */
+        if (r == TK_CC_RANGE || and_start != 0)
+          CC_ESC_WARN(env, (UChar* )"-");
 
-	goto val_entry;
+        goto val_entry;
       }
       else if (state == CCS_RANGE) {
-	CC_ESC_WARN(env, (UChar* )"-");
-	goto sb_char;  /* [!--x] is allowed */
+        CC_ESC_WARN(env, (UChar* )"-");
+        goto sb_char;  /* [!--x] is allowed */
       }
       else { /* CCS_COMPLETE */
-	r = fetch_token_in_cc(tok, &p, end, env);
-	if (r < 0) goto err;
-	fetched = 1;
-	if (r == TK_CC_CLOSE) goto range_end_val; /* allow [a-b-] */
-	else if (r == TK_CC_AND) {
-	  CC_ESC_WARN(env, (UChar* )"-");
-	  goto range_end_val;
-	}
-
-	if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_DOUBLE_RANGE_OP_IN_CC)) {
-	  CC_ESC_WARN(env, (UChar* )"-");
-	  goto sb_char;   /* [0-9-a] is allowed as [0-9\-a] */
-	}
-	r = ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS;
-	goto err;
+        r = fetch_token_in_cc(tok, &p, end, env);
+        if (r < 0) goto err;
+        fetched = 1;
+        if (r == TK_CC_CLOSE) goto range_end_val; /* allow [a-b-] */
+        else if (r == TK_CC_AND) {
+          CC_ESC_WARN(env, (UChar* )"-");
+          goto range_end_val;
+        }
+
+        if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_DOUBLE_RANGE_OP_IN_CC)) {
+          CC_ESC_WARN(env, (UChar* )"-");
+          goto sb_char;   /* [0-9-a] is allowed as [0-9\-a] */
+        }
+        r = ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS;
+        goto err;
       }
       break;
 
     case TK_CC_CC_OPEN: /* [ */
       {
-	Node *anode;
-	CClassNode* acc;
+        Node *anode;
+        CClassNode* acc;
 
-	r = parse_char_class(&anode, tok, &p, end, env);
-	if (r == 0) {
-	  acc = NCCLASS(anode);
-	  r = or_cclass(cc, acc, env);
-	}
-	onig_node_free(anode);
-	if (r != 0) goto err;
+        r = parse_char_class(&anode, tok, &p, end, env);
+        if (r == 0) {
+          acc = NCCLASS(anode);
+          r = or_cclass(cc, acc, env);
+        }
+        onig_node_free(anode);
+        if (r != 0) goto err;
       }
       break;
 
     case TK_CC_AND: /* && */
       {
-	if (state == CCS_VALUE) {
-	  r = next_state_val(cc, &vs, 0, &val_israw, 0, val_type,
-			     &val_type, &state, env);
-	  if (r != 0) goto err;
-	}
-	/* initialize local variables */
-	and_start = 1;
-	state = CCS_START;
-
-	if (IS_NOT_NULL(prev_cc)) {
-	  r = and_cclass(prev_cc, cc, env);
-	  if (r != 0) goto err;
-	  bbuf_free(cc->mbuf);
-	}
-	else {
-	  prev_cc = cc;
-	  cc = &work_cc;
-	}
-	initialize_cclass(cc);
+        if (state == CCS_VALUE) {
+          r = next_state_val(cc, &vs, 0, &val_israw, 0, val_type,
+                             &val_type, &state, env);
+          if (r != 0) goto err;
+        }
+        /* initialize local variables */
+        and_start = 1;
+        state = CCS_START;
+
+        if (IS_NOT_NULL(prev_cc)) {
+          r = and_cclass(prev_cc, cc, env);
+          if (r != 0) goto err;
+          bbuf_free(cc->mbuf);
+        }
+        else {
+          prev_cc = cc;
+          cc = &work_cc;
+        }
+        initialize_cclass(cc);
       }
       break;
 
@@ -4489,7 +4489,7 @@ parse_char_class(Node** np, OnigToken* tok, UChar** src, UChar* end,
 
   if (state == CCS_VALUE) {
     r = next_state_val(cc, &vs, 0, &val_israw, 0, val_type,
-		       &val_type, &state, env);
+                       &val_type, &state, env);
     if (r != 0) goto err;
   }
 
@@ -4533,11 +4533,11 @@ parse_char_class(Node** np, OnigToken* tok, UChar** src, UChar* end,
 }
 
 static int parse_subexp(Node** top, OnigToken* tok, int term,
-			UChar** src, UChar* end, ScanEnv* env);
+                        UChar** src, UChar* end, ScanEnv* env);
 
 static int
 parse_enclose(Node** np, OnigToken* tok, int term, UChar** src, UChar* end,
-	      ScanEnv* env)
+              ScanEnv* env)
 {
   int r, num;
   Node *target;
@@ -4586,57 +4586,57 @@ parse_enclose(Node** np, OnigToken* tok, int term, UChar** src, UChar* end,
 #ifdef USE_NAMED_GROUP
     case '\'':
       if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) {
-	goto named_group1;
+        goto named_group1;
       }
       else
-	return ONIGERR_UNDEFINED_GROUP_OPTION;
+        return ONIGERR_UNDEFINED_GROUP_OPTION;
       break;
 #endif
 
     case '<':   /* look behind (?<=...), (?<!...) */
       PFETCH(c);
       if (c == '=')
-	*np = onig_node_new_anchor(ANCHOR_LOOK_BEHIND);
+        *np = onig_node_new_anchor(ANCHOR_LOOK_BEHIND);
       else if (c == '!')
-	*np = onig_node_new_anchor(ANCHOR_LOOK_BEHIND_NOT);
+        *np = onig_node_new_anchor(ANCHOR_LOOK_BEHIND_NOT);
 #ifdef USE_NAMED_GROUP
       else {
-	if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) {
-	  UChar *name;
-	  UChar *name_end;
-
-	  PUNFETCH;
-	  c = '<';
-
-	named_group1:
-	  list_capture = 0;
-
-	named_group2:
-	  name = p;
-	  r = fetch_name((OnigCodePoint )c, &p, end, &name_end, env, &num, 0);
-	  if (r < 0) return r;
-
-	  num = scan_env_add_mem_entry(env);
-	  if (num < 0) return num;
-	  if (list_capture != 0 && num >= (int )BIT_STATUS_BITS_NUM)
-	    return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY;
-
-	  r = name_add(env->reg, name, name_end, num, env);
-	  if (r != 0) return r;
-	  *np = node_new_enclose_memory(env->option, 1);
-	  CHECK_NULL_RETURN_MEMERR(*np);
-	  NENCLOSE(*np)->regnum = num;
-	  if (list_capture != 0)
-	    BIT_STATUS_ON_AT_SIMPLE(env->capture_history, num);
-	  env->num_named++;
-	}
-	else {
-	  return ONIGERR_UNDEFINED_GROUP_OPTION;
-	}
+        if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) {
+          UChar *name;
+          UChar *name_end;
+
+          PUNFETCH;
+          c = '<';
+
+        named_group1:
+          list_capture = 0;
+
+        named_group2:
+          name = p;
+          r = fetch_name((OnigCodePoint )c, &p, end, &name_end, env, &num, 0);
+          if (r < 0) return r;
+
+          num = scan_env_add_mem_entry(env);
+          if (num < 0) return num;
+          if (list_capture != 0 && num >= (int )BIT_STATUS_BITS_NUM)
+            return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY;
+
+          r = name_add(env->reg, name, name_end, num, env);
+          if (r != 0) return r;
+          *np = node_new_enclose_memory(env->option, 1);
+          CHECK_NULL_RETURN_MEMERR(*np);
+          NENCLOSE(*np)->regnum = num;
+          if (list_capture != 0)
+            BIT_STATUS_ON_AT_SIMPLE(env->capture_history, num);
+          env->num_named++;
+        }
+        else {
+          return ONIGERR_UNDEFINED_GROUP_OPTION;
+        }
       }
 #else
       else {
-	return ONIGERR_UNDEFINED_GROUP_OPTION;
+        return ONIGERR_UNDEFINED_GROUP_OPTION;
       }
 #endif
       break;
@@ -4644,94 +4644,94 @@ parse_enclose(Node** np, OnigToken* tok, int term, UChar** src, UChar* end,
     case '@':
       if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ATMARK_CAPTURE_HISTORY)) {
 #ifdef USE_NAMED_GROUP
-	if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) {
-	  PFETCH(c);
-	  if (c == '<' || c == '\'') {
-	    list_capture = 1;
-	    goto named_group2; /* (?@<name>...) */
-	  }
-	  PUNFETCH;
-	}
+        if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) {
+          PFETCH(c);
+          if (c == '<' || c == '\'') {
+            list_capture = 1;
+            goto named_group2; /* (?@<name>...) */
+          }
+          PUNFETCH;
+        }
 #endif
-	*np = node_new_enclose_memory(env->option, 0);
-	CHECK_NULL_RETURN_MEMERR(*np);
-	num = scan_env_add_mem_entry(env);
-	if (num < 0) {
-	  onig_node_free(*np);
-	  return num;
-	}
-	else if (num >= (int )BIT_STATUS_BITS_NUM) {
-	  onig_node_free(*np);
-	  return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY;
-	}
-	NENCLOSE(*np)->regnum = num;
-	BIT_STATUS_ON_AT_SIMPLE(env->capture_history, num);
+        *np = node_new_enclose_memory(env->option, 0);
+        CHECK_NULL_RETURN_MEMERR(*np);
+        num = scan_env_add_mem_entry(env);
+        if (num < 0) {
+          onig_node_free(*np);
+          return num;
+        }
+        else if (num >= (int )BIT_STATUS_BITS_NUM) {
+          onig_node_free(*np);
+          return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY;
+        }
+        NENCLOSE(*np)->regnum = num;
+        BIT_STATUS_ON_AT_SIMPLE(env->capture_history, num);
       }
       else {
-	return ONIGERR_UNDEFINED_GROUP_OPTION;
+        return ONIGERR_UNDEFINED_GROUP_OPTION;
       }
       break;
 
     case '-': case 'i': case 'm': case 's': case 'x':
       {
-	int neg = 0;
-
-	while (1) {
-	  switch (c) {
-	  case ':':
-	  case ')':
-	  break;
-
-	  case '-':  neg = 1; break;
-	  case 'x':  ONOFF(option, ONIG_OPTION_EXTEND,     neg); break;
-	  case 'i':  ONOFF(option, ONIG_OPTION_IGNORECASE, neg); break;
-	  case 's':
-	    if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) {
-	      ONOFF(option, ONIG_OPTION_MULTILINE,  neg);
-	    }
-	    else
-	      return ONIGERR_UNDEFINED_GROUP_OPTION;
-	    break;
-
-	  case 'm':
-	    if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) {
-	      ONOFF(option, ONIG_OPTION_SINGLELINE, (neg == 0 ? 1 : 0));
-	    }
-	    else if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_RUBY)) {
-	      ONOFF(option, ONIG_OPTION_MULTILINE,  neg);
-	    }
-	    else
-	      return ONIGERR_UNDEFINED_GROUP_OPTION;
-	    break;
-	  default:
-	    return ONIGERR_UNDEFINED_GROUP_OPTION;
-	  }
-
-	  if (c == ')') {
-	    *np = node_new_option(option);
-	    CHECK_NULL_RETURN_MEMERR(*np);
-	    *src = p;
-	    return 2; /* option only */
-	  }
-	  else if (c == ':') {
-	    OnigOptionType prev = env->option;
-
-	    env->option     = option;
-	    r = fetch_token(tok, &p, end, env);
-	    if (r < 0) return r;
-	    r = parse_subexp(&target, tok, term, &p, end, env);
-	    env->option = prev;
-	    if (r < 0) return r;
-	    *np = node_new_option(option);
-	    CHECK_NULL_RETURN_MEMERR(*np);
-	    NENCLOSE(*np)->target = target;
-	    *src = p;
-	    return 0;
-	  }
-
-	  if (PEND) return ONIGERR_END_PATTERN_IN_GROUP;
-	  PFETCH(c);
-	}
+        int neg = 0;
+
+        while (1) {
+          switch (c) {
+          case ':':
+          case ')':
+          break;
+
+          case '-':  neg = 1; break;
+          case 'x':  ONOFF(option, ONIG_OPTION_EXTEND,     neg); break;
+          case 'i':  ONOFF(option, ONIG_OPTION_IGNORECASE, neg); break;
+          case 's':
+            if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) {
+              ONOFF(option, ONIG_OPTION_MULTILINE,  neg);
+            }
+            else
+              return ONIGERR_UNDEFINED_GROUP_OPTION;
+            break;
+
+          case 'm':
+            if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) {
+              ONOFF(option, ONIG_OPTION_SINGLELINE, (neg == 0 ? 1 : 0));
+            }
+            else if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_RUBY)) {
+              ONOFF(option, ONIG_OPTION_MULTILINE,  neg);
+            }
+            else
+              return ONIGERR_UNDEFINED_GROUP_OPTION;
+            break;
+          default:
+            return ONIGERR_UNDEFINED_GROUP_OPTION;
+          }
+
+          if (c == ')') {
+            *np = node_new_option(option);
+            CHECK_NULL_RETURN_MEMERR(*np);
+            *src = p;
+            return 2; /* option only */
+          }
+          else if (c == ':') {
+            OnigOptionType prev = env->option;
+
+            env->option     = option;
+            r = fetch_token(tok, &p, end, env);
+            if (r < 0) return r;
+            r = parse_subexp(&target, tok, term, &p, end, env);
+            env->option = prev;
+            if (r < 0) return r;
+            *np = node_new_option(option);
+            CHECK_NULL_RETURN_MEMERR(*np);
+            NENCLOSE(*np)->target = target;
+            *src = p;
+            return 0;
+          }
+
+          if (PEND) return ONIGERR_END_PATTERN_IN_GROUP;
+          PFETCH(c);
+        }
       }
       break;
 
@@ -4797,11 +4797,11 @@ set_quantifier(Node* qnode, Node* target, int group, ScanEnv* env)
     if (! group) {
       StrNode* sn = NSTR(target);
       if (str_node_can_be_split(sn, env->enc)) {
-	Node* n = str_node_split_last_char(sn, env->enc);
-	if (IS_NOT_NULL(n)) {
-	  qn->target = n;
-	  return 2;
-	}
+        Node* n = str_node_split_last_char(sn, env->enc);
+        if (IS_NOT_NULL(n)) {
+          qn->target = n;
+          return 2;
+        }
       }
     }
     break;
@@ -4815,7 +4815,7 @@ set_quantifier(Node* qnode, Node* target, int group, ScanEnv* env)
 
 #ifdef USE_WARNING_REDUNDANT_NESTED_REPEAT_OPERATOR
       if (!IS_QUANTIFIER_BY_NUMBER(qn) && !IS_QUANTIFIER_BY_NUMBER(qnt) &&
-	  IS_SYNTAX_BV(env->syntax, ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT)) {
+          IS_SYNTAX_BV(env->syntax, ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT)) {
         UChar buf[WARN_BUFSIZE];
 
         switch(ReduceTypeTable[targetq_num][nestq_num]) {
@@ -4849,16 +4849,16 @@ set_quantifier(Node* qnode, Node* target, int group, ScanEnv* env)
     warn_exit:
 #endif
       if (targetq_num >= 0) {
-	if (nestq_num >= 0) {
-	  onig_reduce_nested_quantifier(qnode, target);
-	  goto q_exit;
-	}
-	else if (targetq_num == 1 || targetq_num == 2) { /* * or + */
-	  /* (?:a*){n,m}, (?:a+){n,m} => (?:a*){n,n}, (?:a+){n,n} */
-	  if (! IS_REPEAT_INFINITE(qn->upper) && qn->upper > 1 && qn->greedy) {
-	    qn->upper = (qn->lower == 0 ? 1 : qn->lower);
-	  }
-	}
+        if (nestq_num >= 0) {
+          onig_reduce_nested_quantifier(qnode, target);
+          goto q_exit;
+        }
+        else if (targetq_num == 1 || targetq_num == 2) { /* * or + */
+          /* (?:a*){n,m}, (?:a+){n,m} => (?:a*){n,n}, (?:a+){n,n} */
+          if (! IS_REPEAT_INFINITE(qn->upper) && qn->upper > 1 && qn->greedy) {
+            qn->upper = (qn->lower == 0 ? 1 : qn->lower);
+          }
+        }
       }
     }
     break;
@@ -4986,7 +4986,7 @@ typedef struct {
 
 static int
 i_apply_case_fold(OnigCodePoint from, OnigCodePoint to[],
-		  int to_len, void* arg)
+                  int to_len, void* arg)
 {
   IApplyCaseFoldArg* iarg;
   ScanEnv* env;
@@ -5002,26 +5002,26 @@ i_apply_case_fold(OnigCodePoint from, OnigCodePoint to[],
     int is_in = onig_is_code_in_cc(env->enc, from, cc);
 #ifdef CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS
     if ((is_in != 0 && !IS_NCCLASS_NOT(cc)) ||
-	(is_in == 0 &&  IS_NCCLASS_NOT(cc))) {
+        (is_in == 0 &&  IS_NCCLASS_NOT(cc))) {
       if (ONIGENC_MBC_MINLEN(env->enc) > 1 || *to >= SINGLE_BYTE_SIZE) {
-	add_code_range0(&(cc->mbuf), env, *to, *to, 0);
+        add_code_range0(&(cc->mbuf), env, *to, *to, 0);
       }
       else {
-	BITSET_SET_BIT(bs, *to);
+        BITSET_SET_BIT(bs, *to);
       }
     }
 #else
     if (is_in != 0) {
       if (ONIGENC_MBC_MINLEN(env->enc) > 1 || *to >= SINGLE_BYTE_SIZE) {
-	if (IS_NCCLASS_NOT(cc)) clear_not_flag_cclass(cc, env->enc);
-	add_code_range0(&(cc->mbuf), env, *to, *to, 0);
+        if (IS_NCCLASS_NOT(cc)) clear_not_flag_cclass(cc, env->enc);
+        add_code_range0(&(cc->mbuf), env, *to, *to, 0);
       }
       else {
-	if (IS_NCCLASS_NOT(cc)) {
-	  BITSET_CLEAR_BIT(bs, *to);
-	}
-	else
-	  BITSET_SET_BIT(bs, *to);
+        if (IS_NCCLASS_NOT(cc)) {
+          BITSET_CLEAR_BIT(bs, *to);
+        }
+        else
+          BITSET_SET_BIT(bs, *to);
       }
     }
 #endif /* CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS */
@@ -5033,26 +5033,26 @@ i_apply_case_fold(OnigCodePoint from, OnigCodePoint to[],
 
     if (onig_is_code_in_cc(env->enc, from, cc)
 #ifdef CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS
-	&& !IS_NCCLASS_NOT(cc)
+        && !IS_NCCLASS_NOT(cc)
 #endif
-	) {
+        ) {
       for (i = 0; i < to_len; i++) {
-	len = ONIGENC_CODE_TO_MBC(env->enc, to[i], buf);
-	if (i == 0) {
-	  snode = onig_node_new_str(buf, buf + len);
-	  CHECK_NULL_RETURN_MEMERR(snode);
-
-	  /* char-class expanded multi-char only
-	     compare with string folded at match time. */
-	  NSTRING_SET_AMBIG(snode);
-	}
-	else {
-	  r = onig_node_str_cat(snode, buf, buf + len);
-	  if (r < 0) {
-	    onig_node_free(snode);
-	    return r;
-	  }
-	}
+        len = ONIGENC_CODE_TO_MBC(env->enc, to[i], buf);
+        if (i == 0) {
+          snode = onig_node_new_str(buf, buf + len);
+          CHECK_NULL_RETURN_MEMERR(snode);
+
+          /* char-class expanded multi-char only
+             compare with string folded at match time. */
+          NSTRING_SET_AMBIG(snode);
+        }
+        else {
+          r = onig_node_str_cat(snode, buf, buf + len);
+          if (r < 0) {
+            onig_node_free(snode);
+            return r;
+          }
+        }
       }
 
       *(iarg->ptail) = onig_node_new_alt(snode, NULL_NODE);
@@ -5066,7 +5066,7 @@ i_apply_case_fold(OnigCodePoint from, OnigCodePoint to[],
 
 static int
 parse_exp(Node** np, OnigToken* tok, int term,
-	  UChar** src, UChar* end, ScanEnv* env)
+          UChar** src, UChar* end, ScanEnv* env)
 {
   int r, len, group = 0;
   Node* qn;
@@ -5097,8 +5097,8 @@ parse_exp(Node** np, OnigToken* tok, int term,
       r = parse_subexp(&target, tok, term, src, end, env);
       env->option = prev;
       if (r < 0) {
-	onig_node_free(target);
-	return r;
+        onig_node_free(target);
+        return r;
       }
       NENCLOSE(*np)->target = target;
       return tok->type;
@@ -5120,12 +5120,12 @@ parse_exp(Node** np, OnigToken* tok, int term,
       CHECK_NULL_RETURN_MEMERR(*np);
 
       while (1) {
-	r = fetch_token(tok, src, end, env);
-	if (r < 0) return r;
-	if (r != TK_STRING) break;
+        r = fetch_token(tok, src, end, env);
+        if (r < 0) return r;
+        if (r != TK_STRING) break;
 
-	r = onig_node_str_cat(*np, tok->backp, *src);
-	if (r < 0) return r;
+        r = onig_node_str_cat(*np, tok->backp, *src);
+        if (r < 0) return r;
       }
 
     string_end:
@@ -5141,25 +5141,25 @@ parse_exp(Node** np, OnigToken* tok, int term,
       CHECK_NULL_RETURN_MEMERR(*np);
       len = 1;
       while (1) {
-	if (len >= ONIGENC_MBC_MINLEN(env->enc)) {
-	  if (len == enclen(env->enc, NSTR(*np)->s, NSTR(*np)->end)) {
-	    r = fetch_token(tok, src, end, env);
-	    NSTRING_CLEAR_RAW(*np);
-	    goto string_end;
-	  }
-	}
+        if (len >= ONIGENC_MBC_MINLEN(env->enc)) {
+          if (len == enclen(env->enc, NSTR(*np)->s, NSTR(*np)->end)) {
+            r = fetch_token(tok, src, end, env);
+            NSTRING_CLEAR_RAW(*np);
+            goto string_end;
+          }
+        }
 
-	r = fetch_token(tok, src, end, env);
-	if (r < 0) return r;
-	if (r != TK_RAW_BYTE) {
-	  /* Don't use this, it is wrong for little endian encodings. */
-	  return ONIGERR_TOO_SHORT_MULTI_BYTE_STRING;
-	}
+        r = fetch_token(tok, src, end, env);
+        if (r < 0) return r;
+        if (r != TK_RAW_BYTE) {
+          /* Don't use this, it is wrong for little endian encodings. */
+          return ONIGERR_TOO_SHORT_MULTI_BYTE_STRING;
+        }
 
-	r = node_str_cat_char(*np, (UChar )tok->u.c);
-	if (r < 0) return r;
+        r = node_str_cat_char(*np, (UChar )tok->u.c);
+        if (r < 0) return r;
 
-	len++;
+        len++;
       }
     }
     break;
@@ -5188,7 +5188,7 @@ parse_exp(Node** np, OnigToken* tok, int term,
       qstart = *src;
       qend = find_str_position(end_op, 2, qstart, end, &nextp, env->enc);
       if (IS_NULL(qend)) {
-	nextp = qend = end;
+        nextp = qend = end;
       }
       *np = node_new_str(qstart, qend);
       CHECK_NULL_RETURN_MEMERR(*np);
@@ -5202,33 +5202,33 @@ parse_exp(Node** np, OnigToken* tok, int term,
       case ONIGENC_CTYPE_D:
       case ONIGENC_CTYPE_S:
       case ONIGENC_CTYPE_W:
-	{
-	    CClassNode* cc;
-	    *np = node_new_cclass();
-	    CHECK_NULL_RETURN_MEMERR(*np);
-	    cc = NCCLASS(*np);
-	    add_ctype_to_cc(cc, tok->u.prop.ctype, 0, env);
-	    if (tok->u.prop.not != 0) NCCLASS_SET_NOT(cc);
-	}
-	break;
+        {
+            CClassNode* cc;
+            *np = node_new_cclass();
+            CHECK_NULL_RETURN_MEMERR(*np);
+            cc = NCCLASS(*np);
+            add_ctype_to_cc(cc, tok->u.prop.ctype, 0, env);
+            if (tok->u.prop.not != 0) NCCLASS_SET_NOT(cc);
+        }
+        break;
 
       case ONIGENC_CTYPE_WORD:
-	*np = node_new_ctype(tok->u.prop.ctype, tok->u.prop.not);
-	CHECK_NULL_RETURN_MEMERR(*np);
-	break;
+        *np = node_new_ctype(tok->u.prop.ctype, tok->u.prop.not);
+        CHECK_NULL_RETURN_MEMERR(*np);
+        break;
 
       case ONIGENC_CTYPE_SPACE:
       case ONIGENC_CTYPE_DIGIT:
       case ONIGENC_CTYPE_XDIGIT:
-	{
-	  CClassNode* cc;
+        {
+          CClassNode* cc;
 
 #ifdef USE_SHARED_CCLASS_TABLE
           const OnigCodePoint *mbr;
-	  OnigCodePoint sb_out;
+          OnigCodePoint sb_out;
 
           r = ONIGENC_GET_CTYPE_CODE_RANGE(env->enc, tok->u.prop.ctype,
-					   &sb_out, &mbr);
+                                           &sb_out, &mbr);
           if (r == 0 &&
               ONIGENC_CODE_RANGE_NUM(mbr)
               >= THRESHOLD_RANGE_NUM_FOR_SHARE_CCLASS) {
@@ -5258,7 +5258,7 @@ parse_exp(Node** np, OnigToken* tok, int term,
             }
 
             *np = node_new_cclass_by_codepoint_range(tok->u.prop.not,
-						     sb_out, mbr);
+                                                     sb_out, mbr);
             if (IS_NULL(*np)) {
               THREAD_ATOMIC_END;
               return ONIGERR_MEMORY;
@@ -5267,7 +5267,7 @@ parse_exp(Node** np, OnigToken* tok, int term,
             cc = NCCLASS(*np);
             NCCLASS_SET_SHARE(cc);
             new_key = (type_cclass_key* )xmalloc(sizeof(type_cclass_key));
-	    xmemcpy(new_key, &key, sizeof(type_cclass_key));
+            xmemcpy(new_key, &key, sizeof(type_cclass_key));
             onig_st_add_direct(OnigTypeCClassTable, (st_data_t )new_key,
                                (st_data_t )*np);
 
@@ -5283,12 +5283,12 @@ parse_exp(Node** np, OnigToken* tok, int term,
 #ifdef USE_SHARED_CCLASS_TABLE
           }
 #endif
-	}
-	break;
+        }
+        break;
 
       default:
-	return ONIGERR_PARSER_BUG;
-	break;
+        return ONIGERR_PARSER_BUG;
+        break;
       }
     }
     break;
@@ -5307,27 +5307,27 @@ parse_exp(Node** np, OnigToken* tok, int term,
 
       cc = NCCLASS(*np);
       if (IS_IGNORECASE(env->option)) {
-	IApplyCaseFoldArg iarg;
-
-	iarg.env      = env;
-	iarg.cc       = cc;
-	iarg.alt_root = NULL_NODE;
-	iarg.ptail    = &(iarg.alt_root);
-
-	r = ONIGENC_APPLY_ALL_CASE_FOLD(env->enc, env->case_fold_flag,
-					i_apply_case_fold, &iarg);
-	if (r != 0) {
-	  onig_node_free(iarg.alt_root);
-	  return r;
-	}
-	if (IS_NOT_NULL(iarg.alt_root)) {
+        IApplyCaseFoldArg iarg;
+
+        iarg.env      = env;
+        iarg.cc       = cc;
+        iarg.alt_root = NULL_NODE;
+        iarg.ptail    = &(iarg.alt_root);
+
+        r = ONIGENC_APPLY_ALL_CASE_FOLD(env->enc, env->case_fold_flag,
+                                        i_apply_case_fold, &iarg);
+        if (r != 0) {
+          onig_node_free(iarg.alt_root);
+          return r;
+        }
+        if (IS_NOT_NULL(iarg.alt_root)) {
           Node* work = onig_node_new_alt(*np, iarg.alt_root);
           if (IS_NULL(work)) {
             onig_node_free(iarg.alt_root);
             return ONIGERR_MEMORY;
           }
           *np = work;
-	}
+        }
       }
     }
     break;
@@ -5349,13 +5349,13 @@ parse_exp(Node** np, OnigToken* tok, int term,
   case TK_BACKREF:
     len = tok->u.backref.num;
     *np = node_new_backref(len,
-		   (len > 1 ? tok->u.backref.refs : &(tok->u.backref.ref1)),
-			   tok->u.backref.by_name,
+                   (len > 1 ? tok->u.backref.refs : &(tok->u.backref.ref1)),
+                           tok->u.backref.by_name,
 #ifdef USE_BACKREF_WITH_LEVEL
-			   tok->u.backref.exist_level,
-			   tok->u.backref.level,
+                           tok->u.backref.exist_level,
+                           tok->u.backref.level,
 #endif
-			   env);
+                           env);
     CHECK_NULL_RETURN_MEMERR(*np);
     break;
 
@@ -5365,9 +5365,9 @@ parse_exp(Node** np, OnigToken* tok, int term,
       int gnum = tok->u.call.gnum;
 
       if (gnum < 0) {
-	gnum = BACKREF_REL_TO_ABS(gnum, env);
-	if (gnum <= 0)
-	  return ONIGERR_INVALID_BACKREF;
+        gnum = BACKREF_REL_TO_ABS(gnum, env);
+        if (gnum <= 0)
+          return ONIGERR_INVALID_BACKREF;
       }
       *np = node_new_call(tok->u.call.name, tok->u.call.name_end, gnum);
       CHECK_NULL_RETURN_MEMERR(*np);
@@ -5384,9 +5384,9 @@ parse_exp(Node** np, OnigToken* tok, int term,
   case TK_INTERVAL:
     if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_CONTEXT_INDEP_REPEAT_OPS)) {
       if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_CONTEXT_INVALID_REPEAT_OPS))
-	return ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED;
+        return ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED;
       else
-	*np = node_new_empty();
+        *np = node_new_empty();
     }
     else {
       goto tk_byte;
@@ -5408,49 +5408,49 @@ parse_exp(Node** np, OnigToken* tok, int term,
   repeat:
     if (r == TK_OP_REPEAT || r == TK_INTERVAL) {
       if (is_invalid_quantifier_target(*targetp))
-	return ONIGERR_TARGET_OF_REPEAT_OPERATOR_INVALID;
+        return ONIGERR_TARGET_OF_REPEAT_OPERATOR_INVALID;
 
       qn = node_new_quantifier(tok->u.repeat.lower, tok->u.repeat.upper,
-			       (r == TK_INTERVAL ? 1 : 0));
+                               (r == TK_INTERVAL ? 1 : 0));
       CHECK_NULL_RETURN_MEMERR(qn);
       NQTFR(qn)->greedy = tok->u.repeat.greedy;
       r = set_quantifier(qn, *targetp, group, env);
       if (r < 0) {
-	onig_node_free(qn);
-	return r;
+        onig_node_free(qn);
+        return r;
       }
 
       if (tok->u.repeat.possessive != 0) {
-	Node* en;
-	en = node_new_enclose(ENCLOSE_STOP_BACKTRACK);
-	if (IS_NULL(en)) {
-	  onig_node_free(qn);
-	  return ONIGERR_MEMORY;
-	}
-	NENCLOSE(en)->target = qn;
-	qn = en;
+        Node* en;
+        en = node_new_enclose(ENCLOSE_STOP_BACKTRACK);
+        if (IS_NULL(en)) {
+          onig_node_free(qn);
+          return ONIGERR_MEMORY;
+        }
+        NENCLOSE(en)->target = qn;
+        qn = en;
       }
 
       if (r == 0) {
-	*targetp = qn;
+        *targetp = qn;
       }
       else if (r == 1) {
         onig_node_free(qn);
       }
       else if (r == 2) { /* split case: /abc+/ */
-	Node *tmp;
-
-	*targetp = node_new_list(*targetp, NULL);
-	if (IS_NULL(*targetp)) {
-	  onig_node_free(qn);
-	  return ONIGERR_MEMORY;
-	}
-	tmp = NCDR(*targetp) = node_new_list(qn, NULL);
-	if (IS_NULL(tmp)) {
-	  onig_node_free(qn);
-	  return ONIGERR_MEMORY;
-	}
-	targetp = &(NCAR(tmp));
+        Node *tmp;
+
+        *targetp = node_new_list(*targetp, NULL);
+        if (IS_NULL(*targetp)) {
+          onig_node_free(qn);
+          return ONIGERR_MEMORY;
+        }
+        tmp = NCDR(*targetp) = node_new_list(qn, NULL);
+        if (IS_NULL(tmp)) {
+          onig_node_free(qn);
+          return ONIGERR_MEMORY;
+        }
+        targetp = &(NCAR(tmp));
       }
       goto re_entry;
     }
@@ -5461,7 +5461,7 @@ parse_exp(Node** np, OnigToken* tok, int term,
 
 static int
 parse_branch(Node** top, OnigToken* tok, int term,
-	     UChar** src, UChar* end, ScanEnv* env)
+             UChar** src, UChar* end, ScanEnv* env)
 {
   int r;
   Node *node, **headp;
@@ -5482,18 +5482,18 @@ parse_branch(Node** top, OnigToken* tok, int term,
     while (r != TK_EOT && r != term && r != TK_ALT) {
       r = parse_exp(&node, tok, term, src, end, env);
       if (r < 0) {
-	onig_node_free(node);
-	return r;
+        onig_node_free(node);
+        return r;
       }
 
       if (NTYPE(node) == NT_LIST) {
-	*headp = node;
-	while (IS_NOT_NULL(NCDR(node))) node = NCDR(node);
-	headp = &(NCDR(node));
+        *headp = node;
+        while (IS_NOT_NULL(NCDR(node))) node = NCDR(node);
+        headp = &(NCDR(node));
       }
       else {
-	*headp = node_new_list(node, NULL);
-	headp = &(NCDR(*headp));
+        *headp = node_new_list(node, NULL);
+        headp = &(NCDR(*headp));
       }
     }
   }
@@ -5504,7 +5504,7 @@ parse_branch(Node** top, OnigToken* tok, int term,
 /* term_tok: TK_EOT or TK_SUBEXP_CLOSE */
 static int
 parse_subexp(Node** top, OnigToken* tok, int term,
-	     UChar** src, UChar* end, ScanEnv* env)
+             UChar** src, UChar* end, ScanEnv* env)
 {
   int r;
   Node *node, **headp;
@@ -5527,8 +5527,8 @@ parse_subexp(Node** top, OnigToken* tok, int term,
       if (r < 0) return r;
       r = parse_branch(&node, tok, term, src, end, env);
       if (r < 0) {
-	onig_node_free(node);
-	return r;
+        onig_node_free(node);
+        return r;
       }
 
       *headp = onig_node_new_alt(node, NULL);
@@ -5565,7 +5565,7 @@ parse_regexp(Node** top, UChar** src, UChar* end, ScanEnv* env)
 
 extern int
 onig_parse_make_tree(Node** root, const UChar* pattern, const UChar* end,
-		     regex_t* reg, ScanEnv* env)
+                     regex_t* reg, ScanEnv* env)
 {
   int r;
   UChar* p;
@@ -5592,7 +5592,7 @@ onig_parse_make_tree(Node** root, const UChar* pattern, const UChar* end,
 
 extern void
 onig_scan_env_set_error_string(ScanEnv* env, int ecode ARG_UNUSED,
-				UChar* arg, UChar* arg_end)
+                                UChar* arg, UChar* arg_end)
 {
   env->error     = arg;
   env->error_end = arg_end;
diff --git a/src/sprintf.c b/src/sprintf.c
index 9a960e2cf..fdf484ba0 100644
--- a/src/sprintf.c
+++ b/src/sprintf.c
@@ -1,6 +1,6 @@
 /*
 ** sprintf.c - Kernel.#sprintf
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -162,7 +162,7 @@ mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base)
   posarg > 0 ? \
   (mrb_raise(mrb, E_ARGUMENT_ERROR, "named%.*s after unnumbered(%d)", (len), (name), posarg), mrb_undef_value()) : \
   posarg == -1 ? \
-  (mrb_raise(mrb, E_ARGUMENT_ERROR, "named%.*s after numbered", (len), (name)), mrb_undef_value()) :	\
+  (mrb_raise(mrb, E_ARGUMENT_ERROR, "named%.*s after numbered", (len), (name)), mrb_undef_value()) :    \
   (posarg = -2, mrb_hash_getWithDef(mrb, get_hash(mrb, &hash, argc, argv), id, mrb_undef_value())))
 
 #define GETNUM(n, val) \
diff --git a/src/st.c b/src/st.c
index 725408414..777a03bd2 100644
--- a/src/st.c
+++ b/src/st.c
@@ -1,6 +1,6 @@
 /* This is a public domain general purpose hash table package written by Peter Moore @ UCB. */
 
-/* static	char	sccsid[] = "@(#) st.c 5.1 89/12/14 Crucible"; */
+/* static       char    sccsid[] = "@(#) st.c 5.1 89/12/14 Crucible"; */
 
 #include <stdio.h>
 #ifdef HAVE_STDLIB_H
@@ -66,35 +66,35 @@ static void rehash(st_table *);
 Table of prime numbers 2^n+a, 2<=n<=30.
 */
 static long primes[] = {
-	8 + 3,
-	16 + 3,
-	32 + 5,
-	64 + 3,
-	128 + 3,
-	256 + 27,
-	512 + 9,
-	1024 + 9,
-	2048 + 5,
-	4096 + 3,
-	8192 + 27,
-	16384 + 43,
-	32768 + 3,
-	65536 + 45,
-	131072 + 29,
-	262144 + 3,
-	524288 + 21,
-	1048576 + 7,
-	2097152 + 17,
-	4194304 + 15,
-	8388608 + 9,
-	16777216 + 43,
-	33554432 + 35,
-	67108864 + 15,
-	134217728 + 29,
-	268435456 + 3,
-	536870912 + 11,
-	1073741824 + 85,
-	0
+        8 + 3,
+        16 + 3,
+        32 + 5,
+        64 + 3,
+        128 + 3,
+        256 + 27,
+        512 + 9,
+        1024 + 9,
+        2048 + 5,
+        4096 + 3,
+        8192 + 27,
+        16384 + 43,
+        32768 + 3,
+        65536 + 45,
+        131072 + 29,
+        262144 + 3,
+        524288 + 21,
+        1048576 + 7,
+        2097152 + 17,
+        4194304 + 15,
+        8388608 + 9,
+        16777216 + 43,
+        33554432 + 35,
+        67108864 + 15,
+        134217728 + 29,
+        268435456 + 3,
+        536870912 + 11,
+        1073741824 + 85,
+        0
 };
 
 static int
@@ -104,20 +104,20 @@ new_size(int size)
 
 #if 0
     for (i=3; i<31; i++) {
-	if ((1<<i) > size) return 1<<i;
+        if ((1<<i) > size) return 1<<i;
     }
     return -1;
 #else
     int newsize;
 
     for (i = 0, newsize = MINSIZE;
-	 i < sizeof(primes)/sizeof(primes[0]);
-	 i++, newsize <<= 1)
+         i < sizeof(primes)/sizeof(primes[0]);
+         i++, newsize <<= 1)
     {
-	if (newsize > size) return primes[i];
+        if (newsize > size) return primes[i];
     }
     /* Ran out of polynomials */
-    return -1;			/* should raise exception */
+    return -1;                  /* should raise exception */
 #endif
 }
 
@@ -126,7 +126,7 @@ st_init_table_with_size(const struct st_hash_type *type, int size)
 {
     st_table *tbl;
 
-    size = new_size(size);	/* round up to prime number */
+    size = new_size(size);      /* round up to prime number */
 
     tbl = alloc(st_table);
     tbl->type = type;
@@ -188,13 +188,13 @@ st_clear(st_table *table)
     st_index_t i;
 
     for(i = 0; i < table->num_bins; i++) {
-	ptr = table->bins[i];
-	table->bins[i] = 0;
-	while (ptr != 0) {
-	    next = ptr->next;
-	    free(ptr);
-	    ptr = next;
-	}
+        ptr = table->bins[i];
+        table->bins[i] = 0;
+        while (ptr != 0) {
+            next = ptr->next;
+            free(ptr);
+            ptr = next;
+        }
     }
     table->num_entries = 0;
     table->head = 0;
@@ -216,10 +216,10 @@ st_free_table(st_table *table)
     bin_pos = hash_val%(table)->num_bins;\
     ptr = (table)->bins[bin_pos];\
     if (PTR_NOT_EQUAL(table, ptr, hash_val, key)) {\
-	while (PTR_NOT_EQUAL(table, ptr->next, hash_val, key)) {\
-	    ptr = ptr->next;\
-	}\
-	ptr = ptr->next;\
+        while (PTR_NOT_EQUAL(table, ptr->next, hash_val, key)) {\
+            ptr = ptr->next;\
+        }\
+        ptr = ptr->next;\
     }\
 } while (0)
 
@@ -233,11 +233,11 @@ st_lookup(st_table *table, st_data_t key, st_data_t *value)
     FIND_ENTRY(table, ptr, hash_val, bin_pos);
 
     if (ptr == 0) {
-	return 0;
+        return 0;
     }
     else {
-	if (value != 0)  *value = ptr->record;
-	return 1;
+        if (value != 0)  *value = ptr->record;
+        return 1;
     }
 }
 
@@ -245,7 +245,7 @@ st_lookup(st_table *table, st_data_t key, st_data_t *value)
 do {\
     st_table_entry *entry;\
     if (table->num_entries/(table->num_bins) > ST_DEFAULT_MAX_DENSITY) {\
-	rehash(table);\
+        rehash(table);\
         bin_pos = hash_val % table->num_bins;\
     }\
     \
@@ -256,13 +256,13 @@ do {\
     entry->record = value;\
     entry->next = table->bins[bin_pos];\
     if (table->head != 0) {\
-	entry->fore = 0;\
-	(entry->back = table->tail)->fore = entry;\
-	table->tail = entry;\
+        entry->fore = 0;\
+        (entry->back = table->tail)->fore = entry;\
+        table->tail = entry;\
     }\
     else {\
-	table->head = table->tail = entry;\
-	entry->fore = entry->back = 0;\
+        table->head = table->tail = entry;\
+        entry->fore = entry->back = 0;\
     }\
     table->bins[bin_pos] = entry;\
     table->num_entries++;\
@@ -278,12 +278,12 @@ st_insert(st_table *table, st_data_t key, st_data_t value)
     FIND_ENTRY(table, ptr, hash_val, bin_pos);
 
     if (ptr == 0) {
-	ADD_DIRECT(table, key, value, hash_val, bin_pos);
-	return 0;
+        ADD_DIRECT(table, key, value, hash_val, bin_pos);
+        return 0;
     }
     else {
-	ptr->record = value;
-	return 1;
+        ptr->record = value;
+        return 1;
     }
 }
 
@@ -305,17 +305,17 @@ rehash(register st_table *table)
 
     new_num_bins = new_size(table->num_bins+1);
     new_bins = (st_table_entry**)
-	realloc(table->bins, new_num_bins * sizeof(st_table_entry*));
+        realloc(table->bins, new_num_bins * sizeof(st_table_entry*));
     for (i = 0; i < new_num_bins; ++i) new_bins[i] = 0;
     table->num_bins = new_num_bins;
     table->bins = new_bins;
 
     if ((ptr = table->head) != 0) {
-	do {
-	    hash_val = ptr->hash % new_num_bins;
-	    ptr->next = new_bins[hash_val];
-	    new_bins[hash_val] = ptr;
-	} while ((ptr = ptr->fore) != 0);
+        do {
+            hash_val = ptr->hash % new_num_bins;
+            ptr->next = new_bins[hash_val];
+            new_bins[hash_val] = ptr;
+        } while ((ptr = ptr->fore) != 0);
     }
 }
 
@@ -329,55 +329,55 @@ st_copy(st_table *old_table)
 
     new_table = alloc(st_table);
     if (new_table == 0) {
-	return 0;
+        return 0;
     }
 
     *new_table = *old_table;
     new_table->bins = (st_table_entry**)
-	Calloc((unsigned)num_bins, sizeof(st_table_entry*));
+        Calloc((unsigned)num_bins, sizeof(st_table_entry*));
 
     if (new_table->bins == 0) {
-	free(new_table);
-	return 0;
+        free(new_table);
+        return 0;
     }
 
     if ((ptr = old_table->head) != 0) {
-	prev = 0;
-	tail = &new_table->head;
-	do {
-	    entry = alloc(st_table_entry);
-	    if (entry == 0) {
-		st_free_table(new_table);
-		return 0;
-	    }
-	    *entry = *ptr;
-	    hash_val = entry->hash % num_bins;
-	    entry->next = new_table->bins[hash_val];
-	    new_table->bins[hash_val] = entry;
-	    entry->back = prev;
-	    *tail = prev = entry;
-	    tail = &entry->fore;
-	} while ((ptr = ptr->fore) != 0);
-	new_table->tail = prev;
+        prev = 0;
+        tail = &new_table->head;
+        do {
+            entry = alloc(st_table_entry);
+            if (entry == 0) {
+                st_free_table(new_table);
+                return 0;
+            }
+            *entry = *ptr;
+            hash_val = entry->hash % num_bins;
+            entry->next = new_table->bins[hash_val];
+            new_table->bins[hash_val] = entry;
+            entry->back = prev;
+            *tail = prev = entry;
+            tail = &entry->fore;
+        } while ((ptr = ptr->fore) != 0);
+        new_table->tail = prev;
     }
 
     return new_table;
 }
 
-#define REMOVE_ENTRY(table, ptr) do					\
-    {									\
-	if (ptr->fore == 0 && ptr->back == 0) {				\
-	    table->head = 0;						\
-	    table->tail = 0;						\
-	}								\
-	else {								\
-	    st_table_entry *fore = ptr->fore, *back = ptr->back;	\
-	    if (fore) fore->back = back;				\
-	    if (back) back->fore = fore;				\
-	    if (ptr == table->head) table->head = fore;			\
-	    if (ptr == table->tail) table->tail = back;			\
-	}								\
-	table->num_entries--;						\
+#define REMOVE_ENTRY(table, ptr) do                                     \
+    {                                                                   \
+        if (ptr->fore == 0 && ptr->back == 0) {                         \
+            table->head = 0;                                            \
+            table->tail = 0;                                            \
+        }                                                               \
+        else {                                                          \
+            st_table_entry *fore = ptr->fore, *back = ptr->back;        \
+            if (fore) fore->back = back;                                \
+            if (back) back->fore = fore;                                \
+            if (ptr == table->head) table->head = fore;                 \
+            if (ptr == table->tail) table->tail = back;                 \
+        }                                                               \
+        table->num_entries--;                                           \
     } while (0)
 
 int
@@ -389,14 +389,14 @@ st_delete(register st_table *table, register st_data_t *key, st_data_t *value)
 
     hash_val = do_hash_bin(*key, table);
     for (prev = &table->bins[hash_val]; (ptr = *prev) != 0; prev = &ptr->next) {
-	if (EQUAL(table, *key, ptr->key)) {
-	    *prev = ptr->next;
-	    REMOVE_ENTRY(table, ptr);
-	    if (value != 0) *value = ptr->record;
-	    *key = ptr->key;
-	    free(ptr);
-	    return 1;
-	}
+        if (EQUAL(table, *key, ptr->key)) {
+            *prev = ptr->next;
+            REMOVE_ENTRY(table, ptr);
+            if (value != 0) *value = ptr->record;
+            *key = ptr->key;
+            free(ptr);
+            return 1;
+        }
     }
 
     if (value != 0) *value = 0;
@@ -411,40 +411,40 @@ st_foreach(st_table *table, int (*func)(ANYARGS), st_data_t arg)
     st_index_t i;
 
     if ((ptr = table->head) != 0) {
-	do {
-	    i = ptr->hash % table->num_bins;
-	    retval = (*func)(ptr->key, ptr->record, (void*)arg);
-	    switch (retval) {
-	      case ST_CHECK:	/* check if hash is modified during iteration */
-		for (tmp = table->bins[i]; tmp != ptr; tmp = tmp->next) {
-		    if (!tmp) {
-			/* call func with error notice */
-			retval = (*func)(0, 0, arg, 1);
-			return 1;
-		    }
-		}
-		/* fall through */
-	      default:
-	      case ST_CONTINUE:
-		ptr = ptr->fore;
-		break;
-	      case ST_STOP:
-		return 0;
-	      case ST_DELETE:
-		last = &table->bins[ptr->hash % table->num_bins];
-		for (; (tmp = *last) != 0; last = &tmp->next) {
-		    if (ptr == tmp) {
-			tmp = ptr->fore;
-			*last = ptr->next;
-			REMOVE_ENTRY(table, ptr);
-			free(ptr);
-			if (ptr == tmp) return 0;
-			ptr = tmp;
-			break;
-		    }
-		}
-	    }
-	} while (ptr && table->head);
+        do {
+            i = ptr->hash % table->num_bins;
+            retval = (*func)(ptr->key, ptr->record, (void*)arg);
+            switch (retval) {
+              case ST_CHECK:    /* check if hash is modified during iteration */
+                for (tmp = table->bins[i]; tmp != ptr; tmp = tmp->next) {
+                    if (!tmp) {
+                        /* call func with error notice */
+                        retval = (*func)(0, 0, arg, 1);
+                        return 1;
+                    }
+                }
+                /* fall through */
+              default:
+              case ST_CONTINUE:
+                ptr = ptr->fore;
+                break;
+              case ST_STOP:
+                return 0;
+              case ST_DELETE:
+                last = &table->bins[ptr->hash % table->num_bins];
+                for (; (tmp = *last) != 0; last = &tmp->next) {
+                    if (ptr == tmp) {
+                        tmp = ptr->fore;
+                        *last = ptr->next;
+                        REMOVE_ENTRY(table, ptr);
+                        free(ptr);
+                        if (ptr == tmp) return 0;
+                        ptr = tmp;
+                        break;
+                    }
+                }
+            }
+        } while (ptr && table->head);
     }
     return 0;
 }
@@ -458,19 +458,19 @@ strhash(const char *string)
     register unsigned int h = 0, g;
 
     while ((c = *string++) != '\0') {
-	h = ( h << 4 ) + c;
-	if ( g = h & 0xF0000000 )
-	    h ^= g >> 24;
-	h &= ~g;
+        h = ( h << 4 ) + c;
+        if ( g = h & 0xF0000000 )
+            h ^= g >> 24;
+        h &= ~g;
     }
     return h;
 #elif defined(HASH_PERL)
     register int val = 0;
 
     while ((c = *string++) != '\0') {
-	val += c;
-	val += (val << 10);
-	val ^= (val >> 6);
+        val += c;
+        val += (val << 10);
+        val ^= (val >> 6);
     }
     val += (val << 3);
     val ^= (val >> 11);
@@ -480,7 +480,7 @@ strhash(const char *string)
     register int val = 0;
 
     while ((c = *string++) != '\0') {
-	val = val*997 + c;
+        val = val*997 + c;
     }
 
     return val + (val>>5);
@@ -549,12 +549,12 @@ strcasehash(st_data_t arg)
      * FNV-1a hash each octet in the buffer
      */
     while (*string) {
-	unsigned int c = (unsigned char)*string++;
-	if ((unsigned int)(c - 'A') <= ('Z' - 'A')) c += 'a' - 'A';
-	hval ^= c;
+        unsigned int c = (unsigned char)*string++;
+        if ((unsigned int)(c - 'A') <= ('Z' - 'A')) c += 'a' - 'A';
+        hval ^= c;
 
-	/* multiply by the 32 bit FNV magic prime mod 2^32 */
-	hval *= FNV_32_PRIME;
+        /* multiply by the 32 bit FNV magic prime mod 2^32 */
+        hval *= FNV_32_PRIME;
     }
     return hval;
 }
diff --git a/src/st.h b/src/st.h
index d9da995a5..24db1fd23 100644
--- a/src/st.h
+++ b/src/st.h
@@ -84,11 +84,11 @@ int st_strncasecmp(const char *s1, const char *s2, size_t n);
 #define STRCASECMP(s1, s2) (st_strcasecmp(s1, s2))
 #define STRNCASECMP(s1, s2, n) (st_strncasecmp(s1, s2, n))
 
-#define ST_NUMCMP	((int (*)()) 0)
-#define ST_NUMHASH	((int (*)()) -2)
+#define ST_NUMCMP       ((int (*)()) 0)
+#define ST_NUMHASH      ((int (*)()) -2)
 
-#define st_numcmp	ST_NUMCMP
-#define st_numhash	ST_NUMHASH
+#define st_numcmp       ST_NUMCMP
+#define st_numhash      ST_NUMHASH
 
 int st_strhash();
 
diff --git a/src/state.c b/src/state.c
index f705060e8..a9013afa1 100644
--- a/src/state.c
+++ b/src/state.c
@@ -1,6 +1,6 @@
 /*
 ** state.c - RiteVM open/close functions
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/string.c b/src/string.c
index e92d76b18..e2987db57 100644
--- a/src/string.c
+++ b/src/string.c
@@ -1,6 +1,6 @@
 /*
 ** string.c - String class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/struct.c b/src/struct.c
index c7e09d4ed..767f8fbd4 100644
--- a/src/struct.c
+++ b/src/struct.c
@@ -1,6 +1,6 @@
 /*
 ** struct.c - Struct class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/symbol.c b/src/symbol.c
index bbc5246fe..164e492ea 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -1,6 +1,6 @@
 /*
 ** symbol.c - Symbol class
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/transcode.c b/src/transcode.c
index 3aab69581..1188dc6f5 100644
--- a/src/transcode.c
+++ b/src/transcode.c
@@ -3906,7 +3906,7 @@ econv_primitive_errinfo(mrb_state *mrb, mrb_value self)
 static mrb_value
 econv_insert_output(mrb_state *mrb, mrb_value self)
 {
-	mrb_value string;
+        mrb_value string;
     const char *insert_enc;
 
     int ret;
diff --git a/src/transcode_data.h b/src/transcode_data.h
index 7ff540120..62051701a 100644
--- a/src/transcode_data.h
+++ b/src/transcode_data.h
@@ -22,20 +22,20 @@
 
 #define PType (unsigned int)
 
-#define NOMAP	(PType 0x01)	/* direct map */
-#define ONEbt	(0x02)		/* one byte payload */
-#define TWObt	(0x03)		/* two bytes payload */
-#define THREEbt	(0x05)		/* three bytes payload */
-#define FOURbt	(0x06)		/* four bytes payload, UTF-8 only, macros start at getBT0 */
-#define INVALID	(PType 0x07)	/* invalid byte sequence */
-#define UNDEF	(PType 0x09)	/* legal but undefined */
-#define ZERObt	(PType 0x0A)	/* zero bytes of payload, i.e. remove */
-#define FUNii	(PType 0x0B)	/* function from info to info */
-#define FUNsi	(PType 0x0D)	/* function from start to info */
-#define FUNio	(PType 0x0E)	/* function from info to output */
-#define FUNso	(PType 0x0F)	/* function from start to output */
-#define STR1	(PType 0x11)	/* string 4 <= len <= 259 bytes: 1byte length + content */
-#define GB4bt	(PType 0x12)	/* GB18030 four bytes payload */
+#define NOMAP   (PType 0x01)    /* direct map */
+#define ONEbt   (0x02)          /* one byte payload */
+#define TWObt   (0x03)          /* two bytes payload */
+#define THREEbt (0x05)          /* three bytes payload */
+#define FOURbt  (0x06)          /* four bytes payload, UTF-8 only, macros start at getBT0 */
+#define INVALID (PType 0x07)    /* invalid byte sequence */
+#define UNDEF   (PType 0x09)    /* legal but undefined */
+#define ZERObt  (PType 0x0A)    /* zero bytes of payload, i.e. remove */
+#define FUNii   (PType 0x0B)    /* function from info to info */
+#define FUNsi   (PType 0x0D)    /* function from start to info */
+#define FUNio   (PType 0x0E)    /* function from info to output */
+#define FUNso   (PType 0x0F)    /* function from start to output */
+#define STR1    (PType 0x11)    /* string 4 <= len <= 259 bytes: 1byte length + content */
+#define GB4bt   (PType 0x12)    /* GB18030 four bytes payload */
 #define FUNsio  (PType 0x13)    /* function from start and info to output */
 
 #define STR1_LENGTH(byte_addr) (unsigned int)(*(byte_addr) + 4)
@@ -43,24 +43,24 @@
 #define makeSTR1(bi) (((bi) << 6) | STR1)
 #define makeSTR1LEN(len) ((len)-4)
 
-#define o1(b1)		(PType((((unsigned char)(b1))<<8)|ONEbt))
-#define o2(b1,b2)	(PType((((unsigned char)(b1))<<8)|(((unsigned char)(b2))<<16)|TWObt))
-#define o3(b1,b2,b3)	(PType(((((unsigned char)(b1))<<8)|(((unsigned char)(b2))<<16)|(((unsigned int)(unsigned char)(b3))<<24)|THREEbt)&0xffffffffU))
-#define o4(b0,b1,b2,b3)	(PType(((((unsigned char)(b1))<<8)|(((unsigned char)(b2))<<16)|(((unsigned char)(b3))<<24)|((((unsigned char)(b0))&0x07)<<5)|FOURbt)&0xffffffffU))
+#define o1(b1)          (PType((((unsigned char)(b1))<<8)|ONEbt))
+#define o2(b1,b2)       (PType((((unsigned char)(b1))<<8)|(((unsigned char)(b2))<<16)|TWObt))
+#define o3(b1,b2,b3)    (PType(((((unsigned char)(b1))<<8)|(((unsigned char)(b2))<<16)|(((unsigned int)(unsigned char)(b3))<<24)|THREEbt)&0xffffffffU))
+#define o4(b0,b1,b2,b3) (PType(((((unsigned char)(b1))<<8)|(((unsigned char)(b2))<<16)|(((unsigned char)(b3))<<24)|((((unsigned char)(b0))&0x07)<<5)|FOURbt)&0xffffffffU))
 #define g4(b0,b1,b2,b3) (PType(((((unsigned char)(b0))<<8)|(((unsigned char)(b2))<<16)|((((unsigned char)(b1))&0x0f)<<24)|((((unsigned int)(unsigned char)(b3))&0x0f)<<28)|GB4bt)&0xffffffffU))
-#define funsio(diff)	(PType((((unsigned int)(diff))<<8)|FUNsio))
+#define funsio(diff)    (PType((((unsigned int)(diff))<<8)|FUNsio))
 
-#define getBT1(a)	((unsigned char)((a)>> 8))
-#define getBT2(a)	((unsigned char)((a)>>16))
-#define getBT3(a)	((unsigned char)((a)>>24))
-#define getBT0(a)	(((unsigned char)((a)>> 5)&0x07)|0xF0)   /* for UTF-8 only!!! */
+#define getBT1(a)       ((unsigned char)((a)>> 8))
+#define getBT2(a)       ((unsigned char)((a)>>16))
+#define getBT3(a)       ((unsigned char)((a)>>24))
+#define getBT0(a)       (((unsigned char)((a)>> 5)&0x07)|0xF0)   /* for UTF-8 only!!! */
 
-#define getGB4bt0(a)	((unsigned char)((a)>> 8))
-#define getGB4bt1(a)	((((unsigned char)((a)>>24))&0x0F)|0x30)
-#define getGB4bt2(a)	((unsigned char)((a)>>16))
-#define getGB4bt3(a)	((((unsigned char)((a)>>28))&0x0F)|0x30)
+#define getGB4bt0(a)    ((unsigned char)((a)>> 8))
+#define getGB4bt1(a)    ((((unsigned char)((a)>>24))&0x0F)|0x30)
+#define getGB4bt2(a)    ((unsigned char)((a)>>16))
+#define getGB4bt3(a)    ((((unsigned char)((a)>>28))&0x0F)|0x30)
 
-#define o2FUNii(b1,b2)	(PType((((unsigned char)(b1))<<8)|(((unsigned char)(b2))<<16)|FUNii))
+#define o2FUNii(b1,b2)  (PType((((unsigned char)(b1))<<8)|(((unsigned char)(b2))<<16)|FUNii))
 
 /* do we need these??? maybe not, can be done with simple tables */
 #define ONETRAIL       /* legal but undefined if one more trailing UTF-8 */
diff --git a/src/unicode.c b/src/unicode.c
index 0753fe62a..dec692500 100644
--- a/src/unicode.c
+++ b/src/unicode.c
@@ -2073,7 +2073,7 @@ onigenc_unicode_ctype_code_range(int ctype, const OnigCodePoint* ranges[])
 extern int
 onigenc_utf16_32_get_ctype_code_range(OnigCtype ctype, OnigCodePoint* sb_out,
                                       const OnigCodePoint* ranges[],
-				      struct OnigEncodingTypeST* enc ARG_UNUSED)
+                                      struct OnigEncodingTypeST* enc ARG_UNUSED)
 {
   *sb_out = 0x00;
   return onigenc_unicode_ctype_code_range(ctype, ranges);
@@ -2246,15 +2246,15 @@ onigenc_unicode_mbc_case_fold(OnigEncoding enc,
 
   if (onig_st_lookup(FoldTable, (st_data_t )code, (void* )&to) != 0) {
     if (to->n == 1) {
-      return ONIGENC_CODE_TO_MBC(enc, to->code[0], fold);      
+      return ONIGENC_CODE_TO_MBC(enc, to->code[0], fold);
     }
     else
     {
       rlen = 0;
       for (i = 0; i < to->n; i++) {
-	len = ONIGENC_CODE_TO_MBC(enc, to->code[i], fold);
-	fold += len;
-	rlen += len;
+        len = ONIGENC_CODE_TO_MBC(enc, to->code[i], fold);
+        fold += len;
+        rlen += len;
       }
       return rlen;
     }
@@ -2268,8 +2268,8 @@ onigenc_unicode_mbc_case_fold(OnigEncoding enc,
 
 extern int
 onigenc_unicode_apply_all_case_fold(OnigCaseFoldType flag,
-				    OnigApplyAllCaseFoldFunc f, void* arg,
-				    OnigEncoding enc ARG_UNUSED)
+                                    OnigApplyAllCaseFoldFunc f, void* arg,
+                                    OnigEncoding enc ARG_UNUSED)
 {
   const CaseUnfold_11_Type* p11;
   OnigCodePoint code;
@@ -2289,11 +2289,11 @@ onigenc_unicode_apply_all_case_fold(OnigCaseFoldType flag,
       if (r != 0) return r;
 
       for (k = 0; k < j; k++) {
-	r = (*f)(p11->to.code[j], (OnigCodePoint* )(&p11->to.code[k]), 1, arg);
-	if (r != 0) return r;
+        r = (*f)(p11->to.code[j], (OnigCodePoint* )(&p11->to.code[k]), 1, arg);
+        if (r != 0) return r;
 
-	r = (*f)(p11->to.code[k], (OnigCodePoint* )(&p11->to.code[j]), 1, arg);
-	if (r != 0) return r;
+        r = (*f)(p11->to.code[k], (OnigCodePoint* )(&p11->to.code[j]), 1, arg);
+        if (r != 0) return r;
       }
     }
   }
@@ -2319,23 +2319,23 @@ onigenc_unicode_apply_all_case_fold(OnigCaseFoldType flag,
     for (i = 0; i < numberof(CaseUnfold_11_Locale); i++) {
       p11 = &CaseUnfold_11_Locale[i];
       for (j = 0; j < p11->to.n; j++) {
-	code = p11->from;
-	r = (*f)(p11->to.code[j], &code, 1, arg);
-	if (r != 0) return r;
-
-	code = p11->to.code[j];
-	r = (*f)(p11->from, &code, 1, arg);
-	if (r != 0) return r;
-
-	for (k = 0; k < j; k++) {
-	  r = (*f)(p11->to.code[j], (OnigCodePoint* )(&p11->to.code[k]),
-		   1, arg);
-	  if (r != 0) return r;
-
-	  r = (*f)(p11->to.code[k], (OnigCodePoint* )(&p11->to.code[j]),
-		   1, arg);
-	  if (r != 0) return r;
-	}
+        code = p11->from;
+        r = (*f)(p11->to.code[j], &code, 1, arg);
+        if (r != 0) return r;
+
+        code = p11->to.code[j];
+        r = (*f)(p11->from, &code, 1, arg);
+        if (r != 0) return r;
+
+        for (k = 0; k < j; k++) {
+          r = (*f)(p11->to.code[j], (OnigCodePoint* )(&p11->to.code[k]),
+                   1, arg);
+          if (r != 0) return r;
+
+          r = (*f)(p11->to.code[k], (OnigCodePoint* )(&p11->to.code[j]),
+                   1, arg);
+          if (r != 0) return r;
+        }
       }
     }
 #ifdef USE_UNICODE_CASE_FOLD_TURKISH_AZERI
@@ -2345,17 +2345,17 @@ onigenc_unicode_apply_all_case_fold(OnigCaseFoldType flag,
   if ((flag & INTERNAL_ONIGENC_CASE_FOLD_MULTI_CHAR) != 0) {
     for (i = 0; i < numberof(CaseUnfold_12); i++) {
       for (j = 0; j < CaseUnfold_12[i].to.n; j++) {
-	r = (*f)(CaseUnfold_12[i].to.code[j],
-		 (OnigCodePoint* )CaseUnfold_12[i].from, 2, arg);
-	if (r != 0) return r;	
+        r = (*f)(CaseUnfold_12[i].to.code[j],
+                 (OnigCodePoint* )CaseUnfold_12[i].from, 2, arg);
+        if (r != 0) return r;
 
-	for (k = 0; k < CaseUnfold_12[i].to.n; k++) {
-	  if (k == j) continue;
+        for (k = 0; k < CaseUnfold_12[i].to.n; k++) {
+          if (k == j) continue;
 
-	  r = (*f)(CaseUnfold_12[i].to.code[j],
-		   (OnigCodePoint* )(&CaseUnfold_12[i].to.code[k]), 1, arg);
-	  if (r != 0) return r;
-	}
+          r = (*f)(CaseUnfold_12[i].to.code[j],
+                   (OnigCodePoint* )(&CaseUnfold_12[i].to.code[k]), 1, arg);
+          if (r != 0) return r;
+        }
       }
     }
 
@@ -2363,20 +2363,20 @@ onigenc_unicode_apply_all_case_fold(OnigCaseFoldType flag,
     if ((flag & ONIGENC_CASE_FOLD_TURKISH_AZERI) == 0) {
 #endif
       for (i = 0; i < numberof(CaseUnfold_12_Locale); i++) {
-	for (j = 0; j < CaseUnfold_12_Locale[i].to.n; j++) {
-	  r = (*f)(CaseUnfold_12_Locale[i].to.code[j],
-		   (OnigCodePoint* )CaseUnfold_12_Locale[i].from, 2, arg);
-	  if (r != 0) return r;	
-
-	  for (k = 0; k < CaseUnfold_12_Locale[i].to.n; k++) {
-	    if (k == j) continue;
-
-	    r = (*f)(CaseUnfold_12_Locale[i].to.code[j],
-		     (OnigCodePoint* )(&CaseUnfold_12_Locale[i].to.code[k]),
-		     1, arg);
-	    if (r != 0) return r;
-	  }
-	}
+        for (j = 0; j < CaseUnfold_12_Locale[i].to.n; j++) {
+          r = (*f)(CaseUnfold_12_Locale[i].to.code[j],
+                   (OnigCodePoint* )CaseUnfold_12_Locale[i].from, 2, arg);
+          if (r != 0) return r;
+
+          for (k = 0; k < CaseUnfold_12_Locale[i].to.n; k++) {
+            if (k == j) continue;
+
+            r = (*f)(CaseUnfold_12_Locale[i].to.code[j],
+                     (OnigCodePoint* )(&CaseUnfold_12_Locale[i].to.code[k]),
+                     1, arg);
+            if (r != 0) return r;
+          }
+        }
       }
 #ifdef USE_UNICODE_CASE_FOLD_TURKISH_AZERI
     }
@@ -2384,17 +2384,17 @@ onigenc_unicode_apply_all_case_fold(OnigCaseFoldType flag,
 
     for (i = 0; i < numberof(CaseUnfold_13); i++) {
       for (j = 0; j < CaseUnfold_13[i].to.n; j++) {
-	r = (*f)(CaseUnfold_13[i].to.code[j],
-		 (OnigCodePoint* )CaseUnfold_13[i].from, 3, arg);
-	if (r != 0) return r;	
+        r = (*f)(CaseUnfold_13[i].to.code[j],
+                 (OnigCodePoint* )CaseUnfold_13[i].from, 3, arg);
+        if (r != 0) return r;
 
-	for (k = 0; k < CaseUnfold_13[i].to.n; k++) {
-	  if (k == j) continue;
+        for (k = 0; k < CaseUnfold_13[i].to.n; k++) {
+          if (k == j) continue;
 
-	  r = (*f)(CaseUnfold_13[i].to.code[j],
-		   (OnigCodePoint* )(&CaseUnfold_13[i].to.code[k]), 1, arg);
-	  if (r != 0) return r;
-	}
+          r = (*f)(CaseUnfold_13[i].to.code[j],
+                   (OnigCodePoint* )(&CaseUnfold_13[i].to.code[k]), 1, arg);
+          if (r != 0) return r;
+        }
       }
     }
   }
@@ -2459,14 +2459,14 @@ onigenc_unicode_get_case_fold_codes_by_str(OnigEncoding enc,
 
       code = to->code[0];
       if (onig_st_lookup(Unfold1Table, (st_data_t )code, (void* )&to) != 0) {
-	for (i = 0; i < to->n; i++) {
-	  if (to->code[i] != orig_code) {
-	    items[n].byte_len = len;
-	    items[n].code_len = 1;
-	    items[n].code[0]  = to->code[i];
-	    n++;
-	  }
-	}
+        for (i = 0; i < to->n; i++) {
+          if (to->code[i] != orig_code) {
+            items[n].byte_len = len;
+            items[n].code_len = 1;
+            items[n].code[0]  = to->code[i];
+            n++;
+          }
+        }
       }
     }
     else if ((flag & INTERNAL_ONIGENC_CASE_FOLD_MULTI_CHAR) != 0) {
@@ -2474,66 +2474,66 @@ onigenc_unicode_get_case_fold_codes_by_str(OnigEncoding enc,
       int fn, ncs[3];
 
       for (fn = 0; fn < to->n; fn++) {
-	cs[fn][0] = to->code[fn];
-	if (onig_st_lookup(Unfold1Table, (st_data_t )cs[fn][0],
-			   (void* )&z3) != 0) {
-	  for (i = 0; i < z3->n; i++) {
-	    cs[fn][i+1] = z3->code[i];
-	  }
-	  ncs[fn] = z3->n + 1;
-	}
-	else
-	  ncs[fn] = 1;
+        cs[fn][0] = to->code[fn];
+        if (onig_st_lookup(Unfold1Table, (st_data_t )cs[fn][0],
+                           (void* )&z3) != 0) {
+          for (i = 0; i < z3->n; i++) {
+            cs[fn][i+1] = z3->code[i];
+          }
+          ncs[fn] = z3->n + 1;
+        }
+        else
+          ncs[fn] = 1;
       }
 
       if (fn == 2) {
-	for (i = 0; i < ncs[0]; i++) {
-	  for (j = 0; j < ncs[1]; j++) {
-	    items[n].byte_len = len;
-	    items[n].code_len = 2;
-	    items[n].code[0]  = cs[0][i];
-	    items[n].code[1]  = cs[1][j];
-	    n++;
-	  }
-	}
-
-	if (onig_st_lookup(Unfold2Table, (st_data_t )to->code,
-			   (void* )&z2) != 0) {
-	  for (i = 0; i < z2->n; i++) {
-	    if (z2->code[i] == code) continue;
-
-	    items[n].byte_len = len;
-	    items[n].code_len = 1;
-	    items[n].code[0]  = z2->code[i];
-	    n++;
-	  }
-	}
+        for (i = 0; i < ncs[0]; i++) {
+          for (j = 0; j < ncs[1]; j++) {
+            items[n].byte_len = len;
+            items[n].code_len = 2;
+            items[n].code[0]  = cs[0][i];
+            items[n].code[1]  = cs[1][j];
+            n++;
+          }
+        }
+
+        if (onig_st_lookup(Unfold2Table, (st_data_t )to->code,
+                           (void* )&z2) != 0) {
+          for (i = 0; i < z2->n; i++) {
+            if (z2->code[i] == code) continue;
+
+            items[n].byte_len = len;
+            items[n].code_len = 1;
+            items[n].code[0]  = z2->code[i];
+            n++;
+          }
+        }
       }
       else {
-	for (i = 0; i < ncs[0]; i++) {
-	  for (j = 0; j < ncs[1]; j++) {
-	    for (k = 0; k < ncs[2]; k++) {
-	      items[n].byte_len = len;
-	      items[n].code_len = 3;
-	      items[n].code[0]  = cs[0][i];
-	      items[n].code[1]  = cs[1][j];
-	      items[n].code[2]  = cs[2][k];
-	      n++;
-	    }
-	  }
-	}
-
-	if (onig_st_lookup(Unfold3Table, (st_data_t )to->code,
-			   (void* )&z2) != 0) {
-	  for (i = 0; i < z2->n; i++) {
-	    if (z2->code[i] == code) continue;
-
-	    items[n].byte_len = len;
-	    items[n].code_len = 1;
-	    items[n].code[0]  = z2->code[i];
-	    n++;
-	  }
-	}
+        for (i = 0; i < ncs[0]; i++) {
+          for (j = 0; j < ncs[1]; j++) {
+            for (k = 0; k < ncs[2]; k++) {
+              items[n].byte_len = len;
+              items[n].code_len = 3;
+              items[n].code[0]  = cs[0][i];
+              items[n].code[1]  = cs[1][j];
+              items[n].code[2]  = cs[2][k];
+              n++;
+            }
+          }
+        }
+
+        if (onig_st_lookup(Unfold3Table, (st_data_t )to->code,
+                           (void* )&z2) != 0) {
+          for (i = 0; i < z2->n; i++) {
+            if (z2->code[i] == code) continue;
+
+            items[n].byte_len = len;
+            items[n].code_len = 1;
+            items[n].code[0]  = z2->code[i];
+            n++;
+          }
+        }
       }
 
       /* multi char folded code is not head of another folded multi char */
@@ -2543,10 +2543,10 @@ onigenc_unicode_get_case_fold_codes_by_str(OnigEncoding enc,
   else {
     if (onig_st_lookup(Unfold1Table, (st_data_t )code, (void* )&to) != 0) {
       for (i = 0; i < to->n; i++) {
-	items[n].byte_len = len;
-	items[n].code_len = 1;
-	items[n].code[0]  = to->code[i];
-	n++;
+        items[n].byte_len = len;
+        items[n].code_len = 1;
+        items[n].code[0]  = to->code[i];
+        n++;
       }
     }
   }
@@ -2560,44 +2560,44 @@ onigenc_unicode_get_case_fold_codes_by_str(OnigEncoding enc,
       codes[0] = code;
       code = ONIGENC_MBC_TO_CODE(enc, p, end);
       if (onig_st_lookup(FoldTable, (st_data_t )code, (void* )&to) != 0
-	  && to->n == 1) {
-	codes[1] = to->code[0];
+          && to->n == 1) {
+        codes[1] = to->code[0];
       }
       else
-	codes[1] = code;
+        codes[1] = code;
 
       clen = enclen(enc, p, end);
       len += clen;
       if (onig_st_lookup(Unfold2Table, (st_data_t )codes, (void* )&z2) != 0) {
-	for (i = 0; i < z2->n; i++) {
-	  items[n].byte_len = len;
-	  items[n].code_len = 1;
-	  items[n].code[0]  = z2->code[i];
-	  n++;
-	}
+        for (i = 0; i < z2->n; i++) {
+          items[n].byte_len = len;
+          items[n].code_len = 1;
+          items[n].code[0]  = z2->code[i];
+          n++;
+        }
       }
 
       p += clen;
       if (p < end) {
-	code = ONIGENC_MBC_TO_CODE(enc, p, end);
-	if (onig_st_lookup(FoldTable, (st_data_t )code, (void* )&to) != 0
-	    && to->n == 1) {
-	  codes[2] = to->code[0];
-	}
-	else
-	  codes[2] = code;
-
-	clen = enclen(enc, p, end);
-	len += clen;
-	if (onig_st_lookup(Unfold3Table, (st_data_t )codes,
-			   (void* )&z2) != 0) {
-	  for (i = 0; i < z2->n; i++) {
-	    items[n].byte_len = len;
-	    items[n].code_len = 1;
-	    items[n].code[0]  = z2->code[i];
-	    n++;
-	  }
-	}
+        code = ONIGENC_MBC_TO_CODE(enc, p, end);
+        if (onig_st_lookup(FoldTable, (st_data_t )code, (void* )&to) != 0
+            && to->n == 1) {
+          codes[2] = to->code[0];
+        }
+        else
+          codes[2] = code;
+
+        clen = enclen(enc, p, end);
+        len += clen;
+        if (onig_st_lookup(Unfold3Table, (st_data_t )codes,
+                           (void* )&z2) != 0) {
+          for (i = 0; i < z2->n; i++) {
+            items[n].byte_len = len;
+            items[n].code_len = 1;
+            items[n].code[0]  = z2->code[i];
+            n++;
+          }
+        }
       }
     }
   }
diff --git a/src/utf_8.c b/src/utf_8.c
index 9af010d4a..c444a2053 100644
--- a/src/utf_8.c
+++ b/src/utf_8.c
@@ -86,7 +86,7 @@ static const signed char trans[][0x100] = {
     /* c */ F, F, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
     /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
     /* e */ 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3,
-    /* f */ 5, 6, 6, 6, 7, F, F, F, F, F, F, F, F, F, F, F 
+    /* f */ 5, 6, 6, 6, 7, F, F, F, F, F, F, F, F, F, F, F
   },
   { /* S1   0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f */
     /* 0 */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
@@ -104,7 +104,7 @@ static const signed char trans[][0x100] = {
     /* c */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
     /* d */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
     /* e */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
-    /* f */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F 
+    /* f */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F
   },
   { /* S2   0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f */
     /* 0 */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
@@ -122,7 +122,7 @@ static const signed char trans[][0x100] = {
     /* c */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
     /* d */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
     /* e */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
-    /* f */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F 
+    /* f */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F
   },
   { /* S3   0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f */
     /* 0 */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
@@ -140,7 +140,7 @@ static const signed char trans[][0x100] = {
     /* c */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
     /* d */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
     /* e */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
-    /* f */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F 
+    /* f */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F
   },
   { /* S4   0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f */
     /* 0 */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
@@ -158,7 +158,7 @@ static const signed char trans[][0x100] = {
     /* c */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
     /* d */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
     /* e */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
-    /* f */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F 
+    /* f */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F
   },
   { /* S5   0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f */
     /* 0 */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
@@ -176,7 +176,7 @@ static const signed char trans[][0x100] = {
     /* c */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
     /* d */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
     /* e */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
-    /* f */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F 
+    /* f */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F
   },
   { /* S6   0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f */
     /* 0 */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
@@ -194,7 +194,7 @@ static const signed char trans[][0x100] = {
     /* c */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
     /* d */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
     /* e */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
-    /* f */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F 
+    /* f */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F
   },
   { /* S7   0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f */
     /* 0 */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
@@ -212,7 +212,7 @@ static const signed char trans[][0x100] = {
     /* c */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
     /* d */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
     /* e */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F,
-    /* f */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F 
+    /* f */ F, F, F, F, F, F, F, F, F, F, F, F, F, F, F, F
   },
 };
 #undef A
@@ -255,11 +255,11 @@ is_mbc_newline(const UChar* p, const UChar* end, OnigEncoding enc)
 #endif
     if (p + 1 < end) {
       if (*(p+1) == 0x85 && *p == 0xc2) /* U+0085 */
-	return 1;
+        return 1;
       if (p + 2 < end) {
-	if ((*(p+2) == 0xa8 || *(p+2) == 0xa9)
-	    && *(p+1) == 0x80 && *p == 0xe2)  /* U+2028, U+2029 */
-	  return 1;
+        if ((*(p+2) == 0xa8 || *(p+2) == 0xa9)
+            && *(p+1) == 0x80 && *p == 0xe2)  /* U+2028, U+2029 */
+          return 1;
       }
     }
 #endif
@@ -371,7 +371,7 @@ code_to_mbc(OnigCodePoint code, UChar *buf, OnigEncoding enc ARG_UNUSED)
 
 static int
 mbc_case_fold(OnigCaseFoldType flag, const UChar** pp,
-		   const UChar* end, UChar* fold, OnigEncoding enc)
+                   const UChar* end, UChar* fold, OnigEncoding enc)
 {
   const UChar* p = *pp;
 
@@ -379,10 +379,10 @@ mbc_case_fold(OnigCaseFoldType flag, const UChar** pp,
 #ifdef USE_UNICODE_CASE_FOLD_TURKISH_AZERI
     if ((flag & ONIGENC_CASE_FOLD_TURKISH_AZERI) != 0) {
       if (*p == 0x49) {
-	*fold++ = 0xc4;
-	*fold   = 0xb1;
-	(*pp)++;
-	return 2;
+        *fold++ = 0xc4;
+        *fold   = 0xb1;
+        (*pp)++;
+        return 2;
       }
     }
 #endif
@@ -399,7 +399,7 @@ mbc_case_fold(OnigCaseFoldType flag, const UChar** pp,
 
 static int
 get_ctype_code_range(OnigCtype ctype, OnigCodePoint *sb_out,
-			  const OnigCodePoint* ranges[], OnigEncoding enc ARG_UNUSED)
+                          const OnigCodePoint* ranges[], OnigEncoding enc ARG_UNUSED)
 {
   *sb_out = 0x80;
   return onigenc_unicode_ctype_code_range(ctype, ranges);
diff --git a/src/variable.c b/src/variable.c
index 5aba846b1..f4ec46789 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -1,6 +1,6 @@
 /*
 ** variable.c - mruby variables
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -165,7 +165,7 @@ mrb_vm_cv_get(mrb_state *mrb, mrb_sym sym)
       khiter_t k = kh_get(iv, h, sym);
 
       if (k != kh_end(h))
-	return kh_value(h, k);
+        return kh_value(h, k);
     }
     c = c->super;
   }
@@ -184,8 +184,8 @@ mrb_vm_cv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
       h = c->iv;
       k = kh_get(iv, h, sym);
       if (k != kh_end(h)) {
-	k = kh_put(iv, h, sym);
-	kh_value(h, k) = v;
+        k = kh_put(iv, h, sym);
+        kh_value(h, k) = v;
       }
     }
     c = c->super;
@@ -244,7 +244,7 @@ const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym)
       h = c->iv;
       k = kh_get(iv, h, sym);
       if (k != kh_end(h)) {
-	return kh_value(h, k);
+        return kh_value(h, k);
       }
     }
   }
@@ -254,13 +254,13 @@ const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym)
       h = c->iv;
       k = kh_get(iv, h, sym);
       if (k != kh_end(h)) {
-	return kh_value(h, k);
+        return kh_value(h, k);
       }
     }
     c = c->super;
   }
   mrb_raise(mrb, E_NAME_ERROR, "uninitialized constant %s",
-	    mrb_sym2name(mrb, sym));
+            mrb_sym2name(mrb, sym));
   /* not reached */
   return mrb_nil_value();
 }
diff --git a/src/version.c b/src/version.c
index 9be292a35..142c2239f 100644
--- a/src/version.c
+++ b/src/version.c
@@ -1,6 +1,6 @@
 /*
 ** version.c - version information
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/version.h b/src/version.h
index 0188acf19..fed532886 100644
--- a/src/version.h
+++ b/src/version.h
@@ -1,6 +1,6 @@
 /*
 ** version.h - version information
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
diff --git a/src/vm.c b/src/vm.c
index f74aac1b8..48a329a7d 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -1,6 +1,6 @@
 /*
 ** vm.c - virtual machine for mruby (RiteVM)
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -393,7 +393,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     }
 
     CASE(OP_MOVE) {
-      /* A B	R(A) := R(B) */
+      /* A B    R(A) := R(B) */
 #if 0
       regs[GETARG_A(i)] = regs[GETARG_B(i)];
 #elif 1
@@ -409,51 +409,51 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     }
 
     CASE(OP_LOADL) {
-      /* A Bx	R(A) := Pool(Bx) */
+      /* A Bx   R(A) := Pool(Bx) */
       regs[GETARG_A(i)] = pool[GETARG_Bx(i)];
       NEXT;
     }
 
     CASE(OP_LOADI) {
-      /* A Bx	R(A) := sBx */
+      /* A Bx   R(A) := sBx */
       SET_INT_VALUE(regs[GETARG_A(i)], GETARG_sBx(i));
       NEXT;
     }
 
     CASE(OP_LOADSYM) {
-      /* A B	R(A) := Sym(B) */
+      /* A B    R(A) := Sym(B) */
       SET_SYM_VALUE(regs[GETARG_A(i)], syms[GETARG_Bx(i)]);
       NEXT;
     }
 
     CASE(OP_LOADNIL) {
-      /* A B	R(A) := nil */
+      /* A B    R(A) := nil */
       int a = GETARG_A(i);
- 
+
       SET_NIL_VALUE(regs[a]);
       NEXT;
     }
 
     CASE(OP_LOADSELF) {
-      /* A	R(A) := self */
+      /* A      R(A) := self */
       regs[GETARG_A(i)] = mrb->stack[0];
       NEXT;
     }
 
     CASE(OP_LOADT) {
-      /* A	R(A) := true */
+      /* A      R(A) := true */
       regs[GETARG_A(i)] = mrb_true_value();
       NEXT;
     }
 
     CASE(OP_LOADF) {
-      /* A	R(A) := false */
+      /* A      R(A) := false */
       regs[GETARG_A(i)] = mrb_false_value();
       NEXT;
     }
 
     CASE(OP_GETGLOBAL) {
-      /* A B	R(A) := getglobal(Sym(B)) */
+      /* A B    R(A) := getglobal(Sym(B)) */
       regs[GETARG_A(i)] = mrb_gv_get(mrb, syms[GETARG_Bx(i)]);
       NEXT;
     }
@@ -465,19 +465,19 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     }
 
     CASE(OP_GETSPECIAL) {
-      /* A Bx	R(A) := Special[Bx] */
+      /* A Bx   R(A) := Special[Bx] */
       regs[GETARG_A(i)] = mrb_vm_special_get(mrb, GETARG_Bx(i));
       NEXT;
     }
 
     CASE(OP_SETSPECIAL) {
-      /* A Bx	Special[Bx] := R(A) */
+      /* A Bx   Special[Bx] := R(A) */
       mrb_vm_special_set(mrb, GETARG_Bx(i), regs[GETARG_A(i)]);
       NEXT;
     }
 
     CASE(OP_GETIV) {
-      /* A Bx	R(A) := ivget(Bx) */
+      /* A Bx   R(A) := ivget(Bx) */
       regs[GETARG_A(i)] = mrb_vm_iv_get(mrb, syms[GETARG_Bx(i)]);
       NEXT;
     }
@@ -489,7 +489,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     }
 
     CASE(OP_GETCV) {
-      /* A B	R(A) := ivget(Sym(B)) */
+      /* A B    R(A) := ivget(Sym(B)) */
       regs[GETARG_A(i)] = mrb_vm_cv_get(mrb, syms[GETARG_Bx(i)]);
       NEXT;
     }
@@ -501,19 +501,19 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     }
 
     CASE(OP_GETCONST) {
-      /* A B	R(A) := constget(Sym(B)) */
+      /* A B    R(A) := constget(Sym(B)) */
       regs[GETARG_A(i)] = mrb_vm_const_get(mrb, syms[GETARG_Bx(i)]);
       NEXT;
     }
 
     CASE(OP_SETCONST) {
-      /* A B	constset(Sym(B),R(A)) */
+      /* A B    constset(Sym(B),R(A)) */
       mrb_vm_const_set(mrb, syms[GETARG_Bx(i)], regs[GETARG_A(i)]);
       NEXT;
     }
 
     CASE(OP_GETMCNST) {
-      /* A B C	R(A) := R(C)::Sym(B) */
+      /* A B C  R(A) := R(C)::Sym(B) */
       int a = GETARG_A(i);
 
       regs[a] = mrb_const_get(mrb, regs[a], syms[GETARG_Bx(i)]);
@@ -521,7 +521,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     }
 
     CASE(OP_SETMCNST) {
-      /* A B C	R(A+1)::Sym(B) := R(A) */
+      /* A B C  R(A+1)::Sym(B) := R(A) */
       int a = GETARG_A(i);
 
       mrb_const_set(mrb, regs[a+1], syms[GETARG_Bx(i)], regs[a]);
@@ -529,54 +529,54 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     }
 
     CASE(OP_GETUPVAR) {
-      /* A B C	R(A) := uvget(B,C) */
+      /* A B C  R(A) := uvget(B,C) */
       regs[GETARG_A(i)] = uvget(mrb, GETARG_C(i), GETARG_B(i));
       NEXT;
     }
 
     CASE(OP_SETUPVAR) {
-      /* A B C	uvset(B,C,R(A)) */
+      /* A B C  uvset(B,C,R(A)) */
       uvset(mrb, GETARG_C(i), GETARG_B(i), regs[GETARG_A(i)]);
       NEXT;
     }
 
     CASE(OP_JMP) {
-      /* sBx	pc+=sBx */
+      /* sBx    pc+=sBx */
       pc += GETARG_sBx(i);
       JUMP;
     }
 
     CASE(OP_JMPIF) {
-      /* A sBx	if R(A) pc+=sBx */
+      /* A sBx  if R(A) pc+=sBx */
       if (mrb_test(regs[GETARG_A(i)])) {
-	pc += GETARG_sBx(i);
-	JUMP;
+        pc += GETARG_sBx(i);
+        JUMP;
       }
       NEXT;
     }
 
     CASE(OP_JMPNOT) {
-      /* A sBx	if R(A) pc+=sBx */
+      /* A sBx  if R(A) pc+=sBx */
       if (!mrb_test(regs[GETARG_A(i)])) {
-	pc += GETARG_sBx(i);
-	JUMP;
+        pc += GETARG_sBx(i);
+        JUMP;
       }
       NEXT;
     }
 
     CASE(OP_ONERR) {
-      /* sBx	pc+=sBx on exception */
+      /* sBx    pc+=sBx on exception */
       if (mrb->rsize <= mrb->ci->ridx) {
-	if (mrb->rsize == 0) mrb->rsize = 16;
-	else mrb->rsize *= 2;
-	mrb->rescue = mrb_realloc(mrb, mrb->rescue, sizeof(mrb_code*) * mrb->rsize);
+        if (mrb->rsize == 0) mrb->rsize = 16;
+        else mrb->rsize *= 2;
+        mrb->rescue = mrb_realloc(mrb, mrb->rescue, sizeof(mrb_code*) * mrb->rsize);
       }
       mrb->rescue[mrb->ci->ridx++] = pc + GETARG_sBx(i);
       NEXT;
     }
 
     CASE(OP_RESCUE) {
-      /* A	R(A) := exc; clear(exc) */
+      /* A      R(A) := exc; clear(exc) */
       SET_OBJ_VALUE(regs[GETARG_A(i)],mrb->exc);
       mrb->exc = 0;
       NEXT;
@@ -586,46 +586,46 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       int a = GETARG_A(i);
 
       while (a--) {
-	mrb->ci->ridx--;
+        mrb->ci->ridx--;
       }
       NEXT;
     }
 
     CASE(OP_RAISE) {
-      /* A	raise(R(A)) */
+      /* A      raise(R(A)) */
       mrb->exc = mrb_object(regs[GETARG_A(i)]);
       goto L_RAISE;
     }
 
     CASE(OP_EPUSH) {
-      /* Bx	ensure_push(SEQ[Bx]) */
+      /* Bx     ensure_push(SEQ[Bx]) */
       struct RProc *p;
 
       p = mrb_closure_new(mrb, mrb->irep[irep->idx+GETARG_Bx(i)]);
       /* push ensure_stack */
       if (mrb->esize <= mrb->ci->eidx) {
-	if (mrb->esize == 0) mrb->esize = 16;
-	else mrb->esize *= 2;
-	mrb->ensure = mrb_realloc(mrb, mrb->ensure, sizeof(struct RProc*) * mrb->esize);
+        if (mrb->esize == 0) mrb->esize = 16;
+        else mrb->esize *= 2;
+        mrb->ensure = mrb_realloc(mrb, mrb->ensure, sizeof(struct RProc*) * mrb->esize);
       }
       mrb->ensure[mrb->ci->eidx++] = p;
       NEXT;
     }
 
     CASE(OP_EPOP) {
-      /* A	A.times{ensure_pop().call} */
+      /* A      A.times{ensure_pop().call} */
       int n;
       int a = GETARG_A(i);
 
       for (n=0; n<a; n++) {
-	ecall(mrb, --mrb->ci->eidx);
+        ecall(mrb, --mrb->ci->eidx);
       }
       NEXT;
     }
 
   L_SEND:
     CASE(OP_SEND) {
-      /* A B C	R(A) := call(R(A),Sym(B),R(A+1),... ,R(A+C-1)) */
+      /* A B C  R(A) := call(R(A),Sym(B),R(A+1),... ,R(A+C-1)) */
       int a = GETARG_A(i);
       int n = GETARG_C(i);
       struct RProc *m;
@@ -638,18 +638,18 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       c = mrb_class(mrb, recv);
       m = mrb_method_search_vm(mrb, &c, mid);
       if (!m) {
-	mrb_value sym = mrb_symbol_value(mid);
-
-	mid = mrb_intern(mrb, "method_missing");
-	m = mrb_method_search_vm(mrb, &c, mid);
-	if (n == CALL_MAXARGS) {
-	  mrb_ary_unshift(mrb, regs[a+1], sym);
-	}
-	else {
-	  memmove(regs+a+2, regs+a+1, sizeof(mrb_value)*(n+1));
-	  regs[a+1] = sym;
-	  n++;
-	}
+        mrb_value sym = mrb_symbol_value(mid);
+
+        mid = mrb_intern(mrb, "method_missing");
+        m = mrb_method_search_vm(mrb, &c, mid);
+        if (n == CALL_MAXARGS) {
+          mrb_ary_unshift(mrb, regs[a+1], sym);
+        }
+        else {
+          memmove(regs+a+2, regs+a+1, sizeof(mrb_value)*(n+1));
+          regs[a+1] = sym;
+          n++;
+        }
       }
 
       /* push callinfo */
@@ -666,48 +666,48 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       mrb->stack += a;
 
       if (MRB_PROC_CFUNC_P(m)) {
-	mrb->stack[0] = m->body.func(mrb, recv);
-	mrb->arena_idx = ai;
-	if (mrb->exc) goto L_RAISE;
-	/* pop stackpos */
-	mrb->stack = mrb->stbase + ci->stackidx;
-	cipop(mrb);
-	NEXT;
+        mrb->stack[0] = m->body.func(mrb, recv);
+        mrb->arena_idx = ai;
+        if (mrb->exc) goto L_RAISE;
+        /* pop stackpos */
+        mrb->stack = mrb->stbase + ci->stackidx;
+        cipop(mrb);
+        NEXT;
       }
       else {
-	/* fill callinfo */
-	ci->acc = a;
-
-	/* setup environment for calling method */
-	proc = mrb->ci->proc = m;
-	irep = m->body.irep;
-	pool = irep->pool;
-	syms = irep->syms;
-	ci->nregs = irep->nregs;
-	if (ci->argc < 0) {
-	  stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
-	}
-	else {
-	  stack_extend(mrb, irep->nregs,  ci->argc+2);
-	}
-	regs = mrb->stack;
-	pc = irep->iseq;
-	JUMP;
+        /* fill callinfo */
+        ci->acc = a;
+
+        /* setup environment for calling method */
+        proc = mrb->ci->proc = m;
+        irep = m->body.irep;
+        pool = irep->pool;
+        syms = irep->syms;
+        ci->nregs = irep->nregs;
+        if (ci->argc < 0) {
+          stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
+        }
+        else {
+          stack_extend(mrb, irep->nregs,  ci->argc+2);
+        }
+        regs = mrb->stack;
+        pc = irep->iseq;
+        JUMP;
       }
     }
 
     CASE(OP_FSEND) {
-      /* A B C	R(A) := fcall(R(A),Sym(B),R(A+1),... ,R(A+C)) */
+      /* A B C  R(A) := fcall(R(A),Sym(B),R(A+1),... ,R(A+C)) */
       NEXT;
     }
 
     CASE(OP_VSEND) {
-      /* A B	R(A) := vcall(R(A),Sym(B)) */
+      /* A B    R(A) := vcall(R(A),Sym(B)) */
       NEXT;
     }
 
     CASE(OP_CALL) {
-      /* A	R(A) := self.call(frame.argc, frame.argv) */
+      /* A      R(A) := self.call(frame.argc, frame.argv) */
       mrb_callinfo *ci;
       mrb_value recv = mrb->stack[0];
       struct RProc *m = mrb_proc_ptr(recv);
@@ -717,44 +717,44 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       ci->target_class = m->target_class;
       ci->proc = m;
       if (m->env) {
-	ci->mid = m->env->mid;
-	if (!m->env->stack) {
-	  m->env->stack = mrb->stack;
-	}
+        ci->mid = m->env->mid;
+        if (!m->env->stack) {
+          m->env->stack = mrb->stack;
+        }
       }
 
       /* prepare stack */
       if (MRB_PROC_CFUNC_P(m)) {
-	mrb->stack[0] = m->body.func(mrb, recv);
-	mrb->arena_idx = ai;
-	if (mrb->exc) goto L_RAISE;
-	/* pop stackpos */
-	regs = mrb->stack = mrb->stbase + ci->stackidx;
-	cipop(mrb);
-	NEXT;
+        mrb->stack[0] = m->body.func(mrb, recv);
+        mrb->arena_idx = ai;
+        if (mrb->exc) goto L_RAISE;
+        /* pop stackpos */
+        regs = mrb->stack = mrb->stbase + ci->stackidx;
+        cipop(mrb);
+        NEXT;
       }
       else {
-	/* setup environment for calling method */
-	proc = m;
-	irep = m->body.irep;
-	pool = irep->pool;
-	syms = irep->syms;
-	ci->nregs = irep->nregs;
-	if (ci->argc < 0) {
-	  stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
-	}
-	else {
-	  stack_extend(mrb, irep->nregs,  ci->argc+2);
-	}
-	regs = mrb->stack;
-	regs[0] = m->env->stack[0];
-	pc = m->body.irep->iseq;
-	JUMP;
+        /* setup environment for calling method */
+        proc = m;
+        irep = m->body.irep;
+        pool = irep->pool;
+        syms = irep->syms;
+        ci->nregs = irep->nregs;
+        if (ci->argc < 0) {
+          stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
+        }
+        else {
+          stack_extend(mrb, irep->nregs,  ci->argc+2);
+        }
+        regs = mrb->stack;
+        regs[0] = m->env->stack[0];
+        pc = m->body.irep->iseq;
+        JUMP;
       }
     }
 
     CASE(OP_SUPER) {
-      /* A B C	R(A) := super(R(A+1),... ,R(A+C-1)) */
+      /* A B C  R(A) := super(R(A+1),... ,R(A+C-1)) */
       mrb_value recv;
       mrb_callinfo *ci = mrb->ci;
       struct RProc *m;
@@ -767,17 +767,17 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       c = mrb->ci->proc->target_class->super;
       m = mrb_method_search_vm(mrb, &c, mid);
       if (!m) {
-	c = mrb->ci->proc->target_class;
-	mid = mrb_intern(mrb, "method_missing");
-	m = mrb_method_search_vm(mrb, &c, mid);
-	if (n == CALL_MAXARGS) {
-	  mrb_ary_unshift(mrb, regs[a+1], mrb_symbol_value(ci->mid));
-	}
-	else {
-	  memmove(regs+a+2, regs+a+1, sizeof(mrb_value)*(n+1));
-	  regs[a+1] = mrb_symbol_value(ci->mid);
-	  n++;
-	}
+        c = mrb->ci->proc->target_class;
+        mid = mrb_intern(mrb, "method_missing");
+        m = mrb_method_search_vm(mrb, &c, mid);
+        if (n == CALL_MAXARGS) {
+          mrb_ary_unshift(mrb, regs[a+1], mrb_symbol_value(ci->mid));
+        }
+        else {
+          memmove(regs+a+2, regs+a+1, sizeof(mrb_value)*(n+1));
+          regs[a+1] = mrb_symbol_value(ci->mid);
+          n++;
+        }
       }
 
       /* push callinfo */
@@ -795,38 +795,38 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       mrb->stack[0] = recv;
 
       if (MRB_PROC_CFUNC_P(m)) {
-	mrb->stack[0] = m->body.func(mrb, recv);
-	mrb->arena_idx = ai;
-	if (mrb->exc) goto L_RAISE;
-	/* pop stackpos */
-	mrb->stack = mrb->stbase + ci->stackidx;
-	cipop(mrb);
-	NEXT;
+        mrb->stack[0] = m->body.func(mrb, recv);
+        mrb->arena_idx = ai;
+        if (mrb->exc) goto L_RAISE;
+        /* pop stackpos */
+        mrb->stack = mrb->stbase + ci->stackidx;
+        cipop(mrb);
+        NEXT;
       }
       else {
-	/* fill callinfo */
-	ci->acc = a;
-
-	/* setup environment for calling method */
-	ci->proc = m;
-	irep = m->body.irep;
-	pool = irep->pool;
-	syms = irep->syms;
-	ci->nregs = irep->nregs;
-	if (ci->argc < 0) {
-	  stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
-	}
-	else {
-	  stack_extend(mrb, irep->nregs,  ci->argc+2);
-	}
-	regs = mrb->stack;
-	pc = irep->iseq;
-	JUMP;
+        /* fill callinfo */
+        ci->acc = a;
+
+        /* setup environment for calling method */
+        ci->proc = m;
+        irep = m->body.irep;
+        pool = irep->pool;
+        syms = irep->syms;
+        ci->nregs = irep->nregs;
+        if (ci->argc < 0) {
+          stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
+        }
+        else {
+          stack_extend(mrb, irep->nregs,  ci->argc+2);
+        }
+        regs = mrb->stack;
+        pc = irep->iseq;
+        JUMP;
       }
     }
 
     CASE(OP_ARGARY) {
-      /* A Bx	R(A) := argument array (16=6:1:5:4) */
+      /* A Bx   R(A) := argument array (16=6:1:5:4) */
       int a = GETARG_A(i);
       int bx = GETARG_Bx(i);
       int m1 = (bx>>10)&0x3f;
@@ -837,40 +837,40 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 
       if (lv == 0) stack = regs + 1;
       else {
-	struct REnv *e = uvenv(mrb, lv-1);
-	stack = e->stack + 1;
+        struct REnv *e = uvenv(mrb, lv-1);
+        stack = e->stack + 1;
       }
       if (r == 0) {
-	regs[a] = mrb_ary_new_elts(mrb, m1+m2, stack);
+        regs[a] = mrb_ary_new_elts(mrb, m1+m2, stack);
       }
       else {
-	mrb_value *pp;
-	struct RArray *rest;
-	int len = 0;
-
-	if (stack[m1].tt == MRB_TT_ARRAY) {
-	  struct RArray *ary = mrb_ary_ptr(stack[m1]);
-
-	  pp = ary->buf;
-	  len = ary->len;
-	}
-	regs[a] = mrb_ary_new_capa(mrb, m1+len+m2);
-	rest = mrb_ary_ptr(regs[a]);
-	memcpy(rest->buf, stack, sizeof(mrb_value)*m1);
-	if (len > 0) {
-	  memcpy(rest->buf+m1, pp, sizeof(mrb_value)*len);
-	}
-	if (m2 > 0) {
-	  memcpy(rest->buf+m1+len, stack+m1+1, sizeof(mrb_value)*m2);
-	}
-	rest->len = m1+len+m2;
+        mrb_value *pp;
+        struct RArray *rest;
+        int len = 0;
+
+        if (stack[m1].tt == MRB_TT_ARRAY) {
+          struct RArray *ary = mrb_ary_ptr(stack[m1]);
+
+          pp = ary->buf;
+          len = ary->len;
+        }
+        regs[a] = mrb_ary_new_capa(mrb, m1+len+m2);
+        rest = mrb_ary_ptr(regs[a]);
+        memcpy(rest->buf, stack, sizeof(mrb_value)*m1);
+        if (len > 0) {
+          memcpy(rest->buf+m1, pp, sizeof(mrb_value)*len);
+        }
+        if (m2 > 0) {
+          memcpy(rest->buf+m1+len, stack+m1+1, sizeof(mrb_value)*m2);
+        }
+        rest->len = m1+len+m2;
       }
       regs[a+1] = stack[m1+r+m2];
       NEXT;
     }
 
     CASE(OP_ENTER) {
-      /* Ax		arg setup according to flags (24=5:5:1:5:5:1:1) */
+      /* Ax             arg setup according to flags (24=5:5:1:5:5:1:1) */
       /* number of optional arguments times OP_JMP should follow */
       int ax = GETARG_Ax(i);
       int m1 = (ax>>18)&0x1f;
@@ -887,142 +887,142 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       int len = m1 + o + r + m2;
 
       if (argc < 0) {
-	struct RArray *ary = mrb_ary_ptr(regs[1]);
-	argv = ary->buf;
-	argc = ary->len;
-	regs[len+2] = regs[1];	/* save argary in register */
+        struct RArray *ary = mrb_ary_ptr(regs[1]);
+        argv = ary->buf;
+        argc = ary->len;
+        regs[len+2] = regs[1];  /* save argary in register */
       }
       if (mrb->ci->proc && MRB_PROC_STRICT_P(mrb->ci->proc)) {
-	if (argc >= 0) {
-	  if (argc < m1 + m2 || (r == 0 && argc > len)) {
-	    fprintf(stderr, "'%s': wrong number of arguments (%d for %d)\n",
-		    mrb_sym2name(mrb, mrb->ci->mid),
-		    mrb->ci->argc, m1+m2);
-	    exit(1);
-	  }
-	}
+        if (argc >= 0) {
+          if (argc < m1 + m2 || (r == 0 && argc > len)) {
+            fprintf(stderr, "'%s': wrong number of arguments (%d for %d)\n",
+                    mrb_sym2name(mrb, mrb->ci->mid),
+                    mrb->ci->argc, m1+m2);
+            exit(1);
+          }
+        }
       }
       else if (len > 1 && argc == 1 && argv[0].tt == MRB_TT_ARRAY) {
-	argc = mrb_ary_ptr(argv[0])->len;
-	argv = mrb_ary_ptr(argv[0])->buf;
+        argc = mrb_ary_ptr(argv[0])->len;
+        argv = mrb_ary_ptr(argv[0])->buf;
       }
       mrb->ci->argc = len;
       if (argc < len) {
-	regs[len+1] = argv[argc]; /* move block */
-	memmove(&regs[1], argv, sizeof(mrb_value)*(argc-m2)); /* m1 + o */
-	memmove(&regs[len-m2+1], &argv[argc-m2], sizeof(mrb_value)*m2); /* m2 */
-	if (r) {		  /* r */
-	  regs[m1+o+1] = mrb_ary_new_capa(mrb, 0);
-	}
-	pc += argc - m1 - m2 + 1;
+        regs[len+1] = argv[argc]; /* move block */
+        memmove(&regs[1], argv, sizeof(mrb_value)*(argc-m2)); /* m1 + o */
+        memmove(&regs[len-m2+1], &argv[argc-m2], sizeof(mrb_value)*m2); /* m2 */
+        if (r) {                  /* r */
+          regs[m1+o+1] = mrb_ary_new_capa(mrb, 0);
+        }
+        pc += argc - m1 - m2 + 1;
       }
       else {
-	memmove(&regs[1], argv, sizeof(mrb_value)*(m1+o)); /* m1 + o */
-	if (r) {		  /* r */
-	  regs[m1+o+1] = mrb_ary_new_elts(mrb, argc-m1-o-m2, argv+m1+o);
-	}
-	memmove(&regs[m1+o+r+1], &argv[argc-m2], sizeof(mrb_value)*m2);
-	regs[len+1] = argv[argc]; /* move block */
-	pc += o + 1;
+        memmove(&regs[1], argv, sizeof(mrb_value)*(m1+o)); /* m1 + o */
+        if (r) {                  /* r */
+          regs[m1+o+1] = mrb_ary_new_elts(mrb, argc-m1-o-m2, argv+m1+o);
+        }
+        memmove(&regs[m1+o+r+1], &argv[argc-m2], sizeof(mrb_value)*m2);
+        regs[len+1] = argv[argc]; /* move block */
+        pc += o + 1;
       }
       JUMP;
     }
 
     CASE(OP_KARG) {
-      /* A B C		R(A) := kdict[Sym(B)]; if C kdict.rm(Sym(B)) */
+      /* A B C          R(A) := kdict[Sym(B)]; if C kdict.rm(Sym(B)) */
       /* if C == 2; raise unless kdict.empty? */
       /* OP_JMP should follow to skip init code */
       NEXT;
     }
 
     CASE(OP_KDICT) {
-      /* A C		R(A) := kdict */
+      /* A C            R(A) := kdict */
       NEXT;
     }
 
     CASE(OP_RETURN) {
-      /* A	return R(A) */
+      /* A      return R(A) */
     L_RETURN:
       if (mrb->ci->env) {
-	struct REnv *e = mrb->ci->env;
-	int len = (int)e->flags;
-	mrb_value *p = mrb_malloc(mrb, sizeof(mrb_value)*len);
+        struct REnv *e = mrb->ci->env;
+        int len = (int)e->flags;
+        mrb_value *p = mrb_malloc(mrb, sizeof(mrb_value)*len);
 
-	e->cioff = -1;
-	memcpy(p, e->stack, sizeof(mrb_value)*len);
-	e->stack = p;
+        e->cioff = -1;
+        memcpy(p, e->stack, sizeof(mrb_value)*len);
+        e->stack = p;
       }
 
       if (mrb->exc) {
-	mrb_callinfo *ci;
+        mrb_callinfo *ci;
 
       L_RAISE:
-	ci = mrb->ci;
-	if (ci == mrb->cibase) goto L_STOP;
-	while (ci[0].ridx == ci[-1].ridx) {
-	  cipop(mrb);
-	  ci = mrb->ci;
-	  if (ci == mrb->cibase) {
-	    if (ci->ridx == 0) goto L_STOP;
-	    break;
-	  }
-	}
-	irep = ci->proc->body.irep;
-	pool = irep->pool;
-	syms = irep->syms;
-	regs = mrb->stack = mrb->stbase + ci->stackidx;
-	pc = mrb->rescue[--ci->ridx];
+        ci = mrb->ci;
+        if (ci == mrb->cibase) goto L_STOP;
+        while (ci[0].ridx == ci[-1].ridx) {
+          cipop(mrb);
+          ci = mrb->ci;
+          if (ci == mrb->cibase) {
+            if (ci->ridx == 0) goto L_STOP;
+            break;
+          }
+        }
+        irep = ci->proc->body.irep;
+        pool = irep->pool;
+        syms = irep->syms;
+        regs = mrb->stack = mrb->stbase + ci->stackidx;
+        pc = mrb->rescue[--ci->ridx];
       }
       else {
-	mrb_callinfo *ci = mrb->ci;
-	int acc, eidx = mrb->ci->eidx;
-	mrb_value v = regs[GETARG_A(i)];
-
-	switch (GETARG_B(i)) {
-	case OP_R_NORMAL:
-	  ci = mrb->ci;
-	  break;
-	case OP_R_BREAK:
-	  if (proc->env->cioff < 0) {
-	    localjump_error(mrb, "break");
-	    goto L_RAISE;
-	  }
-	  ci = mrb->ci = mrb->cibase + proc->env->cioff + 1;
-	  break;
-	case OP_R_RETURN:
-	  if (proc->env->cioff < 0) {
-	    localjump_error(mrb, "return");
-	  }
-	  ci = mrb->ci = mrb->cibase + proc->env->cioff;
-	  break;
-	default:
-	  /* cannot happen */
-	  break;
-	}
-	cipop(mrb);
-	acc = ci->acc;
-	pc = ci->pc;
-	regs = mrb->stack = mrb->stbase + ci->stackidx;
-	while (eidx > mrb->ci->eidx) {
-	  ecall(mrb, --eidx);
-	}
-	if (acc < 0) {
-	  mrb->jmp = prev_jmp;
-	  return v;
-	}
-	DEBUG(printf("from :%s\n", mrb_sym2name(mrb, ci->mid)));
-	proc = mrb->ci->proc;
-	irep = proc->body.irep;
-	pool = irep->pool;
-	syms = irep->syms;
-
-	regs[acc] = v;
+        mrb_callinfo *ci = mrb->ci;
+        int acc, eidx = mrb->ci->eidx;
+        mrb_value v = regs[GETARG_A(i)];
+
+        switch (GETARG_B(i)) {
+        case OP_R_NORMAL:
+          ci = mrb->ci;
+          break;
+        case OP_R_BREAK:
+          if (proc->env->cioff < 0) {
+            localjump_error(mrb, "break");
+            goto L_RAISE;
+          }
+          ci = mrb->ci = mrb->cibase + proc->env->cioff + 1;
+          break;
+        case OP_R_RETURN:
+          if (proc->env->cioff < 0) {
+            localjump_error(mrb, "return");
+          }
+          ci = mrb->ci = mrb->cibase + proc->env->cioff;
+          break;
+        default:
+          /* cannot happen */
+          break;
+        }
+        cipop(mrb);
+        acc = ci->acc;
+        pc = ci->pc;
+        regs = mrb->stack = mrb->stbase + ci->stackidx;
+        while (eidx > mrb->ci->eidx) {
+          ecall(mrb, --eidx);
+        }
+        if (acc < 0) {
+          mrb->jmp = prev_jmp;
+          return v;
+        }
+        DEBUG(printf("from :%s\n", mrb_sym2name(mrb, ci->mid)));
+        proc = mrb->ci->proc;
+        irep = proc->body.irep;
+        pool = irep->pool;
+        syms = irep->syms;
+
+        regs[acc] = v;
       }
       JUMP;
     }
 
     CASE(OP_TAILCALL) {
-      /* A B C	return call(R(A),Sym(B),R(A+1),... ,R(A+C-1)) */
+      /* A B C  return call(R(A),Sym(B),R(A+1),... ,R(A+C-1)) */
       int a = GETARG_A(i);
       int n = GETARG_C(i);
       struct RProc *m;
@@ -1035,18 +1035,18 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       c = mrb_class(mrb, recv);
       m = mrb_method_search_vm(mrb, &c, mid);
       if (!m) {
-	mrb_value sym = mrb_symbol_value(mid);
-
-	mid = mrb_intern(mrb, "method_missing");
-	m = mrb_method_search_vm(mrb, &c, mid);
-	if (n == CALL_MAXARGS) {
-	  mrb_ary_unshift(mrb, regs[a+1], sym);
-	}
-	else {
-	  memmove(regs+a+2, regs+a+1, sizeof(mrb_value)*(n+1));
-	  regs[a+1] = sym;
-	  n++;
-	}
+        mrb_value sym = mrb_symbol_value(mid);
+
+        mid = mrb_intern(mrb, "method_missing");
+        m = mrb_method_search_vm(mrb, &c, mid);
+        if (n == CALL_MAXARGS) {
+          mrb_ary_unshift(mrb, regs[a+1], sym);
+        }
+        else {
+          memmove(regs+a+2, regs+a+1, sizeof(mrb_value)*(n+1));
+          regs[a+1] = sym;
+          n++;
+        }
       }
 
 
@@ -1061,29 +1061,29 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       memmove(mrb->stack, &regs[a], (ci->argc+1)*sizeof(mrb_value));
 
       if (MRB_PROC_CFUNC_P(m)) {
-	mrb->stack[0] = m->body.func(mrb, recv);
-	mrb->arena_idx = ai;
-	goto L_RETURN;
+        mrb->stack[0] = m->body.func(mrb, recv);
+        mrb->arena_idx = ai;
+        goto L_RETURN;
       }
       else {
-	/* setup environment for calling method */
-	irep = m->body.irep;
-	pool = irep->pool;
-	syms = irep->syms;
-	if (ci->argc < 0) {
-	  stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
-	}
-	else {
-	  stack_extend(mrb, irep->nregs,  ci->argc+2);
-	}
-	regs = mrb->stack;
-	pc = irep->iseq;
+        /* setup environment for calling method */
+        irep = m->body.irep;
+        pool = irep->pool;
+        syms = irep->syms;
+        if (ci->argc < 0) {
+          stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
+        }
+        else {
+          stack_extend(mrb, irep->nregs,  ci->argc+2);
+        }
+        regs = mrb->stack;
+        pc = irep->iseq;
       }
       JUMP;
     }
 
     CASE(OP_BLKPUSH) {
-      /* A Bx	R(A) := block (16=6:1:5:4) */
+      /* A Bx   R(A) := block (16=6:1:5:4) */
       int a = GETARG_A(i);
       int bx = GETARG_Bx(i);
       int m1 = (bx>>10)&0x3f;
@@ -1094,8 +1094,8 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 
       if (lv == 0) stack = regs + 1;
       else {
-	struct REnv *e = uvenv(mrb, lv-1);
-	stack = e->stack + 1;
+        struct REnv *e = uvenv(mrb, lv-1);
+        stack = e->stack + 1;
       }
       regs[a] = stack[m1+r+m2];
       NEXT;
@@ -1111,7 +1111,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
   /* need to check if - is overridden */\
   switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
   case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):\
-    OP_MATH_BODY(op,i,i);		   \
+    OP_MATH_BODY(op,i,i);                  \
     break;\
   case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT):\
     {\
@@ -1133,90 +1133,90 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 } while (0)
 
     CASE(OP_ADD) {
-      /* A B C	R(A) := R(A)+R(A+1) (Syms[B]=:+,C=1)*/
+      /* A B C  R(A) := R(A)+R(A+1) (Syms[B]=:+,C=1)*/
       int a = GETARG_A(i);
 
       switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {
       case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):
-	OP_MATH_BODY(+,i,i);
-	break;
+        OP_MATH_BODY(+,i,i);
+        break;
       case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT):
-	{
-	  mrb_int x = regs[a].value.i;
-	  mrb_float y = regs[a+1].value.f;
-	  SET_FLOAT_VALUE(regs[a], (mrb_float)x + y);
-	}
-	break;
+        {
+          mrb_int x = regs[a].value.i;
+          mrb_float y = regs[a+1].value.f;
+          SET_FLOAT_VALUE(regs[a], (mrb_float)x + y);
+        }
+        break;
       case TYPES2(MRB_TT_FLOAT,MRB_TT_FIXNUM):
-	OP_MATH_BODY(+,f,i);
-	break;
+        OP_MATH_BODY(+,f,i);
+        break;
       case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):
-	OP_MATH_BODY(+,f,f);
-	break;
+        OP_MATH_BODY(+,f,f);
+        break;
       case TYPES2(MRB_TT_STRING,MRB_TT_STRING):
-	regs[a] = mrb_str_plus(mrb, regs[a], regs[a+1]);
-	break;
+        regs[a] = mrb_str_plus(mrb, regs[a], regs[a+1]);
+        break;
       default:
-	i = MKOP_ABC(OP_SEND, a, GETARG_B(i), GETARG_C(i));
-	goto L_SEND;
+        i = MKOP_ABC(OP_SEND, a, GETARG_B(i), GETARG_C(i));
+        goto L_SEND;
       }
       NEXT;
     }
 
     CASE(OP_SUB) {
-      /* A B C	R(A) := R(A)-R(A+1) (Syms[B]=:-,C=1)*/
+      /* A B C  R(A) := R(A)-R(A+1) (Syms[B]=:-,C=1)*/
       OP_MATH(-);
       NEXT;
     }
 
     CASE(OP_MUL) {
-      /* A B C	R(A) := R(A)*R(A+1) (Syms[B]=:*,C=1)*/
+      /* A B C  R(A) := R(A)*R(A+1) (Syms[B]=:*,C=1)*/
       OP_MATH(*);
       NEXT;
     }
 
     CASE(OP_DIV) {
-      /* A B C	R(A) := R(A)/R(A+1) (Syms[B]=:/,C=1)*/
+      /* A B C  R(A) := R(A)/R(A+1) (Syms[B]=:/,C=1)*/
       OP_MATH(/);
       NEXT;
     }
 
     CASE(OP_ADDI) {
-      /* A B C	R(A) := R(A)+C (Syms[B]=:+)*/
+      /* A B C  R(A) := R(A)+C (Syms[B]=:+)*/
       int a = GETARG_A(i);
 
       /* need to check if + is overridden */
       switch (mrb_type(regs[a])) {
       case MRB_TT_FIXNUM:
-	regs[a].value.i += GETARG_C(i);
-	break;
+        regs[a].value.i += GETARG_C(i);
+        break;
       case MRB_TT_FLOAT:
-	regs[a].value.f += GETARG_C(i);
-	break;
+        regs[a].value.f += GETARG_C(i);
+        break;
       default:
-	SET_INT_VALUE(regs[a+1], GETARG_C(i));
-	i = MKOP_ABC(OP_SEND, a, GETARG_B(i), 1);
-	goto L_SEND;
+        SET_INT_VALUE(regs[a+1], GETARG_C(i));
+        i = MKOP_ABC(OP_SEND, a, GETARG_B(i), 1);
+        goto L_SEND;
       }
       NEXT;
     }
 
     CASE(OP_SUBI) {
-      /* A B C	R(A) := R(A)-C (Syms[B]=:+)*/
+      /* A B C  R(A) := R(A)-C (Syms[B]=:+)*/
       int a = GETARG_A(i);
 
       /* need to check if + is overridden */
       switch (mrb_type(regs[a])) {
       case MRB_TT_FIXNUM:
-	regs[a].value.i -= GETARG_C(i);
-	break;
+        regs[a].value.i -= GETARG_C(i);
+        break;
       case MRB_TT_FLOAT:
-	regs[a].value.f -= GETARG_C(i);
-	break;
+        regs[a].value.f -= GETARG_C(i);
+        break;
       default:
-	SET_INT_VALUE(regs[a+1], GETARG_C(i));
-	i = MKOP_ABC(OP_SEND, a, GETARG_B(i), 1);
-	goto L_SEND;
+        SET_INT_VALUE(regs[a+1], GETARG_C(i));
+        i = MKOP_ABC(OP_SEND, a, GETARG_B(i), 1);
+        goto L_SEND;
       }
       NEXT;
     }
@@ -1235,7 +1235,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
   /* need to check if - is overridden */\
   switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
   case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):\
-    OP_CMP_BODY(op,i,i);		   \
+    OP_CMP_BODY(op,i,i);                   \
     break;\
   case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT):\
     OP_CMP_BODY(op,i,f);\
@@ -1253,134 +1253,134 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 } while (0)
 
     CASE(OP_EQ) {
-      /* A B C	R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
+      /* A B C  R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
       OP_CMP(==);
       NEXT;
     }
 
     CASE(OP_LT) {
-      /* A B C	R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
+      /* A B C  R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
       OP_CMP(<);
       NEXT;
     }
 
     CASE(OP_LE) {
-      /* A B C	R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
+      /* A B C  R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
       OP_CMP(<=);
       NEXT;
     }
 
     CASE(OP_GT) {
-      /* A B C	R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
+      /* A B C  R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
       OP_CMP(>);
       NEXT;
     }
 
     CASE(OP_GE) {
-      /* A B C	R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
+      /* A B C  R(A) := R(A)<R(A+1) (Syms[B]=:<,C=1)*/
       OP_CMP(>=);
       NEXT;
     }
 
     CASE(OP_ARRAY) {
-      /* A B C   	R(A) := ary_new(R(B),R(B+1)..R(B+C)) */
+      /* A B C          R(A) := ary_new(R(B),R(B+1)..R(B+C)) */
       int b = GETARG_B(i);
       int lim = b+GETARG_C(i);
       mrb_value ary = mrb_ary_new_capa(mrb, GETARG_C(i));
 
       while (b < lim) {
-	mrb_ary_push(mrb, ary, regs[b++]);
+        mrb_ary_push(mrb, ary, regs[b++]);
       }
       regs[GETARG_A(i)] = ary;
       NEXT;
     }
 
     CASE(OP_ARYCAT) {
-      /* A B		mrb_ary_concat(R(A),R(B)) */
+      /* A B            mrb_ary_concat(R(A),R(B)) */
       mrb_ary_concat(mrb, regs[GETARG_A(i)],
-		     mrb_ary_splat(mrb, regs[GETARG_B(i)]));
+                     mrb_ary_splat(mrb, regs[GETARG_B(i)]));
       NEXT;
     }
 
     CASE(OP_ARYPUSH) {
-      /* A B		R(A).push(R(B)) */
+      /* A B            R(A).push(R(B)) */
       mrb_ary_push(mrb, regs[GETARG_A(i)], regs[GETARG_B(i)]);
       NEXT;
     }
 
     CASE(OP_AREF) {
-      /* A B C		R(A) := R(B)[C] */
+      /* A B C          R(A) := R(B)[C] */
       int a = GETARG_A(i);
       int c = GETARG_C(i);
       mrb_value v = regs[GETARG_B(i)];
 
       if (v.tt != MRB_TT_ARRAY) {
-	if (c == 0) {
-	  regs[GETARG_A(i)] = v;
-	}
-	else {
-	  SET_NIL_VALUE(regs[a]);
-	}
+        if (c == 0) {
+          regs[GETARG_A(i)] = v;
+        }
+        else {
+          SET_NIL_VALUE(regs[a]);
+        }
       }
       else {
-	regs[GETARG_A(i)] = mrb_ary_ref(mrb, v, c);
+        regs[GETARG_A(i)] = mrb_ary_ref(mrb, v, c);
       }
       NEXT;
     }
 
     CASE(OP_ASET) {
-      /* A B C		R(B)[C] := R(A) */
+      /* A B C          R(B)[C] := R(A) */
       mrb_ary_set(mrb, regs[GETARG_B(i)], GETARG_C(i), regs[GETARG_A(i)]);
       NEXT;
     }
 
     CASE(OP_APOST) {
-      /* A B C	*R(A),R(A+1)..R(A+C) := R(A) */
+      /* A B C  *R(A),R(A+1)..R(A+C) := R(A) */
       int a = GETARG_A(i);
       mrb_value v = regs[a];
       int pre  = GETARG_B(i);
       int post = GETARG_C(i);
 
       if (v.tt != MRB_TT_ARRAY) {
-	regs[a++] = mrb_ary_new_capa(mrb, 0);
-	while (post--) {
-	  SET_NIL_VALUE(regs[a]);
-	  a++;
-	}
+        regs[a++] = mrb_ary_new_capa(mrb, 0);
+        while (post--) {
+          SET_NIL_VALUE(regs[a]);
+          a++;
+        }
       }
       else {
-	struct RArray *ary = mrb_ary_ptr(v);
-	size_t len = ary->len;
-	int i;
-
-	if (len > pre + post) {
-	  regs[a++] = mrb_ary_new_elts(mrb, len - pre - post, ary->buf+pre);
-	  while (post--) {
-	    regs[a++] = ary->buf[len-post-1];
-	  }
-	}
-	else {
-	  regs[a++] = mrb_ary_new_capa(mrb, 0);
-	  for (i=0; i+pre<len; i++) {
-	    regs[a+i] = ary->buf[pre+i];
-	  }
-	  while (i < post) {
-	    SET_NIL_VALUE(regs[a+i]);
-	    i++;
-	  }
-	}
+        struct RArray *ary = mrb_ary_ptr(v);
+        size_t len = ary->len;
+        int i;
+
+        if (len > pre + post) {
+          regs[a++] = mrb_ary_new_elts(mrb, len - pre - post, ary->buf+pre);
+          while (post--) {
+            regs[a++] = ary->buf[len-post-1];
+          }
+        }
+        else {
+          regs[a++] = mrb_ary_new_capa(mrb, 0);
+          for (i=0; i+pre<len; i++) {
+            regs[a+i] = ary->buf[pre+i];
+          }
+          while (i < post) {
+            SET_NIL_VALUE(regs[a+i]);
+            i++;
+          }
+        }
       }
       NEXT;
     }
 
     CASE(OP_STRING) {
-      /* A Bx		R(A) := str_new(Lit(Bx)) */
+      /* A Bx           R(A) := str_new(Lit(Bx)) */
       regs[GETARG_A(i)] = mrb_str_literal(mrb, pool[GETARG_Bx(i)]);
       NEXT;
     }
 
     CASE(OP_STRCAT) {
-      /* A B	R(A).concat(R(B)) */
+      /* A B    R(A).concat(R(B)) */
       mrb_str_concat(mrb, regs[GETARG_A(i)], regs[GETARG_B(i)]);
       NEXT;
     }
@@ -1393,23 +1393,23 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       mrb_value hash = mrb_hash_new_capa(mrb, c);
 
       while (b < lim) {
-	mrb_hash_set(mrb, hash, regs[b], regs[b+1]);
-	b+=2;
+        mrb_hash_set(mrb, hash, regs[b], regs[b+1]);
+        b+=2;
       }
       regs[GETARG_A(i)] = hash;
       NEXT;
     }
 
     CASE(OP_LAMBDA) {
-      /* A b c	R(A) := lambda(SEQ[b],c) (b:c = 14:2) */
+      /* A b c  R(A) := lambda(SEQ[b],c) (b:c = 14:2) */
       struct RProc *p;
       int c = GETARG_c(i);
 
       if (c & OP_L_CAPTURE) {
-	p = mrb_closure_new(mrb, mrb->irep[irep->idx+GETARG_b(i)]);
+        p = mrb_closure_new(mrb, mrb->irep[irep->idx+GETARG_b(i)]);
       }
       else {
-	p = mrb_proc_new(mrb, mrb->irep[irep->idx+GETARG_b(i)]);
+        p = mrb_proc_new(mrb, mrb->irep[irep->idx+GETARG_b(i)]);
       }
       if (c & OP_L_STRICT) p->flags |= MRB_PROC_STRICT;
       regs[GETARG_A(i)] = mrb_obj_value(p);
@@ -1417,13 +1417,13 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     }
 
     CASE(OP_OCLASS) {
-      /* A	R(A) := ::Object */
+      /* A      R(A) := ::Object */
       regs[GETARG_A(i)] = mrb_obj_value(mrb->object_class);
       NEXT;
     }
 
     CASE(OP_CLASS) {
-      /* A B	R(A) := newclass(R(A),Sym(B),R(A+1)) */
+      /* A B    R(A) := newclass(R(A),Sym(B),R(A+1)) */
       struct RClass *c = 0;
       int a = GETARG_A(i);
       mrb_value base, super;
@@ -1432,7 +1432,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       base = regs[a];
       super = regs[a+1];
       if (mrb_nil_p(base)) {
-	base = mrb_obj_value(mrb->ci->target_class);
+        base = mrb_obj_value(mrb->ci->target_class);
       }
       c = mrb_vm_define_class(mrb, base, super, id);
       regs[a] = mrb_obj_value(c);
@@ -1440,7 +1440,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     }
 
     CASE(OP_MODULE) {
-      /* A B		R(A) := newmodule(R(A),Sym(B)) */
+      /* A B            R(A) := newmodule(R(A),Sym(B)) */
       struct RClass *c = 0;
       int a = GETARG_A(i);
       mrb_value base;
@@ -1448,7 +1448,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 
       base = regs[a];
       if (mrb_nil_p(base)) {
-	base = mrb_obj_value(mrb->ci->target_class);
+        base = mrb_obj_value(mrb->ci->target_class);
       }
       c = mrb_vm_define_module(mrb, base, id);
       regs[a] = mrb_obj_value(c);
@@ -1456,7 +1456,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     }
 
     CASE(OP_EXEC) {
-      /* A Bx	R(A) := blockexec(R(A),SEQ[Bx]) */
+      /* A Bx   R(A) := blockexec(R(A),SEQ[Bx]) */
       int a = GETARG_A(i);
       mrb_callinfo *ci;
       mrb_value recv = regs[a];
@@ -1476,29 +1476,29 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
       ci->proc = p;
 
       if (MRB_PROC_CFUNC_P(p)) {
-	mrb->stack[0] = p->body.func(mrb, recv);
-	mrb->arena_idx = ai;
-	if (mrb->exc) goto L_RAISE;
-	/* pop stackpos */
-	regs = mrb->stack = mrb->stbase + ci->stackidx;
-	cipop(mrb);
-	NEXT;
+        mrb->stack[0] = p->body.func(mrb, recv);
+        mrb->arena_idx = ai;
+        if (mrb->exc) goto L_RAISE;
+        /* pop stackpos */
+        regs = mrb->stack = mrb->stbase + ci->stackidx;
+        cipop(mrb);
+        NEXT;
       }
       else {
-	/* setup environment for calling method */
-	irep = p->body.irep;
-	pool = irep->pool;
-	syms = irep->syms;
-	mrb->stack += a;
-	stack_extend(mrb, irep->nregs, 1);
-	regs = mrb->stack;
-	pc = irep->iseq;
-	JUMP;
+        /* setup environment for calling method */
+        irep = p->body.irep;
+        pool = irep->pool;
+        syms = irep->syms;
+        mrb->stack += a;
+        stack_extend(mrb, irep->nregs, 1);
+        regs = mrb->stack;
+        pc = irep->iseq;
+        JUMP;
       }
     }
 
     CASE(OP_METHOD) {
-      /* A B		R(A).newmethod(Sym(B),R(A+1)) */
+      /* A B            R(A).newmethod(Sym(B),R(A+1)) */
       int a = GETARG_A(i);
       struct RClass *c = mrb_class_ptr(regs[a]);
 
@@ -1507,39 +1507,39 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
     }
 
     CASE(OP_SCLASS) {
-      /* A B	R(A) := R(B).singleton_class */
+      /* A B    R(A) := R(B).singleton_class */
       regs[GETARG_A(i)] = mrb_singleton_class(mrb, regs[GETARG_B(i)]);
       NEXT;
     }
 
     CASE(OP_TCLASS) {
-      /* A B	R(A) := target_class */
+      /* A B    R(A) := target_class */
       regs[GETARG_A(i)] = mrb_obj_value(mrb->ci->target_class);
       NEXT;
     }
 
     CASE(OP_RANGE) {
-      /* A B C	R(A) := range_new(R(B),R(B+1),C) */
+      /* A B C  R(A) := range_new(R(B),R(B+1),C) */
       int b = GETARG_B(i);
       regs[GETARG_A(i)] = mrb_range_new(mrb, regs[b], regs[b+1], GETARG_C(i));
       NEXT;
     }
 
     CASE(OP_DEBUG) {
-      /* A	debug print R(A),R(B),R(C) */
+      /* A      debug print R(A),R(B),R(C) */
       printf("OP_DEBUG %d %d %d\n", GETARG_A(i), GETARG_B(i), GETARG_C(i));
       NEXT;
     }
 
     CASE(OP_STOP) {
-      /* 	stop VM */
+      /*        stop VM */
     L_STOP:
       mrb->jmp = prev_jmp;
       return mrb_nil_value();
     }
 
     CASE(OP_ERR) {
-      /* Bx	raise RuntimeError with message Lit(Bx) */
+      /* Bx     raise RuntimeError with message Lit(Bx) */
       mrb_value msg = pool[GETARG_Bx(i)];
       mrb_value exc = mrb_exc_new3(mrb, mrb->eRuntimeError_class, msg);
 
diff --git a/src/vm_core.h b/src/vm_core.h
index 1fadffaee..46eb99969 100644
--- a/src/vm_core.h
+++ b/src/vm_core.h
@@ -1,6 +1,6 @@
 /*
 ** vm_core.h - RiteVM core
-** 
+**
 ** See Copyright Notice in mruby.h
 */
 
@@ -130,12 +130,12 @@ typedef struct mrb_compile_option_struct {
 } mrb_compile_option_t;
 
 struct iseq_inline_cache_entry {
-	mrb_value ic_vmstat;
-	mrb_value ic_class;
+        mrb_value ic_vmstat;
+        mrb_value ic_class;
     union {
-	mrb_value value;
-	mrb_method_entry_t *method;
-	long index;
+        mrb_value value;
+        mrb_method_entry_t *method;
+        long index;
     } ic_value;
 };
 
@@ -168,9 +168,9 @@ void mrb_objspace_free(struct mrb_objspace *);
 #endif
 
 typedef struct mrb_block_struct {
-    mrb_value self;			/* share with method frame if it's only block */
-    mrb_value *lfp;			/* share with method frame if it's only block */
-    mrb_value *dfp;			/* share with method frame if it's only block */
+    mrb_value self;                     /* share with method frame if it's only block */
+    mrb_value *lfp;                     /* share with method frame if it's only block */
+    mrb_value *dfp;                     /* share with method frame if it's only block */
     mrb_iseq_t *iseq;
     mrb_value proc;
 } mrb_block_t;
@@ -217,7 +217,7 @@ RUBY_EXTERN mrb_value mrb_mRubyVMFrozenCore;
 typedef struct {
     mrb_block_t block;
 
-    mrb_value envval;		/* for GC mark */
+    mrb_value envval;           /* for GC mark */
     mrb_value blockprocval;
     int safe_level;
     int is_from_method;
@@ -231,11 +231,11 @@ typedef struct {
     mrb_value *env;
     int env_size;
     int local_size;
-    mrb_value prev_envval;		/* for GC mark */
+    mrb_value prev_envval;              /* for GC mark */
     mrb_block_t block;
 } mrb_env_t;
 
-//#define GetBindingPtr(obj, ptr) 
+//#define GetBindingPtr(obj, ptr)
 //  GetCoreDataFromValue(obj, mrb_binding_t, ptr)
 
 //typedef struct {
@@ -330,7 +330,7 @@ void mrb_disable_interrupt(void);
 //int mrb_thread_method_id_and_class(mrb_thread_t *th, mrb_sym *idp, mrb_value *klassp);
 
 mrb_value mrb_vm_invoke_proc(mrb_thread_t *th, mrb_proc_t *proc, mrb_value self,
-			int argc, const mrb_value *argv, const mrb_block_t *blockptr);
+                        int argc, const mrb_value *argv, const mrb_block_t *blockptr);
 mrb_value mrb_vm_make_proc(mrb_thread_t *th, const mrb_block_t *block, mrb_value klass);
 mrb_value mrb_vm_make_env_object(mrb_thread_t *th, mrb_control_frame_t *cfp);
 
@@ -400,9 +400,9 @@ void mrb_thread_lock_destroy(mrb_thread_lock_t *);
 #define EXEC_EVENT_HOOK(th, flag, self, id, klass) do { \
     mrb_event_flag_t wait_event__ = th->event_flags; \
     if (UNLIKELY(wait_event__)) { \
-	if (wait_event__ & (flag | RUBY_EVENT_VM)) { \
-	    mrb_threadptr_exec_event_hooks(th, flag, self, id, klass); \
-	} \
+        if (wait_event__ & (flag | RUBY_EVENT_VM)) { \
+            mrb_threadptr_exec_event_hooks(th, flag, self, id, klass); \
+        } \
     } \
 } while (0)
 #endif