diff --git a/expat/xmltok/xmltok_impl.c b/expat/xmltok/xmltok_impl.c
index 44949238..0a5ebd7c 100755
--- a/expat/xmltok/xmltok_impl.c
+++ b/expat/xmltok/xmltok_impl.c
@@ -65,7 +65,7 @@ Contributor(s):
   case BT_DIGIT: \
   case BT_NAME: \
   case BT_MINUS: \
-    ptr += MINBPC; \
+    ptr += MINBPC(enc); \
     break; \
   CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \
   CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \
@@ -90,7 +90,7 @@ Contributor(s):
     } \
   case BT_NMSTRT: \
   case BT_HEX: \
-    ptr += MINBPC; \
+    ptr += MINBPC(enc); \
     break; \
   CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \
   CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \
@@ -111,26 +111,26 @@ int PREFIX(scanComment)(const ENCODING *enc, const char *ptr, const char *end,
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     while (ptr != end) {
       switch (BYTE_TYPE(enc, ptr)) {
       INVALID_CASES(ptr, nextTokPtr)
       case BT_MINUS:
-	if ((ptr += MINBPC) == end)
+	if ((ptr += MINBPC(enc)) == end)
 	  return XML_TOK_PARTIAL;
 	if (CHAR_MATCHES(enc, ptr, '-')) {
-	  if ((ptr += MINBPC) == end)
+	  if ((ptr += MINBPC(enc)) == end)
 	    return XML_TOK_PARTIAL;
 	  if (!CHAR_MATCHES(enc, ptr, '>')) {
 	    *nextTokPtr = ptr;
 	    return XML_TOK_INVALID;
 	  }
-	  *nextTokPtr = ptr + MINBPC;
+	  *nextTokPtr = ptr + MINBPC(enc);
 	  return XML_TOK_COMMENT;
 	}
 	break;
       default:
-	ptr += MINBPC;
+	ptr += MINBPC(enc);
 	break;
       }
     }
@@ -148,13 +148,13 @@ int PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
     return XML_TOK_PARTIAL;
   switch (BYTE_TYPE(enc, ptr)) {
   case BT_MINUS:
-    return PREFIX(scanComment)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_LSQB:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_COND_SECT_OPEN;
   case BT_NMSTRT:
   case BT_HEX:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     break;
   default:
     *nextTokPtr = ptr;
@@ -163,10 +163,10 @@ int PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
   while (ptr != end) {
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_PERCNT:
-      if (ptr + MINBPC == end)
+      if (ptr + MINBPC(enc) == end)
 	return XML_TOK_PARTIAL;
       /* don't allow <!ENTITY% foo "whatever"> */
-      switch (BYTE_TYPE(enc, ptr + MINBPC)) {
+      switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
       case BT_S: case BT_CR: case BT_LF: case BT_PERCNT:
 	*nextTokPtr = ptr;
 	return XML_TOK_INVALID;
@@ -177,7 +177,7 @@ int PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
       return XML_TOK_DECL_OPEN;
     case BT_NMSTRT:
     case BT_HEX:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     default:
       *nextTokPtr = ptr;
@@ -192,7 +192,7 @@ int PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end,
 {
   int upper = 0;
   *tokPtr = XML_TOK_PI;
-  if (end - ptr != MINBPC*3)
+  if (end - ptr != MINBPC(enc)*3)
     return 1;
   switch (BYTE_TO_ASCII(enc, ptr)) {
   case 'x':
@@ -203,7 +203,7 @@ int PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end,
   default:
     return 1;
   }
-  ptr += MINBPC;
+  ptr += MINBPC(enc);
   switch (BYTE_TO_ASCII(enc, ptr)) {
   case 'm':
     break;
@@ -213,7 +213,7 @@ int PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end,
   default:
     return 1;
   }
-  ptr += MINBPC;
+  ptr += MINBPC(enc);
   switch (BYTE_TO_ASCII(enc, ptr)) {
   case 'l':
     break;
@@ -253,21 +253,21 @@ int PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
 	*nextTokPtr = ptr;
 	return XML_TOK_INVALID;
       }
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       while (ptr != end) {
         switch (BYTE_TYPE(enc, ptr)) {
         INVALID_CASES(ptr, nextTokPtr)
 	case BT_QUEST:
-	  ptr += MINBPC;
+	  ptr += MINBPC(enc);
 	  if (ptr == end)
 	    return XML_TOK_PARTIAL;
 	  if (CHAR_MATCHES(enc, ptr, '>')) {
-	    *nextTokPtr = ptr + MINBPC;
+	    *nextTokPtr = ptr + MINBPC(enc);
 	    return tok;
 	  }
 	  break;
 	default:
-	  ptr += MINBPC;
+	  ptr += MINBPC(enc);
 	  break;
 	}
       }
@@ -277,11 +277,11 @@ int PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
 	*nextTokPtr = ptr;
 	return XML_TOK_INVALID;
       }
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr == end)
 	return XML_TOK_PARTIAL;
       if (CHAR_MATCHES(enc, ptr, '>')) {
-	*nextTokPtr = ptr + MINBPC;
+	*nextTokPtr = ptr + MINBPC(enc);
 	return tok;
       }
       /* fall through */
@@ -300,9 +300,9 @@ int PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr, const char *e
 {
   int i;
   /* CDATA[ */
-  if (end - ptr < 6 * MINBPC)
+  if (end - ptr < 6 * MINBPC(enc))
     return XML_TOK_PARTIAL;
-  for (i = 0; i < 6; i++, ptr += MINBPC) {
+  for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
     if (!CHAR_MATCHES(enc, ptr, "CDATA["[i])) {
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
@@ -318,47 +318,45 @@ int PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, const char *en
 {
   if (ptr == end)
     return XML_TOK_NONE;
-#if MINBPC > 1
-  {
+  if (MINBPC(enc) > 1) {
     size_t n = end - ptr;
-    if (n & (MINBPC - 1)) {
-      n &= ~(MINBPC - 1);
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
       if (n == 0)
 	return XML_TOK_PARTIAL;
       end = ptr + n;
     }
   }
-#endif
   switch (BYTE_TYPE(enc, ptr)) {
   case BT_RSQB:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_PARTIAL;
     if (!CHAR_MATCHES(enc, ptr, ']'))
       break;
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_PARTIAL;
     if (!CHAR_MATCHES(enc, ptr, '>')) {
-      ptr -= MINBPC;
+      ptr -= MINBPC(enc);
       break;
     }
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_CDATA_SECT_CLOSE;
   case BT_CR:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_PARTIAL;
     if (BYTE_TYPE(enc, ptr) == BT_LF)
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
     *nextTokPtr = ptr;
     return XML_TOK_DATA_NEWLINE;
   case BT_LF:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_DATA_NEWLINE;
   INVALID_CASES(ptr, nextTokPtr)
   default:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     break;
   }
   while (ptr != end) {
@@ -382,7 +380,7 @@ int PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, const char *en
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
   }
@@ -408,12 +406,12 @@ int PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, const char *end,
     switch (BYTE_TYPE(enc, ptr)) {
     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     case BT_S: case BT_CR: case BT_LF:
-      for (ptr += MINBPC; ptr != end; ptr += MINBPC) {
+      for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
 	switch (BYTE_TYPE(enc, ptr)) {
 	case BT_S: case BT_CR: case BT_LF:
 	  break;
 	case BT_GT:
-	  *nextTokPtr = ptr + MINBPC;
+	  *nextTokPtr = ptr + MINBPC(enc);
           return XML_TOK_END_TAG;
 	default:
 	  *nextTokPtr = ptr;
@@ -424,11 +422,11 @@ int PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, const char *end,
 #ifdef XMLNS
     case BT_COLON:
       /* no need to check qname syntax here, since end-tag must match exactly */
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
 #endif
     case BT_GT:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_END_TAG;
     default:
       *nextTokPtr = ptr;
@@ -453,13 +451,13 @@ int PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, const char *end
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
-    for (ptr += MINBPC; ptr != end; ptr += MINBPC) {
+    for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
       switch (BYTE_TYPE(enc, ptr)) {
       case BT_DIGIT:
       case BT_HEX:
 	break;
       case BT_SEMI:
-	*nextTokPtr = ptr + MINBPC;
+	*nextTokPtr = ptr + MINBPC(enc);
 	return XML_TOK_CHAR_REF;
       default:
 	*nextTokPtr = ptr;
@@ -478,7 +476,7 @@ int PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
 {
   if (ptr != end) {
     if (CHAR_MATCHES(enc, ptr, 'x'))
-      return PREFIX(scanHexCharRef)(enc, ptr + MINBPC, end, nextTokPtr);
+      return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_DIGIT:
       break;
@@ -486,12 +484,12 @@ int PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
-    for (ptr += MINBPC; ptr != end; ptr += MINBPC) {
+    for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
       switch (BYTE_TYPE(enc, ptr)) {
       case BT_DIGIT:
 	break;
       case BT_SEMI:
-	*nextTokPtr = ptr + MINBPC;
+	*nextTokPtr = ptr + MINBPC(enc);
 	return XML_TOK_CHAR_REF;
       default:
 	*nextTokPtr = ptr;
@@ -513,7 +511,7 @@ int PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
   switch (BYTE_TYPE(enc, ptr)) {
   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
   case BT_NUM:
-    return PREFIX(scanCharRef)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   default:
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
@@ -522,7 +520,7 @@ int PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
     switch (BYTE_TYPE(enc, ptr)) {
     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     case BT_SEMI:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_ENTITY_REF;
     default:
       *nextTokPtr = ptr;
@@ -551,7 +549,7 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
 	return XML_TOK_INVALID;
       }
       hadColon = 1;
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr == end)
 	return XML_TOK_PARTIAL;
       switch (BYTE_TYPE(enc, ptr)) {
@@ -566,7 +564,7 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
       for (;;) {
 	int t;
 
-	ptr += MINBPC;
+	ptr += MINBPC(enc);
 	if (ptr == end)
 	  return XML_TOK_PARTIAL;
 	t = BYTE_TYPE(enc, ptr);
@@ -591,7 +589,7 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
 #endif
 	for (;;) {
 	  
-	  ptr += MINBPC;
+	  ptr += MINBPC(enc);
 	  if (ptr == end)
 	    return XML_TOK_PARTIAL;
 	  open = BYTE_TYPE(enc, ptr);
@@ -607,7 +605,7 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
 	    return XML_TOK_INVALID;
 	  }
 	}
-	ptr += MINBPC;
+	ptr += MINBPC(enc);
 	/* in attribute value */
 	for (;;) {
 	  int t;
@@ -620,7 +618,7 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
 	  INVALID_CASES(ptr, nextTokPtr)
 	  case BT_AMP:
 	    {
-	      int tok = PREFIX(scanRef)(enc, ptr + MINBPC, end, &ptr);
+	      int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
 	      if (tok <= 0) {
 		if (tok == XML_TOK_INVALID)
 		  *nextTokPtr = ptr;
@@ -632,11 +630,11 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
 	    *nextTokPtr = ptr;
 	    return XML_TOK_INVALID;
 	  default:
-	    ptr += MINBPC;
+	    ptr += MINBPC(enc);
 	    break;
 	  }
 	}
-	ptr += MINBPC;
+	ptr += MINBPC(enc);
 	if (ptr == end)
 	  return XML_TOK_PARTIAL;
 	switch (BYTE_TYPE(enc, ptr)) {
@@ -654,7 +652,7 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
 	}
 	/* ptr points to closing quote */
 	for (;;) {
-	  ptr += MINBPC;
+	  ptr += MINBPC(enc);
 	  if (ptr == end)
 	    return XML_TOK_PARTIAL;
 	  switch (BYTE_TYPE(enc, ptr)) {
@@ -663,18 +661,18 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
 	    continue;
 	  case BT_GT:
           gt:
-	    *nextTokPtr = ptr + MINBPC;
+	    *nextTokPtr = ptr + MINBPC(enc);
 	    return XML_TOK_START_TAG_WITH_ATTS;
 	  case BT_SOL:
           sol:
-	    ptr += MINBPC;
+	    ptr += MINBPC(enc);
 	    if (ptr == end)
 	      return XML_TOK_PARTIAL;
 	    if (!CHAR_MATCHES(enc, ptr, '>')) {
 	      *nextTokPtr = ptr;
 	      return XML_TOK_INVALID;
 	    }
-	    *nextTokPtr = ptr + MINBPC;
+	    *nextTokPtr = ptr + MINBPC(enc);
 	    return XML_TOK_EMPTY_ELEMENT_WITH_ATTS;
 	  default:
 	    *nextTokPtr = ptr;
@@ -706,20 +704,20 @@ int PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
   switch (BYTE_TYPE(enc, ptr)) {
   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
   case BT_EXCL:
-    if ((ptr += MINBPC) == end)
+    if ((ptr += MINBPC(enc)) == end)
       return XML_TOK_PARTIAL;
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_MINUS:
-      return PREFIX(scanComment)(enc, ptr + MINBPC, end, nextTokPtr);
+      return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     case BT_LSQB:
-      return PREFIX(scanCdataSection)(enc, ptr + MINBPC, end, nextTokPtr);
+      return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     }
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   case BT_QUEST:
-    return PREFIX(scanPi)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_SOL:
-    return PREFIX(scanEndTag)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   default:
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
@@ -738,7 +736,7 @@ int PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
 	return XML_TOK_INVALID;
       }
       hadColon = 1;
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr == end)
 	return XML_TOK_PARTIAL;
       switch (BYTE_TYPE(enc, ptr)) {
@@ -751,7 +749,7 @@ int PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
 #endif
     case BT_S: case BT_CR: case BT_LF:
       {
-        ptr += MINBPC;
+        ptr += MINBPC(enc);
 	while (ptr != end) {
 	  switch (BYTE_TYPE(enc, ptr)) {
 	  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
@@ -760,7 +758,7 @@ int PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
 	  case BT_SOL:
 	    goto sol;
 	  case BT_S: case BT_CR: case BT_LF:
-	    ptr += MINBPC;
+	    ptr += MINBPC(enc);
 	    continue;
 	  default:
 	    *nextTokPtr = ptr;
@@ -772,18 +770,18 @@ int PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
       }
     case BT_GT:
     gt:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_START_TAG_NO_ATTS;
     case BT_SOL:
     sol:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr == end)
 	return XML_TOK_PARTIAL;
       if (!CHAR_MATCHES(enc, ptr, '>')) {
 	*nextTokPtr = ptr;
 	return XML_TOK_INVALID;
       }
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_EMPTY_ELEMENT_NO_ATTS;
     default:
       *nextTokPtr = ptr;
@@ -799,51 +797,49 @@ int PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
 {
   if (ptr == end)
     return XML_TOK_NONE;
-#if MINBPC > 1
-  {
+  if (MINBPC(enc) > 1) {
     size_t n = end - ptr;
-    if (n & (MINBPC - 1)) {
-      n &= ~(MINBPC - 1);
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
       if (n == 0)
 	return XML_TOK_PARTIAL;
       end = ptr + n;
     }
   }
-#endif
   switch (BYTE_TYPE(enc, ptr)) {
   case BT_LT:
-    return PREFIX(scanLt)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_AMP:
-    return PREFIX(scanRef)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_CR:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_TRAILING_CR;
     if (BYTE_TYPE(enc, ptr) == BT_LF)
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
     *nextTokPtr = ptr;
     return XML_TOK_DATA_NEWLINE;
   case BT_LF:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_DATA_NEWLINE;
   case BT_RSQB:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_TRAILING_RSQB;
     if (!CHAR_MATCHES(enc, ptr, ']'))
       break;
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_TRAILING_RSQB;
     if (!CHAR_MATCHES(enc, ptr, '>')) {
-      ptr -= MINBPC;
+      ptr -= MINBPC(enc);
       break;
     }
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   INVALID_CASES(ptr, nextTokPtr)
   default:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     break;
   }
   while (ptr != end) {
@@ -859,17 +855,17 @@ int PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
 #undef LEAD_CASE
     case BT_RSQB:
-      if (ptr + MINBPC != end) {
-	 if (!CHAR_MATCHES(enc, ptr + MINBPC, ']')) {
-	   ptr += MINBPC;
+      if (ptr + MINBPC(enc) != end) {
+	 if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ']')) {
+	   ptr += MINBPC(enc);
 	   break;
 	 }
-	 if (ptr + 2*MINBPC != end) {
-	   if (!CHAR_MATCHES(enc, ptr + 2*MINBPC, '>')) {
-	     ptr += MINBPC;
+	 if (ptr + 2*MINBPC(enc) != end) {
+	   if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), '>')) {
+	     ptr += MINBPC(enc);
 	     break;
 	   }
-	   *nextTokPtr = ptr + 2*MINBPC;
+	   *nextTokPtr = ptr + 2*MINBPC(enc);
 	   return XML_TOK_INVALID;
 	 }
       }
@@ -884,7 +880,7 @@ int PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
   }
@@ -913,7 +909,7 @@ int PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
     switch (BYTE_TYPE(enc, ptr)) {
     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     case BT_SEMI:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_PARAM_ENTITY_REF;
     default:
       *nextTokPtr = ptr;
@@ -961,7 +957,7 @@ int PREFIX(scanLit)(int open, const ENCODING *enc,
     INVALID_CASES(ptr, nextTokPtr)
     case BT_QUOT:
     case BT_APOS:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (t != open)
 	break;
       if (ptr == end)
@@ -975,7 +971,7 @@ int PREFIX(scanLit)(int open, const ENCODING *enc,
 	return XML_TOK_INVALID;
       }
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
   }
@@ -989,51 +985,49 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
   int tok;
   if (ptr == end)
     return XML_TOK_NONE;
-#if MINBPC > 1
-  {
+  if (MINBPC(enc) > 1) {
     size_t n = end - ptr;
-    if (n & (MINBPC - 1)) {
-      n &= ~(MINBPC - 1);
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
       if (n == 0)
 	return XML_TOK_PARTIAL;
       end = ptr + n;
     }
   }
-#endif
   switch (BYTE_TYPE(enc, ptr)) {
   case BT_QUOT:
-    return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_APOS:
-    return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_LT:
     {
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr == end)
 	return XML_TOK_PARTIAL;
       switch (BYTE_TYPE(enc, ptr)) {
       case BT_EXCL:
-	return PREFIX(scanDecl)(enc, ptr + MINBPC, end, nextTokPtr);
+	return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
       case BT_QUEST:
-	return PREFIX(scanPi)(enc, ptr + MINBPC, end, nextTokPtr);
+	return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
       case BT_NMSTRT:
       case BT_HEX:
       case BT_NONASCII:
       case BT_LEAD2:
       case BT_LEAD3:
       case BT_LEAD4:
-	*nextTokPtr = ptr - MINBPC;
+	*nextTokPtr = ptr - MINBPC(enc);
 	return XML_TOK_INSTANCE_START;
       }
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
   case BT_CR:
-    if (ptr + MINBPC == end)
+    if (ptr + MINBPC(enc) == end)
       return XML_TOK_TRAILING_CR;
     /* fall through */
   case BT_S: case BT_LF:
     for (;;) {
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr == end)
 	break;
       switch (BYTE_TYPE(enc, ptr)) {
@@ -1041,7 +1035,7 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
 	break;
       case BT_CR:
 	/* don't split CR/LF pair */
-	if (ptr + MINBPC != end)
+	if (ptr + MINBPC(enc) != end)
 	  break;
 	/* fall through */
       default:
@@ -1052,43 +1046,43 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
     *nextTokPtr = ptr;
     return XML_TOK_PROLOG_S;
   case BT_PERCNT:
-    return PREFIX(scanPercent)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_COMMA:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_COMMA;
   case BT_LSQB:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_OPEN_BRACKET;
   case BT_RSQB:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_PARTIAL;
     if (CHAR_MATCHES(enc, ptr, ']')) {
-      if (ptr + MINBPC == end)
+      if (ptr + MINBPC(enc) == end)
 	return XML_TOK_PARTIAL;
-      if (CHAR_MATCHES(enc, ptr + MINBPC, '>')) {
-	*nextTokPtr = ptr + 2*MINBPC;
+      if (CHAR_MATCHES(enc, ptr + MINBPC(enc), '>')) {
+	*nextTokPtr = ptr + 2*MINBPC(enc);
 	return XML_TOK_COND_SECT_CLOSE;
       }
     }
     *nextTokPtr = ptr;
     return XML_TOK_CLOSE_BRACKET;
   case BT_LPAR:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_OPEN_PAREN;
   case BT_RPAR:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_PARTIAL;
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_AST:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_CLOSE_PAREN_ASTERISK;
     case BT_QUEST:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_CLOSE_PAREN_QUESTION;
     case BT_PLUS:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_CLOSE_PAREN_PLUS;
     case BT_CR: case BT_LF: case BT_S:
     case BT_GT: case BT_COMMA: case BT_VERBAR:
@@ -1099,13 +1093,13 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   case BT_VERBAR:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_OR;
   case BT_GT:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_DECL_CLOSE;
   case BT_NUM:
-    return PREFIX(scanPoundName)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
 #define LEAD_CASE(n) \
   case BT_LEAD ## n: \
     if (end - ptr < n) \
@@ -1127,7 +1121,7 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
   case BT_NMSTRT:
   case BT_HEX:
     tok = XML_TOK_NAME;
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     break;
   case BT_DIGIT:
   case BT_NAME:
@@ -1136,16 +1130,16 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
   case BT_COLON:
 #endif
     tok = XML_TOK_NMTOKEN;
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     break;
   case BT_NONASCII:
     if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       tok = XML_TOK_NAME;
       break;
     }
     if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       tok = XML_TOK_NMTOKEN;
       break;
     }
@@ -1164,7 +1158,7 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
       return tok;
 #ifdef XMLNS
     case BT_COLON:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       switch (tok) {
       case XML_TOK_NAME:
 	if (ptr == end)
@@ -1188,21 +1182,21 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
 	*nextTokPtr = ptr;
 	return XML_TOK_INVALID;
       }
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_NAME_PLUS;
     case BT_AST:
       if (tok == XML_TOK_NMTOKEN)  {
 	*nextTokPtr = ptr;
 	return XML_TOK_INVALID;
       }
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_NAME_ASTERISK;
     case BT_QUEST:
       if (tok == XML_TOK_NMTOKEN)  {
 	*nextTokPtr = ptr;
 	return XML_TOK_INVALID;
       }
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_NAME_QUESTION;
     default:
       *nextTokPtr = ptr;
@@ -1228,7 +1222,7 @@ int PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *
 #undef LEAD_CASE
     case BT_AMP:
       if (ptr == start)
-	return PREFIX(scanRef)(enc, ptr + MINBPC, end, nextTokPtr);
+	return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_LT:
@@ -1237,18 +1231,18 @@ int PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *
       return XML_TOK_INVALID;
     case BT_LF:
       if (ptr == start) {
-	*nextTokPtr = ptr + MINBPC;
+	*nextTokPtr = ptr + MINBPC(enc);
 	return XML_TOK_DATA_NEWLINE;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_CR:
       if (ptr == start) {
-	ptr += MINBPC;
+	ptr += MINBPC(enc);
 	if (ptr == end)
 	  return XML_TOK_TRAILING_CR;
 	if (BYTE_TYPE(enc, ptr) == BT_LF)
-	  ptr += MINBPC;
+	  ptr += MINBPC(enc);
 	*nextTokPtr = ptr;
 	return XML_TOK_DATA_NEWLINE;
       }
@@ -1256,13 +1250,13 @@ int PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *
       return XML_TOK_DATA_CHARS;
     case BT_S:
       if (ptr == start) {
-	*nextTokPtr = ptr + MINBPC;
+	*nextTokPtr = ptr + MINBPC(enc);
 	return XML_TOK_ATTRIBUTE_VALUE_S;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
   }
@@ -1286,35 +1280,35 @@ int PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, const char *end
 #undef LEAD_CASE
     case BT_AMP:
       if (ptr == start)
-	return PREFIX(scanRef)(enc, ptr + MINBPC, end, nextTokPtr);
+	return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_PERCNT:
       if (ptr == start)
-	return PREFIX(scanPercent)(enc, ptr + MINBPC, end, nextTokPtr);
+	return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_LF:
       if (ptr == start) {
-	*nextTokPtr = ptr + MINBPC;
+	*nextTokPtr = ptr + MINBPC(enc);
 	return XML_TOK_DATA_NEWLINE;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_CR:
       if (ptr == start) {
-	ptr += MINBPC;
+	ptr += MINBPC(enc);
 	if (ptr == end)
 	  return XML_TOK_TRAILING_CR;
 	if (BYTE_TYPE(enc, ptr) == BT_LF)
-	  ptr += MINBPC;
+	  ptr += MINBPC(enc);
 	*nextTokPtr = ptr;
 	return XML_TOK_DATA_NEWLINE;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
   }
@@ -1326,9 +1320,9 @@ static
 int PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
 		       const char **badPtr)
 {
-  ptr += MINBPC;
-  end -= MINBPC;
-  for (; ptr != end; ptr += MINBPC) {
+  ptr += MINBPC(enc);
+  end -= MINBPC(enc);
+  for (; ptr != end; ptr += MINBPC(enc)) {
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_DIGIT:
     case BT_HEX:
@@ -1389,7 +1383,7 @@ int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
   int nAtts = 0;
   int open;
 
-  for (ptr += MINBPC;; ptr += MINBPC) {
+  for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
     switch (BYTE_TYPE(enc, ptr)) {
 #define START_NAME \
       if (state == other) { \
@@ -1400,7 +1394,7 @@ int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
 	state = inName; \
       }
 #define LEAD_CASE(n) \
-    case BT_LEAD ## n: START_NAME ptr += (n - MINBPC); break;
+    case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break;
     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
 #undef LEAD_CASE
     case BT_NONASCII:
@@ -1411,7 +1405,7 @@ int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
 #undef START_NAME
     case BT_QUOT:
       if (state != inValue) {
-	atts[nAtts].valuePtr = ptr + MINBPC;
+	atts[nAtts].valuePtr = ptr + MINBPC(enc);
         state = inValue;
         open = BT_QUOT;
       }
@@ -1422,7 +1416,7 @@ int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
       break;
     case BT_APOS:
       if (state != inValue) {
-	atts[nAtts].valuePtr = ptr + MINBPC;
+	atts[nAtts].valuePtr = ptr + MINBPC(enc);
         state = inValue;
         open = BT_APOS;
       }
@@ -1441,8 +1435,8 @@ int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
 	       && atts[nAtts].normalized
 	       && (ptr == atts[nAtts].valuePtr
 		   || BYTE_TO_ASCII(enc, ptr) != ' '
-		   || BYTE_TO_ASCII(enc, ptr + MINBPC) == ' '
-	           || BYTE_TYPE(enc, ptr + MINBPC) == open))
+		   || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ' '
+	           || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
 	atts[nAtts].normalized = 0;
       break;
     case BT_CR: case BT_LF:
@@ -1470,9 +1464,9 @@ int PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
 {
   int result = 0;
   /* skip &# */
-  ptr += 2*MINBPC;
+  ptr += 2*MINBPC(enc);
   if (CHAR_MATCHES(enc, ptr, 'x')) {
-    for (ptr += MINBPC; !CHAR_MATCHES(enc, ptr, ';'); ptr += MINBPC) {
+    for (ptr += MINBPC(enc); !CHAR_MATCHES(enc, ptr, ';'); ptr += MINBPC(enc)) {
       int c = BYTE_TO_ASCII(enc, ptr);
       switch (c) {
       case '0': case '1': case '2': case '3': case '4':
@@ -1494,7 +1488,7 @@ int PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
     }
   }
   else {
-    for (; !CHAR_MATCHES(enc, ptr, ';'); ptr += MINBPC) {
+    for (; !CHAR_MATCHES(enc, ptr, ';'); ptr += MINBPC(enc)) {
       int c = BYTE_TO_ASCII(enc, ptr);
       result *= 10;
       result += (c - '0');
@@ -1509,8 +1503,8 @@ static
 int PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr, const char *end)
 {
   switch (end - ptr) {
-  case 2 * MINBPC:
-    if (CHAR_MATCHES(enc, ptr + MINBPC, 't')) {
+  case 2 * MINBPC(enc):
+    if (CHAR_MATCHES(enc, ptr + MINBPC(enc), 't')) {
       switch (BYTE_TO_ASCII(enc, ptr)) {
       case 'l':
 	return '<';
@@ -1519,35 +1513,35 @@ int PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr, const cha
       }
     }
     break;
-  case 3 * MINBPC:
+  case 3 * MINBPC(enc):
     if (CHAR_MATCHES(enc, ptr, 'a')) {
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (CHAR_MATCHES(enc, ptr, 'm')) {
-	ptr += MINBPC;
+	ptr += MINBPC(enc);
 	if (CHAR_MATCHES(enc, ptr, 'p'))
 	  return '&';
       }
     }
     break;
-  case 4 * MINBPC:
+  case 4 * MINBPC(enc):
     switch (BYTE_TO_ASCII(enc, ptr)) {
     case 'q':
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (CHAR_MATCHES(enc, ptr, 'u')) {
-	ptr += MINBPC;
+	ptr += MINBPC(enc);
 	if (CHAR_MATCHES(enc, ptr, 'o')) {
-	  ptr += MINBPC;
+	  ptr += MINBPC(enc);
   	  if (CHAR_MATCHES(enc, ptr, 't'))
 	    return '"';
 	}
       }
       break;
     case 'a':
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (CHAR_MATCHES(enc, ptr, 'p')) {
-	ptr += MINBPC;
+	ptr += MINBPC(enc);
 	if (CHAR_MATCHES(enc, ptr, 'o')) {
-	  ptr += MINBPC;
+	  ptr += MINBPC(enc);
   	  if (CHAR_MATCHES(enc, ptr, 's'))
 	    return '\'';
 	}
@@ -1584,24 +1578,22 @@ int PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
     case BT_MINUS:
       if (*ptr2++ != *ptr1++)
 	return 0;
-#if MINBPC > 1
-      if (*ptr2++ != *ptr1++)
-	return 0;
-#if MINBPC > 2
-      if (*ptr2++ != *ptr1++)
-	return 0;
-#if MINBPC > 3
-      if (*ptr2++ != *ptr1++)
-	return 0;
-#endif
-#endif
-#endif
+      if (MINBPC(enc) > 1) {
+	if (*ptr2++ != *ptr1++)
+	  return 0;
+	if (MINBPC(enc) > 2) {
+	  if (*ptr2++ != *ptr1++)
+	    return 0;
+          if (MINBPC(enc) > 3) {
+	    if (*ptr2++ != *ptr1++)
+      	      return 0;
+	  }
+	}
+      }
       break;
     default:
-#if MINBPC == 1
-      if (*ptr1 == *ptr2)
+      if (MINBPC(enc) == 1 && *ptr1 == *ptr2)
 	return 1;
-#endif
       switch (BYTE_TYPE(enc, ptr2)) {
       case BT_LEAD2:
       case BT_LEAD3:
@@ -1627,7 +1619,7 @@ int PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
 static
 int PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1, const char *ptr2)
 {
-  for (; *ptr2; ptr1 += MINBPC, ptr2++) {
+  for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
     if (!CHAR_MATCHES(end, ptr1, *ptr2))
       return 0;
   }
@@ -1669,7 +1661,7 @@ int PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
     case BT_DIGIT:
     case BT_NAME:
     case BT_MINUS:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     default:
       return ptr - start;
@@ -1685,7 +1677,7 @@ const char *PREFIX(skipS)(const ENCODING *enc, const char *ptr)
     case BT_LF:
     case BT_CR:
     case BT_S:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     default:
       return ptr;
@@ -1710,17 +1702,17 @@ void PREFIX(updatePosition)(const ENCODING *enc,
     case BT_LF:
       pos->columnNumber = (unsigned)-1;
       pos->lineNumber++;
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     case BT_CR:
       pos->lineNumber++;
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)
-	ptr += MINBPC;
+	ptr += MINBPC(enc);
       pos->columnNumber = (unsigned)-1;
       break;
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
     pos->columnNumber++;