enclave 0.1.0

data/ext/enclave/mruby/mrbgems/mruby-pack/src/pack.c

@@ -0,0 +1,2129 @@
+/*
+ ** pack.c - Array#pack, String#unpack
+ */
+
+#include <mruby.h>
+#include <mruby/error.h>
+#include <mruby/array.h>
+#include <mruby/class.h>
+#include <mruby/numeric.h>
+#include <mruby/string.h>
+#include <mruby/variable.h>
+#include <mruby/endian.h>
+#include <mruby/internal.h>
+#include <mruby/presym.h>
+
+#include <ctype.h>
+#include <string.h>
+
+#define INT_OVERFLOW_P(n)  ((n) < MRB_INT_MIN || (n) > MRB_INT_MAX)
+#define UINT_OVERFLOW_P(n) ((n) > MRB_INT_MAX)
+
+#ifndef EOF
+# define EOF (-1) /* for MRB_NO_STDIO */
+#endif
+
+struct tmpl {
+  mrb_value str;
+  int idx;
+};
+
+enum pack_dir {
+  PACK_DIR_CHAR,      /* C */
+  PACK_DIR_SHORT,     /* S */
+  PACK_DIR_LONG,      /* L */
+  PACK_DIR_QUAD,      /* Q */
+  //PACK_DIR_INT,     /* i */
+  //PACK_DIR_VAX,
+  PACK_DIR_BER,       /* w */
+  PACK_DIR_UTF8,      /* U */
+  PACK_DIR_DOUBLE,    /* E */
+  PACK_DIR_FLOAT,     /* f */
+  PACK_DIR_STR,       /* A */
+  PACK_DIR_HEX,       /* h */
+  PACK_DIR_BSTR,      /* b */
+  PACK_DIR_BASE64,    /* m */
+  PACK_DIR_UU,        /* u */
+  PACK_DIR_QENC,      /* M */
+  PACK_DIR_NUL,       /* x */
+  PACK_DIR_BACK,      /* X */
+  PACK_DIR_ABS,       /* @ */
+  PACK_DIR_NONE,      /* - */
+};
+
+enum pack_type {
+  PACK_TYPE_INTEGER,
+  PACK_TYPE_FLOAT,
+  PACK_TYPE_STRING,
+  PACK_TYPE_NONE
+};
+
+#define PACK_FLAG_s             0x00000001      /* native size ("_" "!") */
+#define PACK_FLAG_a             0x00000002      /* null padding ("a") */
+#define PACK_FLAG_Z             0x00000004      /* append nul char ("z") */
+#define PACK_FLAG_SIGNED        0x00000008      /* native size ("_" "!") */
+#define PACK_FLAG_GT            0x00000010      /* big endian (">") */
+#define PACK_FLAG_LT            0x00000020      /* little endian ("<") */
+#define PACK_FLAG_WIDTH         0x00000040      /* "count" is "width" */
+#define PACK_FLAG_LSB           0x00000080      /* LSB / low nibble first */
+#define PACK_FLAG_COUNT2        0x00000100      /* "count" is special... */
+#define PACK_FLAG_LITTLEENDIAN  0x00000200      /* little endian actually */
+
+#define PACK_BASE64_IGNORE      0xff
+#define PACK_BASE64_PADDING     0xfe
+#define IGN                     PACK_BASE64_IGNORE
+#define PAD                     PACK_BASE64_PADDING
+
+static const unsigned char base64chars[64] = {
+  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+  'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+  'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+  'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/',
+};
+static const unsigned char base64_dec_tab[128] = {
+  IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN,
+  IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN,
+  IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN, IGN,  62, IGN, IGN, IGN,  63,
+   52,  53,  54,  55,  56,  57,  58,  59,  60,  61, IGN, IGN, IGN, PAD, IGN, IGN,
+  IGN,   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,
+   15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25, IGN, IGN, IGN, IGN, IGN,
+  IGN,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,
+   41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51, IGN, IGN, IGN, IGN, IGN,
+};
+
+/* lookup table for hex character to integer conversion */
+static const signed char hex_lookup[256] = {
+  /* 0x00-0x0F */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  /* 0x10-0x1F */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  /* 0x20-0x2F */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  /* 0x30-0x3F */  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
+  /* 0x40-0x4F */ -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  /* 0x50-0x5F */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  /* 0x60-0x6F */ -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  /* 0x70-0x7F */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  /* 0x80-0x8F */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  /* 0x90-0x9F */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  /* 0xA0-0xAF */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  /* 0xB0-0xBF */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  /* 0xC0-0xCF */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  /* 0xD0-0xDF */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  /* 0xE0-0xEF */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  /* 0xF0-0xFF */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+};
+/* byte index arrays for endianness optimization */
+static const int be_idx16[2] = {1, 0};          /* big-endian 16-bit: MSB, LSB */
+static const int le_idx16[2] = {0, 1};          /* little-endian 16-bit: LSB, MSB */
+static const int be_idx32[4] = {3, 2, 1, 0};    /* big-endian 32-bit: MSB...LSB */
+static const int le_idx32[4] = {0, 1, 2, 3};    /* little-endian 32-bit: LSB...MSB */
+static const int be_idx64[8] = {7, 6, 5, 4, 3, 2, 1, 0};  /* big-endian 64-bit: MSB...LSB */
+static const int le_idx64[8] = {0, 1, 2, 3, 4, 5, 6, 7};  /* little-endian 64-bit: LSB...MSB */
+/* lookup tables for binary string optimization */
+/* Convert character to bit value (0 or 1) */
+static inline uint8_t char_to_bit(unsigned char c) {
+  switch (c) {
+    case '0': return 0;
+    case '1': return 1;
+    default: return 0;
+  }
+}
+
+static const char bit_to_char[2] = {'0', '1'};
+
+/* 8-bit batch processing functions for binary strings */
+static inline uint8_t
+pack_8_bits_msb(const char *src)
+{
+  uint8_t result = 0;
+  result |= char_to_bit((uint8_t)src[0]) << 7;
+  result |= char_to_bit((uint8_t)src[1]) << 6;
+  result |= char_to_bit((uint8_t)src[2]) << 5;
+  result |= char_to_bit((uint8_t)src[3]) << 4;
+  result |= char_to_bit((uint8_t)src[4]) << 3;
+  result |= char_to_bit((uint8_t)src[5]) << 2;
+  result |= char_to_bit((uint8_t)src[6]) << 1;
+  result |= char_to_bit((uint8_t)src[7]);
+  return result;
+}
+
+static inline uint8_t
+pack_8_bits_lsb(const char *src)
+{
+  uint8_t result = 0;
+  result |= char_to_bit((uint8_t)src[0]);
+  result |= char_to_bit((uint8_t)src[1]) << 1;
+  result |= char_to_bit((uint8_t)src[2]) << 2;
+  result |= char_to_bit((uint8_t)src[3]) << 3;
+  result |= char_to_bit((uint8_t)src[4]) << 4;
+  result |= char_to_bit((uint8_t)src[5]) << 5;
+  result |= char_to_bit((uint8_t)src[6]) << 6;
+  result |= char_to_bit((uint8_t)src[7]) << 7;
+  return result;
+}
+
+static inline void
+unpack_8_bits_msb(uint8_t byte, char *dst)
+{
+  dst[0] = bit_to_char[(byte >> 7) & 1];
+  dst[1] = bit_to_char[(byte >> 6) & 1];
+  dst[2] = bit_to_char[(byte >> 5) & 1];
+  dst[3] = bit_to_char[(byte >> 4) & 1];
+  dst[4] = bit_to_char[(byte >> 3) & 1];
+  dst[5] = bit_to_char[(byte >> 2) & 1];
+  dst[6] = bit_to_char[(byte >> 1) & 1];
+  dst[7] = bit_to_char[byte & 1];
+}
+
+static inline void
+unpack_8_bits_lsb(uint8_t byte, char *dst)
+{
+  dst[0] = bit_to_char[byte & 1];
+  dst[1] = bit_to_char[(byte >> 1) & 1];
+  dst[2] = bit_to_char[(byte >> 2) & 1];
+  dst[3] = bit_to_char[(byte >> 3) & 1];
+  dst[4] = bit_to_char[(byte >> 4) & 1];
+  dst[5] = bit_to_char[(byte >> 5) & 1];
+  dst[6] = bit_to_char[(byte >> 6) & 1];
+  dst[7] = bit_to_char[(byte >> 7) & 1];
+}
+
+/* character classification for string format optimization */
+#define CHAR_NULL    0x01
+#define CHAR_SPACE   0x02
+
+/* Character classification function */
+static inline uint8_t char_class(unsigned char c) {
+  switch (c) {
+    case '\0': return CHAR_NULL;
+    case ' ':
+    case '\t':
+    case '\n':
+    case '\v':
+    case '\f':
+    case '\r': return CHAR_SPACE;
+    default: return 0;
+  }
+}
+/* UTF-8 optimization lookup tables */
+/* UTF-8 sequence length lookup table for non-ASCII bytes (0x80-0xFF) */
+/* Index = byte_value - 0x80, so table[0] = info for byte 0x80 */
+static const uint8_t utf8_seq_len_high[128] = {
+  /* 0x80-0xBF: Invalid start bytes (continuation bytes) - return 0 for error */
+  0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,
+
+  /* 0xC0-0xDF: 2-byte sequences */
+  2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,
+
+  /* 0xE0-0xEF: 3-byte sequences */
+  3,3,3,3,3,3,3,3, 3,3,3,3,3,3,3,3,
+
+  /* 0xF0-0xF7: 4-byte sequences */
+  4,4,4,4,4,4,4,4,
+
+  /* 0xF8-0xFF: Invalid start bytes - return 0 for error */
+  0,0,0,0,0,0,0,0
+};
+
+/* Fast validation for UTF-8 continuation bytes (0x80-0xBF) */
+/* Index = byte_value - 0x80 */
+static const uint8_t utf8_is_continuation[128] = {
+  /* 0x80-0xBF: Valid continuation bytes */
+  1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
+
+  /* 0xC0-0xFF: Invalid continuation bytes */
+  0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0
+};
+
+/* Helper macro for continuation byte validation */
+#define IS_UTF8_CONTINUATION(byte) \
+  ((byte) >= 0x80 && utf8_is_continuation[(byte) - 0x80])
+
+/* Quoted-printable optimization lookup table */
+/* 0=literal, 1=encode, 2=special (newline) */
+static const uint8_t qprint_encode_type[256] = {
+  /* 0x00-0x1F: Control characters - encode */
+  1,1,1,1,1,1,1,1, 1,0,2,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
+  /*     \t \n                      */
+
+  /* 0x20-0x3F: Printable ASCII */
+  0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,1,0,0,
+  /*                                                                 =   */
+
+  /* 0x40-0x5F: Printable ASCII */
+  0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,
+
+  /* 0x60-0x7F: Printable ASCII */
+  0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,1,
+  /*                                                                    DEL*/
+
+  /* 0x80-0xFF: High-bit characters - encode */
+  1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1
+};
+
+/* UU-encoding optimization lookup tables */
+/* UU-encoding uses 6-bit values mapped to ASCII 32-95, but space (32) -> backtick (96) */
+static const char uu_encode_table[64] = {
+  '`', '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/',
+  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?',
+  '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+  'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_'
+};
+
+/* UU-decoding lookup table for ASCII 32-127 */
+static const int8_t uu_decode_table[96] = {
+  /* ASCII 32-47: ` ! " # $ % & ' ( ) * + , - . / */
+  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
+  /* ASCII 48-63: 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */
+  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+  /* ASCII 64-79: @ A B C D E F G H I J K L M N O */
+  32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+  /* ASCII 80-95: P Q R S T U V W X Y Z [ \ ] ^ _ */
+  48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+  /* ASCII 96-127: ` a b c... (invalid for UU, but ` = 0 for decoding) */
+  0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+};
+
+/* template parsing optimization structures */
+typedef struct {
+  enum pack_dir dir;
+  enum pack_type type;
+  int size;
+  unsigned int base_flags;
+} format_info_t;
+
+/* Format character lookup function */
+static inline format_info_t pack_format_info(unsigned char c) {
+  switch (c) {
+    case 'A': return (format_info_t){PACK_DIR_STR, PACK_TYPE_STRING, 0, PACK_FLAG_WIDTH | PACK_FLAG_COUNT2};
+    case 'a': return (format_info_t){PACK_DIR_STR, PACK_TYPE_STRING, 0, PACK_FLAG_WIDTH | PACK_FLAG_COUNT2 | PACK_FLAG_a};
+    case 'B': return (format_info_t){PACK_DIR_BSTR, PACK_TYPE_STRING, 0, PACK_FLAG_COUNT2};
+    case 'b': return (format_info_t){PACK_DIR_BSTR, PACK_TYPE_STRING, 0, PACK_FLAG_COUNT2 | PACK_FLAG_LSB};
+    case 'C': return (format_info_t){PACK_DIR_CHAR, PACK_TYPE_INTEGER, 1, 0};
+    case 'c': return (format_info_t){PACK_DIR_CHAR, PACK_TYPE_INTEGER, 1, PACK_FLAG_SIGNED};
+    case 'D': return (format_info_t){PACK_DIR_DOUBLE, PACK_TYPE_FLOAT, 8, PACK_FLAG_SIGNED};
+    case 'd': return (format_info_t){PACK_DIR_DOUBLE, PACK_TYPE_FLOAT, 8, PACK_FLAG_SIGNED};
+    case 'E': return (format_info_t){PACK_DIR_DOUBLE, PACK_TYPE_FLOAT, 8, PACK_FLAG_SIGNED | PACK_FLAG_LT};
+    case 'e': return (format_info_t){PACK_DIR_FLOAT, PACK_TYPE_FLOAT, 4, PACK_FLAG_SIGNED | PACK_FLAG_LT};
+    case 'F': return (format_info_t){PACK_DIR_FLOAT, PACK_TYPE_FLOAT, 4, PACK_FLAG_SIGNED};
+    case 'f': return (format_info_t){PACK_DIR_FLOAT, PACK_TYPE_FLOAT, 4, PACK_FLAG_SIGNED};
+    case 'G': return (format_info_t){PACK_DIR_DOUBLE, PACK_TYPE_FLOAT, 8, PACK_FLAG_SIGNED | PACK_FLAG_GT};
+    case 'g': return (format_info_t){PACK_DIR_FLOAT, PACK_TYPE_FLOAT, 4, PACK_FLAG_SIGNED | PACK_FLAG_GT};
+    case 'H': return (format_info_t){PACK_DIR_HEX, PACK_TYPE_STRING, 0, PACK_FLAG_COUNT2};
+    case 'h': return (format_info_t){PACK_DIR_HEX, PACK_TYPE_STRING, 0, PACK_FLAG_COUNT2 | PACK_FLAG_LSB};
+    /* I, i, J, j are handled specially based on sizeof() */
+    case 'L': return (format_info_t){PACK_DIR_LONG, PACK_TYPE_INTEGER, 4, 0};
+    case 'l': return (format_info_t){PACK_DIR_LONG, PACK_TYPE_INTEGER, 4, PACK_FLAG_SIGNED};
+    case 'M': return (format_info_t){PACK_DIR_QENC, PACK_TYPE_STRING, 0, PACK_FLAG_WIDTH | PACK_FLAG_COUNT2};
+    case 'm': return (format_info_t){PACK_DIR_BASE64, PACK_TYPE_STRING, 0, PACK_FLAG_WIDTH | PACK_FLAG_COUNT2};
+    case 'N': return (format_info_t){PACK_DIR_LONG, PACK_TYPE_INTEGER, 4, PACK_FLAG_GT};
+    case 'n': return (format_info_t){PACK_DIR_SHORT, PACK_TYPE_INTEGER, 2, PACK_FLAG_GT};
+    case 'Q': return (format_info_t){PACK_DIR_QUAD, PACK_TYPE_INTEGER, 8, 0};
+    case 'q': return (format_info_t){PACK_DIR_QUAD, PACK_TYPE_INTEGER, 8, PACK_FLAG_SIGNED};
+    case 'S': return (format_info_t){PACK_DIR_SHORT, PACK_TYPE_INTEGER, 2, 0};
+    case 's': return (format_info_t){PACK_DIR_SHORT, PACK_TYPE_INTEGER, 2, PACK_FLAG_SIGNED};
+    case 'u': return (format_info_t){PACK_DIR_UU, PACK_TYPE_STRING, 0, PACK_FLAG_WIDTH | PACK_FLAG_COUNT2};
+    case 'U': return (format_info_t){PACK_DIR_UTF8, PACK_TYPE_INTEGER, 0, 0};
+    case 'V': return (format_info_t){PACK_DIR_LONG, PACK_TYPE_INTEGER, 4, PACK_FLAG_LT};
+    case 'v': return (format_info_t){PACK_DIR_SHORT, PACK_TYPE_INTEGER, 2, PACK_FLAG_LT};
+    case 'w': return (format_info_t){PACK_DIR_BER, PACK_TYPE_INTEGER, 0, PACK_FLAG_SIGNED};
+    case 'x': return (format_info_t){PACK_DIR_NUL, PACK_TYPE_NONE, 0, 0};
+    case 'X': return (format_info_t){PACK_DIR_BACK, PACK_TYPE_NONE, 0, 0};
+    case '@': return (format_info_t){PACK_DIR_ABS, PACK_TYPE_NONE, 0, 0};
+    case 'Z': return (format_info_t){PACK_DIR_STR, PACK_TYPE_STRING, 0, PACK_FLAG_WIDTH | PACK_FLAG_COUNT2 | PACK_FLAG_Z};
+    default: return (format_info_t){PACK_DIR_NONE, PACK_TYPE_NONE, 0, 0};
+  }
+}
+
+
+#define IS_PADDING_CHAR_A(c) (char_class((unsigned char)(c)) & (CHAR_NULL | CHAR_SPACE))
+#define IS_PADDING_CHAR_Z(c) (char_class((unsigned char)(c)) & CHAR_NULL)
+
+static int
+hex2int(unsigned char ch)
+{
+  return hex_lookup[ch];
+}
+
+static mrb_value
+str_len_ensure(mrb_state *mrb, mrb_value str, mrb_int len)
+{
+  mrb_int n = RSTRING_LEN(str);
+  if (len < 0) {
+    mrb_raise(mrb, E_RANGE_ERROR, "negative (or overflowed) integer");
+  }
+  if (len > n) {
+    do {
+      n *= 2;
+    } while (len > n);
+    str = mrb_str_resize(mrb, str, n);
+  }
+  return str;
+}
+
+
+static int
+pack_char(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags)
+{
+  str = str_len_ensure(mrb, str, sidx + 1);
+  RSTRING_PTR(str)[sidx] = (char)mrb_integer(o);
+  return 1;
+}
+
+static int
+unpack_char(mrb_state *mrb, const void *src, mrb_int srclen, mrb_value ary, unsigned int flags)
+{
+  if (flags & PACK_FLAG_SIGNED)
+    mrb_ary_push(mrb, ary, mrb_fixnum_value(*(signed char*)src));
+  else
+    mrb_ary_push(mrb, ary, mrb_fixnum_value(*(unsigned char*)src));
+  return 1;
+}
+
+static int
+pack_short(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags)
+{
+  str = str_len_ensure(mrb, str, sidx + 2);
+  uint16_t n = (uint16_t)mrb_integer(o);
+  char *dptr = RSTRING_PTR(str) + sidx;
+
+  /* use lookup tables to eliminate branching */
+  const int *idx = (flags & PACK_FLAG_LITTLEENDIAN) ? le_idx16 : be_idx16;
+  dptr[idx[0]] = (char)(n & 0xff);
+  dptr[idx[1]] = (char)(n >> 8);
+
+  return 2;
+}
+
+static int
+unpack_short(mrb_state *mrb, const unsigned char *src, mrb_int srclen, mrb_value ary, unsigned int flags)
+{
+  /* use lookup tables to eliminate branching */
+  const int *idx = (flags & PACK_FLAG_LITTLEENDIAN) ? le_idx16 : be_idx16;
+  int n = (src[idx[1]] << 8) | src[idx[0]];
+
+  if ((flags & PACK_FLAG_SIGNED) && (n >= 0x8000)) {
+    n -= 0x10000;
+  }
+  mrb_ary_push(mrb, ary, mrb_fixnum_value(n));
+  return 2;
+}
+
+static int
+pack_long(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags)
+{
+  str = str_len_ensure(mrb, str, sidx + 4);
+  uint32_t n = (uint32_t)mrb_integer(o);
+  char *dptr = RSTRING_PTR(str) + sidx;
+
+  /* use lookup tables to eliminate branching */
+  const int *idx = (flags & PACK_FLAG_LITTLEENDIAN) ? le_idx32 : be_idx32;
+  dptr[idx[0]] = (char)(n & 0xff);
+  dptr[idx[1]] = (char)(n >> 8);
+  dptr[idx[2]] = (char)(n >> 16);
+  dptr[idx[3]] = (char)(n >> 24);
+
+  return 4;
+}
+
+#ifndef MRB_INT64
+static void
+u32tostr(char *buf, size_t len, uint32_t n)
+{
+#ifdef MRB_NO_STDIO
+  char *bufend = buf + len;
+  char *p = bufend - 1;
+
+  if (len < 1) {
+    return;
+  }
+
+  *p-- = '\0';
+  len--;
+
+  if (n > 0) {
+    for (; len > 0 && n > 0; len --, n /= 10) {
+      *p -- = '0' + (n % 10);
+    }
+    p++;
+  }
+  else if (len > 0) {
+    *p = '0';
+    len--;
+  }
+
+  memmove(buf, p, bufend - p);
+#else
+  snprintf(buf, len, "%" PRIu32, n);
+#endif /* MRB_NO_STDIO */
+}
+#endif /* MRB_INT64 */
+
+static int
+unpack_long(mrb_state *mrb, const unsigned char *src, mrb_int srclen, mrb_value ary, unsigned int flags)
+{
+#ifndef MRB_INT64
+  char msg[60];
+#endif
+  uint32_t ul;
+  mrb_int n;
+
+  /* use lookup tables to eliminate branching */
+  const int *idx = (flags & PACK_FLAG_LITTLEENDIAN) ? le_idx32 : be_idx32;
+  ul = ((uint32_t)src[idx[3]] << 24) |
+       ((uint32_t)src[idx[2]] << 16) |
+       ((uint32_t)src[idx[1]] << 8) |
+       (uint32_t)src[idx[0]];
+
+  if (flags & PACK_FLAG_SIGNED) {
+    n = (int32_t)ul;
+  }
+  else {
+#ifndef MRB_INT64
+    if (UINT_OVERFLOW_P(ul)) {
+      u32tostr(msg, sizeof(msg), ul);
+      mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Integer: %s", msg);
+    }
+#endif
+    n = ul;
+  }
+  mrb_ary_push(mrb, ary, mrb_int_value(mrb, n));
+  return 4;
+}
+
+static int
+pack_quad(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags)
+{
+  str = str_len_ensure(mrb, str, sidx + 8);
+  uint64_t n = (uint64_t)mrb_integer(o);
+  char *dptr = RSTRING_PTR(str) + sidx;
+
+  /* use lookup tables to eliminate branching */
+  const int *idx = (flags & PACK_FLAG_LITTLEENDIAN) ? le_idx64 : be_idx64;
+  dptr[idx[0]] = (char)(n & 0xff);
+  dptr[idx[1]] = (char)(n >> 8);
+  dptr[idx[2]] = (char)(n >> 16);
+  dptr[idx[3]] = (char)(n >> 24);
+  dptr[idx[4]] = (char)(n >> 32);
+  dptr[idx[5]] = (char)(n >> 40);
+  dptr[idx[6]] = (char)(n >> 48);
+  dptr[idx[7]] = (char)(n >> 56);
+
+  return 8;
+}
+
+static void
+u64tostr(char *buf, size_t len, uint64_t n)
+{
+#ifdef MRB_NO_STDIO
+  mrb_assert(len > 0);
+
+  if (n < 10) {
+    buf[0] = '0' + n;
+    buf[1] = '\0';
+    return;
+  }
+
+  char *bufend = buf + len;
+  char *p = bufend - 1;
+
+  *p-- = '\0';
+  len--;
+
+  for (; len > 0 && n > 0; len--, n /= 10) {
+    *p-- = '0' + (n % 10);
+  }
+  p++;
+  memmove(buf, p, bufend - p);
+#else
+  snprintf(buf, len, "%" PRIu64, n);
+#endif /* MRB_NO_STDIO */
+}
+
+#ifndef MRB_INT64
+static void
+i64tostr(char *buf, size_t len, int64_t n)
+{
+#ifdef MRB_NO_STDIO
+  mrb_assert(len > 0);
+
+  if (n < 0) {
+    *buf++ = '-';
+    len--;
+    n = -n;
+  }
+
+  u64tostr(buf, len, (uint64_t)n);
+#else
+  snprintf(buf, len, "%" PRId64, n);
+#endif /* MRB_NO_STDIO */
+}
+#endif /* MRB_INT64 */
+
+static int
+unpack_quad(mrb_state *mrb, const unsigned char *src, mrb_int srclen, mrb_value ary, unsigned int flags)
+{
+  char msg[60];
+  mrb_int n;
+
+  /* use lookup tables to eliminate branching */
+  const int *idx = (flags & PACK_FLAG_LITTLEENDIAN) ? le_idx64 : be_idx64;
+  uint64_t ull = ((uint64_t)src[idx[7]] << 56) |
+                 ((uint64_t)src[idx[6]] << 48) |
+                 ((uint64_t)src[idx[5]] << 40) |
+                 ((uint64_t)src[idx[4]] << 32) |
+                 ((uint64_t)src[idx[3]] << 24) |
+                 ((uint64_t)src[idx[2]] << 16) |
+                 ((uint64_t)src[idx[1]] << 8) |
+                 (uint64_t)src[idx[0]];
+
+  if (flags & PACK_FLAG_SIGNED) {
+    int64_t sll = ull;
+#ifndef MRB_INT64
+    if (INT_OVERFLOW_P(sll)) {
+      i64tostr(msg, sizeof(msg), sll);
+      mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Integer: %s", msg);
+    }
+#endif
+    n = (mrb_int)sll;
+  }
+  else {
+    if (UINT_OVERFLOW_P(ull)) {
+      u64tostr(msg, sizeof(msg), ull);
+      mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Integer: %s", msg);
+    }
+    n = (mrb_int)ull;
+  }
+  mrb_ary_push(mrb, ary, mrb_int_value(mrb, n));
+  return 8;
+}
+
+static int
+pack_BER(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags)
+{
+  mrb_int n = mrb_integer(o);
+
+  if (n < 0) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "can't compress negative numbers");
+  }
+
+  /* fast path for 1-byte values (0-127) */
+  if (n < 128) {
+    str = str_len_ensure(mrb, str, sidx + 1);
+    RSTRING_PTR(str)[sidx] = (char)n;
+    return 1;
+  }
+
+  /* fast path for 2-byte values (128-16383) */
+  if (n < 16384) {
+    str = str_len_ensure(mrb, str, sidx + 2);
+    char *p = RSTRING_PTR(str) + sidx;
+    *p++ = (char)((n >> 7) | 0x80);
+    *p = (char)(n & 0x7f);
+    return 2;
+  }
+
+  /* original algorithm for larger values */
+  int i;
+  for (i = 1; i < (int)sizeof(mrb_int) + 1; i++) {
+    mrb_int mask = ~((1L << (7 * i)) - 1);
+    if ((n & mask) == 0) break;
+  }
+
+  str = str_len_ensure(mrb, str, sidx + i);
+  char *p = RSTRING_PTR(str) + sidx;
+
+  for (size_t j = i; j > 0; p++, j--) {
+    mrb_int x = (n >> (7 * (j - 1))) & 0x7f;
+    *p = (char)x;
+    if (j > 1) *p |= 0x80;
+  }
+
+  return i;
+}
+
+static int
+unpack_BER(mrb_state *mrb, const unsigned char *src, mrb_int srclen, mrb_value ary, unsigned int flags)
+{
+  mrb_int n = 0;
+  const unsigned char *p = src;
+  const unsigned char *e = p + srclen;
+
+  if (srclen == 0) return 0;
+
+  /* calculate maximum safe bytes before potential overflow */
+  const int max_safe_bytes = (sizeof(mrb_int) * 8 - 1) / 7;  /* conservative estimate */
+
+  int i;
+  for (i = 1; p < e; p++, i++) {
+    /* check overflow before we might exceed safe limits */
+    if (i > max_safe_bytes || n > (MRB_INT_MAX >> 7)) {
+      mrb_raise(mrb, E_RANGE_ERROR, "BER unpacking 'w' overflow");
+    }
+
+    n <<= 7;
+    n |= *p & 0x7f;
+    if ((*p & 0x80) == 0) break;
+  }
+
+  mrb_ary_push(mrb, ary, mrb_int_value(mrb, n));
+  return i;
+}
+
+#ifndef MRB_NO_FLOAT
+static int
+pack_double(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags)
+{
+  union {
+    double d;
+    uint64_t u;
+  } converter;
+
+  str = str_len_ensure(mrb, str, sidx + 8);
+  converter.d = mrb_float(o);
+  char *dptr = RSTRING_PTR(str) + sidx;
+
+  /* Use bit shifts for endian-independent byte extraction (same as pack_quad) */
+  uint64_t n = converter.u;
+  const int *idx = (flags & PACK_FLAG_LITTLEENDIAN) ? le_idx64 : be_idx64;
+  dptr[idx[0]] = (char)(n & 0xff);
+  dptr[idx[1]] = (char)((n >> 8) & 0xff);
+  dptr[idx[2]] = (char)((n >> 16) & 0xff);
+  dptr[idx[3]] = (char)((n >> 24) & 0xff);
+  dptr[idx[4]] = (char)((n >> 32) & 0xff);
+  dptr[idx[5]] = (char)((n >> 40) & 0xff);
+  dptr[idx[6]] = (char)((n >> 48) & 0xff);
+  dptr[idx[7]] = (char)((n >> 56) & 0xff);
+
+  return 8;
+}
+
+static int
+unpack_double(mrb_state *mrb, const unsigned char * src, mrb_int srclen, mrb_value ary, unsigned int flags)
+{
+  union {
+    double d;
+    uint64_t u;
+  } converter;
+
+  /* Use bit shifts for endian-independent byte assembly (same as unpack_quad) */
+  const int *idx = (flags & PACK_FLAG_LITTLEENDIAN) ? le_idx64 : be_idx64;
+  converter.u = ((uint64_t)src[idx[7]] << 56) |
+                ((uint64_t)src[idx[6]] << 48) |
+                ((uint64_t)src[idx[5]] << 40) |
+                ((uint64_t)src[idx[4]] << 32) |
+                ((uint64_t)src[idx[3]] << 24) |
+                ((uint64_t)src[idx[2]] << 16) |
+                ((uint64_t)src[idx[1]] << 8) |
+                ((uint64_t)src[idx[0]]);
+
+  mrb_ary_push(mrb, ary, mrb_float_value(mrb, converter.d));
+
+  return 8;
+}
+
+static int
+pack_float(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags)
+{
+  union {
+    float f;
+    uint32_t u;
+  } converter;
+
+  str = str_len_ensure(mrb, str, sidx + 4);
+  converter.f = (float)mrb_float(o);
+  char *dptr = RSTRING_PTR(str) + sidx;
+
+  /* Use bit shifts for endian-independent byte extraction (same as pack_long) */
+  uint32_t n = converter.u;
+  const int *idx = (flags & PACK_FLAG_LITTLEENDIAN) ? le_idx32 : be_idx32;
+  dptr[idx[0]] = (char)(n & 0xff);
+  dptr[idx[1]] = (char)((n >> 8) & 0xff);
+  dptr[idx[2]] = (char)((n >> 16) & 0xff);
+  dptr[idx[3]] = (char)((n >> 24) & 0xff);
+
+  return 4;
+}
+
+static int
+unpack_float(mrb_state *mrb, const unsigned char * src, mrb_int srclen, mrb_value ary, unsigned int flags)
+{
+  union {
+    float f;
+    uint32_t u;
+  } converter;
+
+  /* Use bit shifts for endian-independent byte assembly (same as unpack_long) */
+  const int *idx = (flags & PACK_FLAG_LITTLEENDIAN) ? le_idx32 : be_idx32;
+  converter.u = ((uint32_t)src[idx[3]] << 24) |
+                ((uint32_t)src[idx[2]] << 16) |
+                ((uint32_t)src[idx[1]] << 8) |
+                ((uint32_t)src[idx[0]]);
+
+  mrb_ary_push(mrb, ary, mrb_float_value(mrb, converter.f));
+
+  return 4;
+}
+#endif
+
+static int
+pack_utf8(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, int count, unsigned int flags)
+{
+  char utf8[4];
+  int len;
+  uint32_t c = (uint32_t)mrb_integer(o);
+
+  len = (int)mrb_utf8_to_buf(utf8, c);
+  if (len == 0) {
+    mrb_raise(mrb, E_RANGE_ERROR, "pack(U): value out of range");
+  }
+
+  str = str_len_ensure(mrb, str, sidx + len);
+  memcpy(RSTRING_PTR(str) + sidx, utf8, len);
+
+  return len;
+}
+
+
+
+static int
+unpack_utf8(mrb_state *mrb, const unsigned char * src, mrb_int srclen, mrb_value ary, unsigned int flags)
+{
+  if (srclen == 0) {
+    return 1;
+  }
+
+  const unsigned char *p = src;
+  uint8_t first_byte = *p;
+
+  /* ASCII fast path - most common case */
+  if (first_byte < 0x80) {
+    mrb_ary_push(mrb, ary, mrb_fixnum_value(first_byte));
+    return 1;
+  }
+
+  /* Multi-byte UTF-8 with optimized lookup table */
+  uint8_t seq_len = utf8_seq_len_high[first_byte - 0x80];
+  if (seq_len == 0 || seq_len > srclen) {
+    goto malformed;
+  }
+
+  /* Inline 2-byte sequence optimization - common case */
+  if (seq_len == 2) {
+    if (!IS_UTF8_CONTINUATION(p[1])) {
+      goto malformed;
+    }
+    uint32_t uv = ((first_byte & 0x1F) << 6) | (p[1] & 0x3F);
+    /* validate minimum value for 2-byte sequence */
+    if (uv >= 0x80) {
+      mrb_ary_push(mrb, ary, mrb_fixnum_value((mrb_int)uv));
+      return 2;
+    }
+    goto redundant;
+  }
+
+  /* Inline 3-byte sequence optimization */
+  if (seq_len == 3) {
+    if (!IS_UTF8_CONTINUATION(p[1]) || !IS_UTF8_CONTINUATION(p[2])) {
+      goto malformed;
+    }
+    uint32_t uv = ((first_byte & 0x0F) << 12) |
+                  ((p[1] & 0x3F) << 6) |
+                  (p[2] & 0x3F);
+    /* validate minimum value for 3-byte sequence */
+    if (uv >= 0x800) {
+      mrb_ary_push(mrb, ary, mrb_fixnum_value((mrb_int)uv));
+      return 3;
+    }
+    goto redundant;
+  }
+
+  /* 4-byte sequence - less common, use original implementation */
+  if (seq_len == 4) {
+    if (!IS_UTF8_CONTINUATION(p[1]) || !IS_UTF8_CONTINUATION(p[2]) || !IS_UTF8_CONTINUATION(p[3])) {
+      goto malformed;
+    }
+    uint32_t uv = ((first_byte & 0x07) << 18) |
+                  ((p[1] & 0x3F) << 12) |
+                  ((p[2] & 0x3F) << 6) |
+                  (p[3] & 0x3F);
+    /* validate minimum value and maximum valid Unicode */
+    if (uv >= 0x10000 && uv <= 0x10FFFF) {
+      mrb_ary_push(mrb, ary, mrb_fixnum_value((mrb_int)uv));
+      return 4;
+    }
+    if (uv < 0x10000) goto redundant;
+    goto malformed;
+  }
+
+malformed:
+  mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed UTF-8 character");
+
+redundant:
+  mrb_raise(mrb, E_ARGUMENT_ERROR, "redundant UTF-8 sequence");
+}
+
+static int
+pack_str(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, int count, unsigned int flags)
+{
+  const char *sptr = RSTRING_PTR(src);
+  mrb_int slen = RSTRING_LEN(src);
+  mrb_int copylen, padlen;
+  char pad;
+
+  /* determine padding character based on format */
+  if ((flags & PACK_FLAG_a) || (flags & PACK_FLAG_Z))
+    pad = '\0';
+  else
+    pad = ' ';
+
+  if (count == 0) {
+    return 0;
+  }
+  else if (count == -1) {
+    copylen = slen;
+    padlen = (flags & PACK_FLAG_Z) ? 1 : 0;
+  }
+  else if (count < slen) {
+    copylen = count;
+    padlen = 0;
+  }
+  else {
+    copylen = slen;
+    padlen = count - slen;
+  }
+
+  /* pre-allocate exact buffer size */
+  dst = str_len_ensure(mrb, dst, didx + copylen + padlen);
+  char *dptr = RSTRING_PTR(dst) + didx;
+  char *dptr0 = dptr;
+
+  /* copy string data */
+  if (copylen > 0) {
+    memcpy(dptr, sptr, copylen);
+    dptr += copylen;
+  }
+
+  /* bulk padding using memset instead of loop */
+  if (padlen > 0) {
+    memset(dptr, pad, padlen);
+    dptr += padlen;
+  }
+
+  return (int)(dptr - dptr0);
+}
+
+#define CHECK_UNPACK_LEN(mrb, slen, ary) do {\
+  if ((slen) <= 0) {\
+    mrb_ary_push(mrb, ary, mrb_str_new(mrb, 0, 0));\
+    return 0;\
+  }\
+} while (0)
+
+static int
+unpack_str(mrb_state *mrb, const void *src, mrb_int slen, mrb_value ary, int count, unsigned int flags)
+{
+  CHECK_UNPACK_LEN(mrb, slen, ary);
+
+  const char *sptr = (const char*)src;
+  int copylen;
+
+  if (count != -1 && count < slen) {
+    slen = count;
+  }
+  copylen = (int)slen;
+
+  if (slen >= 0 && flags & PACK_FLAG_Z) {  /* "Z" format */
+    const char *cp = (const char*)memchr(sptr, '\0', slen);
+    if (cp != NULL) {
+      copylen = (int)(cp - sptr);
+      if (count == -1) {
+        slen = copylen + 1;
+      }
+    }
+  }
+  else if (!(flags & PACK_FLAG_a)) {  /* "A" format - trim spaces and nulls */
+    /* optimized reverse trimming using lookup table */
+    while (copylen > 0 && IS_PADDING_CHAR_A(sptr[copylen - 1])) {
+      copylen--;
+    }
+  }
+  /* "a" format does no trimming */
+
+  if (copylen < 0) copylen = 0;
+
+  mrb_value dst = mrb_str_new(mrb, sptr, (mrb_int)copylen);
+  mrb_ary_push(mrb, ary, dst);
+  return (int)slen;
+}
+
+
+static int
+pack_hex(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, int count, unsigned int flags)
+{
+  char *sptr = RSTRING_PTR(src);
+  long slen = (long)RSTRING_LEN(src);
+
+  unsigned int ashift, bshift;
+  if (flags & PACK_FLAG_LSB) {
+    ashift = 0;
+    bshift = 4;
+  }
+  else {
+    ashift = 4;
+    bshift = 0;
+  }
+
+  if (count == -1) {
+    count = slen;
+  }
+  else if (slen > count) {
+    slen = count;
+  }
+
+  /* calculate output buffer size needed - one byte per two hex chars */
+  /* use count/2 + (count&1) to avoid overflow when count == INT_MAX */
+  int output_bytes = count / 2 + (count & 1);
+  dst = str_len_ensure(mrb, dst, didx + output_bytes);
+  char *dptr = RSTRING_PTR(dst) + didx;
+  char *dptr0 = dptr;
+
+  /* process pairs of hex characters */
+  while (slen >= 2) {
+    int a = hex2int((unsigned char)*sptr++);
+    if (a < 0) break;
+    int b = hex2int((unsigned char)*sptr++);
+    if (b < 0) break;
+
+    *dptr++ = (a << ashift) + (b << bshift);
+    slen -= 2;
+  }
+
+  /* handle odd remaining character */
+  if (slen > 0) {
+    int a = hex2int((unsigned char)*sptr);
+    if (a >= 0) {
+      *dptr++ = (a << ashift);
+    }
+  }
+
+  return (int)(dptr - dptr0);
+}
+
+static int
+unpack_hex(mrb_state *mrb, const void *src, mrb_int slen, mrb_value ary, int count, unsigned int flags)
+{
+  CHECK_UNPACK_LEN(mrb, slen, ary);
+
+  int ashift, bshift;
+  if (flags & PACK_FLAG_LSB) {
+    ashift = 0;
+    bshift = 4;
+  }
+  else {
+    ashift = 4;
+    bshift = 0;
+  }
+
+  const char *sptr = (const char*)src;
+  const char *sptr0 = sptr;
+
+  if (count == -1)
+    count = (int)(slen * 2);
+
+  mrb_value dst = mrb_str_new(mrb, NULL, count);
+  char *dptr = RSTRING_PTR(dst);
+  char *dptr0 = dptr;
+
+  const char hexadecimal[] = "0123456789abcdef";
+
+  /* process full bytes when we need pairs of hex characters */
+  while (slen > 0 && count >= 2) {
+    unsigned char byte = *sptr++;
+    slen--;
+
+    *dptr++ = hexadecimal[(byte >> ashift) & 0x0f];
+    *dptr++ = hexadecimal[(byte >> bshift) & 0x0f];
+    count -= 2;
+  }
+
+  /* handle remaining single character if count is odd */
+  if (slen > 0 && count > 0) {
+    unsigned char byte = *sptr++;
+    *dptr++ = hexadecimal[(byte >> ashift) & 0x0f];
+  }
+
+  dst = mrb_str_resize(mrb, dst, (mrb_int)(dptr - dptr0));
+  mrb_ary_push(mrb, ary, dst);
+  return (int)(sptr - sptr0);
+}
+
+static int
+pack_bstr(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, int count, unsigned int flags)
+{
+  const char *sptr = RSTRING_PTR(src);
+  int slen = (int)RSTRING_LEN(src);
+
+  if (count == -1) {
+    count = slen;
+  }
+  else if (slen > count) {
+    slen = count;
+  }
+
+  /* calculate exact output size: (slen + 7) / 8 */
+  int output_bytes = (slen + 7) / 8;
+  dst = str_len_ensure(mrb, dst, didx + output_bytes);
+  char *dptr = RSTRING_PTR(dst) + didx;
+  char *dptr0 = dptr;
+
+  /* select batch processing function based on bit order */
+  uint8_t (*pack_func)(const char *) = (flags & PACK_FLAG_LSB) ? pack_8_bits_lsb : pack_8_bits_msb;
+
+  /* process 8 characters at a time */
+  int full_bytes = slen / 8;
+  for (int i = 0; i < full_bytes; i++) {
+    *dptr++ = (char)pack_func(sptr);
+    sptr += 8;
+  }
+
+  /* handle remaining bits (partial byte) */
+  int remaining_bits = slen % 8;
+  if (remaining_bits > 0) {
+    char temp_chars[8] = {'0', '0', '0', '0', '0', '0', '0', '0'};
+    /* copy remaining characters, padding with '0' */
+    for (int i = 0; i < remaining_bits; i++) {
+      temp_chars[i] = sptr[i];
+    }
+    *dptr++ = (char)pack_func(temp_chars);
+  }
+
+  return (int)(dptr - dptr0);
+}
+
+static int
+unpack_bstr(mrb_state *mrb, const void *src, mrb_int slen, mrb_value ary, int count, unsigned int flags)
+{
+  CHECK_UNPACK_LEN(mrb, slen, ary);
+
+  const char *sptr0 = (const char*)src;
+  const char *sptr = sptr0;
+
+  if (count == -1 || count > slen * 8)
+    count = (int)(slen * 8);
+
+  /* pre-allocate exact output size */
+  mrb_value dst = mrb_str_new(mrb, NULL, count);
+  char *dptr = RSTRING_PTR(dst);
+  char *dptr0 = dptr;
+
+  /* select batch processing function based on bit order */
+  void (*unpack_func)(uint8_t, char *) = (flags & PACK_FLAG_LSB) ? unpack_8_bits_lsb : unpack_8_bits_msb;
+
+  /* process 8 bits (1 byte) at a time */
+  int full_bytes = count / 8;
+  for (int i = 0; i < full_bytes; i++) {
+    unpack_func((uint8_t)*sptr++, dptr);
+    dptr += 8;
+  }
+
+  /* handle remaining bits (partial byte) */
+  int remaining_bits = count % 8;
+  if (remaining_bits > 0) {
+    char temp_chars[8];
+    unpack_func((uint8_t)*sptr++, temp_chars);
+    /* copy only the required number of characters */
+    for (int i = 0; i < remaining_bits; i++) {
+      *dptr++ = temp_chars[i];
+    }
+  }
+
+  /* ensure string is properly sized */
+  dst = mrb_str_resize(mrb, dst, (mrb_int)(dptr - dptr0));
+  mrb_ary_push(mrb, ary, dst);
+  return (int)(sptr - sptr0);
+}
+
+static int
+pack_base64(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, int count)
+{
+  char *srcptr = RSTRING_PTR(src);
+  mrb_int srclen = RSTRING_LEN(src);
+
+  if (srclen == 0) {
+    return 0;
+  }
+
+  if (count != 0 && count < 3) {
+    count = 45;
+  }
+  else if (count >= 3) {
+    count -= count % 3;
+  }
+
+  /* precise memory allocation */
+  mrb_int dstlen = (srclen + 2) / 3 * 4;
+  if (count > 0) {
+    dstlen += (srclen / count) + ((srclen % count) == 0 ? 0 : 1);
+  }
+  dst = str_len_ensure(mrb, dst, didx + dstlen);
+  char *dstptr = RSTRING_PTR(dst) + didx;
+  char *dstptr0 = dstptr;
+
+  if (count == 0) {
+    /* fast path: no line wrapping */
+    while (srclen >= 3) {
+      unsigned long l = (unsigned char)*srcptr++ << 16;
+      l += (unsigned char)*srcptr++ << 8;
+      l += (unsigned char)*srcptr++;
+      srclen -= 3;
+
+      *dstptr++ = base64chars[(l >> 18) & 0x3f];
+      *dstptr++ = base64chars[(l >> 12) & 0x3f];
+      *dstptr++ = base64chars[(l >> 6) & 0x3f];
+      *dstptr++ = base64chars[l & 0x3f];
+    }
+  }
+  else {
+    /* line wrapping path */
+    mrb_int column = 3;
+    while (srclen >= 3) {
+      unsigned long l = (unsigned char)*srcptr++ << 16;
+      l += (unsigned char)*srcptr++ << 8;
+      l += (unsigned char)*srcptr++;
+      srclen -= 3;
+
+      *dstptr++ = base64chars[(l >> 18) & 0x3f];
+      *dstptr++ = base64chars[(l >> 12) & 0x3f];
+      *dstptr++ = base64chars[(l >> 6) & 0x3f];
+      *dstptr++ = base64chars[l & 0x3f];
+
+      if (column == count) {
+        *dstptr++ = '\n';
+        column = 0;
+      }
+      column += 3;
+    }
+
+    /* handle remaining 1-2 bytes */
+    if (srclen == 1) {
+      unsigned long l = (unsigned char)*srcptr << 16;
+      *dstptr++ = base64chars[(l >> 18) & 0x3f];
+      *dstptr++ = base64chars[(l >> 12) & 0x3f];
+      *dstptr++ = '=';
+      *dstptr++ = '=';
+      column += 3;
+    }
+    else if (srclen == 2) {
+      unsigned long l = (unsigned char)*srcptr++ << 16;
+      l += (unsigned char)*srcptr << 8;
+      *dstptr++ = base64chars[(l >> 18) & 0x3f];
+      *dstptr++ = base64chars[(l >> 12) & 0x3f];
+      *dstptr++ = base64chars[(l >> 6) & 0x3f];
+      *dstptr++ = '=';
+      column += 3;
+    }
+
+    if (column > 0) {
+      *dstptr++ = '\n';
+    }
+    return (int)(dstptr - dstptr0);
+  }
+
+  /* handle remaining 1-2 bytes for fast path */
+  if (srclen == 1) {
+    unsigned long l = (unsigned char)*srcptr << 16;
+    *dstptr++ = base64chars[(l >> 18) & 0x3f];
+    *dstptr++ = base64chars[(l >> 12) & 0x3f];
+    *dstptr++ = '=';
+    *dstptr++ = '=';
+  }
+  else if (srclen == 2) {
+    unsigned long l = (unsigned char)*srcptr++ << 16;
+    l += (unsigned char)*srcptr << 8;
+    *dstptr++ = base64chars[(l >> 18) & 0x3f];
+    *dstptr++ = base64chars[(l >> 12) & 0x3f];
+    *dstptr++ = base64chars[(l >> 6) & 0x3f];
+    *dstptr++ = '=';
+  }
+
+  return (int)(dstptr - dstptr0);
+}
+
+static int
+unpack_base64(mrb_state *mrb, const void *src, mrb_int slen, mrb_value ary)
+{
+  CHECK_UNPACK_LEN(mrb, slen, ary);
+
+  const char *sptr0 = (const char*)src;
+  const char *sptr = sptr0;
+
+  /* estimate buffer size - may be shorter due to padding/whitespace */
+  int dlen = (int)(slen / 4 * 3);
+  mrb_value dst = mrb_str_new(mrb, NULL, dlen);
+  char *dptr0 = RSTRING_PTR(dst);
+  char *dptr = dptr0;
+
+  int padding = 0;
+  while (slen >= 4) {
+    unsigned char ch[4];
+
+    /* collect 4 valid base64 characters */
+    for (int i = 0; i < 4; i++) {
+      unsigned char c;
+      do {
+        if (slen-- == 0)
+          goto done;
+        c = *sptr++;
+        if (c >= sizeof(base64_dec_tab))
+          continue;
+        ch[i] = base64_dec_tab[c];
+        if (ch[i] == PACK_BASE64_PADDING) {
+          ch[i] = 0;
+          padding++;
+        }
+      } while (c >= sizeof(base64_dec_tab) || ch[i] == PACK_BASE64_IGNORE);
+    }
+
+    /* decode 4 characters to 3 bytes */
+    unsigned long l = (ch[0] << 18) + (ch[1] << 12) + (ch[2] << 6) + ch[3];
+
+    if (padding == 0) {
+      *dptr++ = (l >> 16) & 0xff;
+      *dptr++ = (l >> 8) & 0xff;
+      *dptr++ = l & 0xff;
+    }
+    else if (padding == 1) {
+      *dptr++ = (l >> 16) & 0xff;
+      *dptr++ = (l >> 8) & 0xff;
+      break;
+    }
+    else {
+      *dptr++ = (l >> 16) & 0xff;
+      break;
+    }
+  }
+
+done:
+  dst = mrb_str_resize(mrb, dst, (mrb_int)(dptr - dptr0));
+  mrb_ary_push(mrb, ary, dst);
+  return (int)(sptr - sptr0);
+}
+
+static int
+pack_qenc(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, int count)
+{
+  static const char hex_table[] = "0123456789ABCDEF";
+  char buff[1024];
+  char *s = RSTRING_PTR(src);
+  char *send = s + RSTRING_LEN(src);
+  int i = 0, n = 0, prev = EOF;
+  int dlen = 0;
+
+  if (count <= 1) count = 72;
+
+  while (s < send) {
+    unsigned char byte = (unsigned char)*s;
+    uint8_t encode_type = qprint_encode_type[byte];
+
+    /* ASCII printable fast path - most common case */
+    if (encode_type == 0) {
+      /* Handle space/tab at line end special case */
+      if ((byte == ' ' || byte == '\t') && s + 1 < send && *(s + 1) == '\n') {
+        /* Space/tab before newline needs encoding */
+        buff[i++] = '=';
+        buff[i++] = hex_table[(byte & 0xf0) >> 4];
+        buff[i++] = hex_table[byte & 0x0f];
+        n += 3;
+        prev = EOF;
+      }
+      else {
+        /* Regular printable character - direct copy */
+        buff[i++] = byte;
+        n++;
+        prev = byte;
+      }
+    }
+    /* Newline special handling */
+    else if (encode_type == 2) {
+      if (prev == ' ' || prev == '\t') {
+        buff[i++] = '=';
+        buff[i++] = byte;
+      }
+      buff[i++] = byte;
+      n = 0;
+      prev = byte;
+    }
+    /* Character needs encoding */
+    else {
+      buff[i++] = '=';
+      buff[i++] = hex_table[(byte & 0xf0) >> 4];
+      buff[i++] = hex_table[byte & 0x0f];
+      n += 3;
+      prev = EOF;
+    }
+
+    /* Check line length limit */
+    if (n > count) {
+      buff[i++] = '=';
+      buff[i++] = '\n';
+      n = 0;
+      prev = '\n';
+    }
+
+    /* Flush buffer if getting full */
+    if (i > 1024 - 5) {
+      str_len_ensure(mrb, dst, didx+dlen+i);
+      memcpy(RSTRING_PTR(dst)+didx+dlen, buff, i);
+      dlen += i;
+      i = 0;
+    }
+    s++;
+  }
+
+  /* Add final soft line break if needed */
+  if (n > 0) {
+    buff[i++] = '=';
+    buff[i++] = '\n';
+  }
+
+  /* Flush remaining buffer */
+  if (i > 0) {
+    str_len_ensure(mrb, dst, didx+dlen+i);
+    memcpy(RSTRING_PTR(dst)+didx+dlen, buff, i);
+    dlen += i;
+  }
+
+  return dlen;
+}
+
+static int
+unpack_qenc(mrb_state *mrb, const void *src, mrb_int slen, mrb_value ary)
+{
+  CHECK_UNPACK_LEN(mrb, slen, ary);
+
+  mrb_value buf = mrb_str_new(mrb, 0, slen);
+  const char *s = (const char*)src;
+  const char *send = s + slen;
+  char *ptr = RSTRING_PTR(buf);
+  int c1, c2;
+
+  while (s < send) {
+    /* Fast path for non-encoded characters - most common case */
+    if (*s != '=') {
+      *ptr++ = *s;
+      s++;
+      continue;
+    }
+
+    /* Handle =XX encoded sequences */
+    if (++s == send) break;
+
+    /* Handle soft line breaks: =\r\n or =\n */
+    if (s + 1 < send && *s == '\r' && *(s + 1) == '\n') {
+      s += 2;  /* Skip \r\n */
+      continue;
+    }
+    if (*s == '\n') {
+      s++;     /* Skip \n */
+      continue;
+    }
+
+    /* Decode =XX hex sequence */
+    if ((c1 = hex2int(*s)) == -1) break;
+    if (++s == send) break;
+    if ((c2 = hex2int(*s)) == -1) break;
+    *ptr++ = (char)(c1 << 4 | c2);
+    s++;
+  }
+
+  buf = mrb_str_resize(mrb, buf, (mrb_int)(ptr - RSTRING_PTR(buf)));
+  mrb_ary_push(mrb, ary, buf);
+  return (int)slen;
+}
+
+static int
+pack_uu(mrb_state *mrb, mrb_value src, mrb_value dst, mrb_int didx, int count)
+{
+  char *s = RSTRING_PTR(src);
+  int slen = (int)RSTRING_LEN(src);
+  int lines_written = 0;
+  int dlen = 0;
+
+  if (count <= 1) count = 45; /* default line length for UU-encoding */
+
+  /* Calculate buffer size by accounting for per-line encoding
+   * Each line encodes separately, so padding happens per line, not globally
+   */
+  mrb_int num_lines = (slen + count - 1) / count;  /* Number of lines */
+  mrb_int total_encoded = 0;
+  mrb_int temp_slen = slen;
+
+  /* Calculate actual encoded size line by line */
+  while (temp_slen > 0) {
+    mrb_int line_len = (temp_slen > count) ? count : temp_slen;
+    total_encoded += ((line_len + 2) / 3) * 4;  /* Each line's encoded size */
+    temp_slen -= line_len;
+  }
+
+  /* Total buffer = encoded data + (length char + newline) per line + terminating line */
+  mrb_int buffer_size = total_encoded + num_lines * 2 + 2;
+  str_len_ensure(mrb, dst, didx + buffer_size);
+  char *dptr = RSTRING_PTR(dst) + didx;
+
+  while (slen > 0) {
+    int line_len = (slen > count) ? count : slen;
+
+    /* Write line length character */
+    *dptr++ = uu_encode_table[line_len & 0x3F];
+    dlen++;
+
+    int processed = 0;
+    while (processed < line_len) {
+      /* Process groups of 3 bytes -> 4 characters */
+      uint32_t group = 0;
+      int bytes_in_group = 0;
+
+      /* Read up to 3 bytes */
+      for (int i = 0; i < 3 && processed < line_len; i++) {
+        group = (group << 8) | (unsigned char)s[processed++];
+        bytes_in_group++;
+      }
+
+      /* Pad incomplete group with zeros */
+      group <<= (3 - bytes_in_group) * 8;
+
+      /* Extract 4 groups of 6 bits and encode */
+      *dptr++ = uu_encode_table[(group >> 18) & 0x3F];
+      *dptr++ = uu_encode_table[(group >> 12) & 0x3F];
+      *dptr++ = uu_encode_table[(group >> 6) & 0x3F];
+      *dptr++ = uu_encode_table[group & 0x3F];
+      dlen += 4;
+    }
+
+    /* Add newline */
+    *dptr++ = '\n';
+    dlen++;
+
+    s += line_len;
+    slen -= line_len;
+    lines_written++;
+  }
+
+  /* Add terminating line if data was processed */
+  if (lines_written > 0) {
+    *dptr++ = uu_encode_table[0]; /* length 0 */
+    *dptr++ = '\n';
+    dlen += 2;
+  }
+
+  return dlen;
+}
+
+static int
+unpack_uu(mrb_state *mrb, const void *src, mrb_int slen, mrb_value ary)
+{
+  const unsigned char *s = (const unsigned char*)src;
+  const unsigned char *send = s + slen;
+  mrb_value result = mrb_str_new(mrb, 0, slen * 3 / 4); /* estimate result size */
+  char *dptr = RSTRING_PTR(result);
+  char *dptr_start = dptr;
+
+  while (s < send) {
+    /* Skip empty lines and whitespace */
+    while (s < send && (*s == '\n' || *s == '\r' || *s == ' ' || *s == '\t')) {
+      s++;
+    }
+    if (s >= send) break;
+
+    /* Read line length */
+    int line_len = 0;
+    if (*s >= 32 && *s < 128 && uu_decode_table[*s - 32] >= 0) {
+      line_len = uu_decode_table[*s - 32];
+      s++;
+    }
+    else {
+      break; /* Invalid length character */
+    }
+
+    /* Empty line indicates end */
+    if (line_len == 0) {
+      break;
+    }
+
+    /* Decode line data */
+    int bytes_decoded = 0;
+    while (bytes_decoded < line_len && s + 3 < send) {
+      /* Decode 4 characters to 3 bytes */
+      int c[4];
+      int valid = 1;
+
+      for (int i = 0; i < 4; i++) {
+        if (s >= send || *s < 32 || *s >= 128 || uu_decode_table[*s - 32] < 0) {
+          valid = 0;
+          break;
+        }
+        c[i] = uu_decode_table[*s++ - 32];
+      }
+
+      if (!valid) break;
+
+      /* Combine 4 x 6-bit values into 3 x 8-bit values */
+      uint32_t group = (c[0] << 18) | (c[1] << 12) | (c[2] << 6) | c[3];
+
+      /* Extract up to 3 bytes, don't exceed line length */
+      int bytes_to_extract = (line_len - bytes_decoded > 3) ? 3 : (line_len - bytes_decoded);
+
+      for (int i = 0; i < bytes_to_extract; i++) {
+        *dptr++ = (group >> (16 - i * 8)) & 0xFF;
+        bytes_decoded++;
+      }
+    }
+
+    /* Skip to end of line */
+    while (s < send && *s != '\n' && *s != '\r') {
+      s++;
+    }
+  }
+
+  result = mrb_str_resize(mrb, result, (mrb_int)(dptr - dptr_start));
+  mrb_ary_push(mrb, ary, result);
+  return (int)slen;
+}
+
+static int
+pack_nul(mrb_state *mrb, mrb_value dst, mrb_int didx, int count)
+{
+  long i;
+
+  dst = str_len_ensure(mrb, dst, didx + count);
+  for (i = 0; i < count; i++) {
+    RSTRING_PTR(dst)[didx + i] = '\0';
+  }
+  return count;
+}
+
+static void
+check_x(mrb_state *mrb, mrb_int a, mrb_int count, char c)
+{
+  if (a < count) {
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "%c outside of string", c);
+  }
+}
+
+static void
+prepare_tmpl(mrb_state *mrb, struct tmpl *tmpl)
+{
+  mrb_get_args(mrb, "S", &tmpl->str);
+  tmpl->idx = 0;
+}
+
+static int
+has_tmpl(const struct tmpl *tmpl)
+{
+  return (tmpl->idx < RSTRING_LEN(tmpl->str));
+}
+
+static enum pack_dir
+read_tmpl(mrb_state *mrb, struct tmpl *tmpl, enum pack_type *typep, mrb_int *sizep, mrb_int *countp, unsigned int *flagsp)
+{
+  mrb_int t, tlen;
+  int ch, size = 0;
+  enum pack_dir dir;
+  enum pack_type type;
+  mrb_int count = 1;
+  unsigned int flags = 0;
+  const char *tptr;
+
+  tptr = RSTRING_PTR(tmpl->str);
+  tlen = RSTRING_LEN(tmpl->str);
+
+ restart:
+  if (tmpl->idx >= tlen) return PACK_DIR_NONE;
+  t = tptr[tmpl->idx++];
+ alias:
+
+  /* Handle whitespace - skip and restart */
+  if (ISSPACE((char)t)) {
+    goto restart;
+  }
+
+  /* Special handling for runtime-dependent formats and special characters */
+  switch (t) {
+  case 'I':
+    switch (sizeof(int)) {
+      case 2: t = 'S'; goto alias;
+      case 4: t = 'L'; goto alias;
+      case 8: t = 'Q'; goto alias;
+      default:
+        mrb_raisef(mrb, E_RUNTIME_ERROR, "mruby-pack does not support sizeof(int) == %d", (int)sizeof(int));
+    }
+    break;
+  case 'i':
+    switch (sizeof(int)) {
+      case 2: t = 's'; goto alias;
+      case 4: t = 'l'; goto alias;
+      case 8: t = 'q'; goto alias;
+      default:
+        mrb_raisef(mrb, E_RUNTIME_ERROR, "mruby-pack does not support sizeof(int) == %d", (int)sizeof(int));
+    }
+    break;
+  case 'J':
+    switch (sizeof(intptr_t)) {
+      case 4: t = 'L'; goto alias;
+      case 8: t = 'Q'; goto alias;
+      default:
+        mrb_raisef(mrb, E_RUNTIME_ERROR, "mruby-pack does not support sizeof(uintptr_t) == %d", (int)sizeof(uintptr_t));
+    }
+    break;
+  case 'j':
+    switch (sizeof(intptr_t)) {
+      case 4: t = 'l'; goto alias;
+      case 8: t = 'q'; goto alias;
+      default:
+        mrb_raisef(mrb, E_RUNTIME_ERROR, "mruby-pack does not support sizeof(intptr_t) == %d", (int)sizeof(intptr_t));
+    }
+    break;
+  case '#':
+    while (++tmpl->idx < tlen && tptr[tmpl->idx] != '\n')
+      ;
+    goto restart;
+  case 'p': case 'P':
+  case '%':
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "%c is not supported", (char)t);
+    break;
+  default:
+    /* Use O(1) lookup table for standard format characters */
+    if (t >= 0 && t < 256) {
+      format_info_t info_val = pack_format_info((unsigned char)t);
+      const format_info_t *info = &info_val;
+      if (info->dir != PACK_DIR_NONE) {
+        /* Valid format character found in lookup table */
+        dir = info->dir;
+        type = info->type;
+        size = info->size;
+        flags = info->base_flags;
+        break;
+      }
+    }
+
+    /* Handle invalid characters */
+    char c = (char)t;
+    mrb_value s = mrb_str_new(mrb, &c, 1);
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "unknown unpack directive %!v", s);
+  }
+
+  /* read suffix [0-9*_!<>] */
+  while (tmpl->idx < tlen) {
+    ch = tptr[tmpl->idx];
+    if (ISDIGIT(ch)) {
+      char *e;
+      mrb_int n;
+      if (!mrb_read_int(tptr+tmpl->idx, tptr+tlen, &e, &n) || INT_MAX < n) {
+        mrb_raise(mrb, E_RUNTIME_ERROR, "too big template length");
+      }
+      count = n;
+      tmpl->idx = (int)(e - tptr);
+      continue;
+    }
+    else if (ch == '*')  {
+      if (type == PACK_TYPE_NONE)
+        count = 0;
+      else
+        count = -1;
+    }
+    else if (ch == '_' || ch == '!' || ch == '<' || ch == '>') {
+      if (strchr("sSiIlLqQ", (int)t) == NULL) {
+        mrb_raisef(mrb, E_ARGUMENT_ERROR, "'%c' allowed only after types sSiIlLqQ", ch);
+      }
+      if (ch == '_' || ch == '!') {
+        flags |= PACK_FLAG_s;
+      }
+      else if (ch == '<') {
+        flags |= PACK_FLAG_LT;
+      }
+      else if (ch == '>') {
+        flags |= PACK_FLAG_GT;
+      }
+    }
+    else {
+      break;
+    }
+    tmpl->idx++;
+  }
+
+  if ((flags & PACK_FLAG_LT) || (!(flags & PACK_FLAG_GT) && littleendian)) {
+    flags |= PACK_FLAG_LITTLEENDIAN;
+  }
+
+  *typep = type;
+  *sizep = size;
+  *countp = count;
+  *flagsp = flags;
+  return dir;
+}
+
+/*
+ * call-seq:
+ *   array.pack(template) -> string
+ *
+ * Packs the contents of array into a binary string according to the
+ * directives in template. Directives are single characters from the
+ * table below. Each directive may be followed by a number indicating
+ * the number of times to repeat the directive.
+ *
+ * Template string directives:
+ *   C - 8-bit unsigned integer (unsigned char)
+ *   c - 8-bit signed integer (signed char)
+ *   S - 16-bit unsigned integer, native endian (uint16_t)
+ *   s - 16-bit signed integer, native endian (int16_t)
+ *   L - 32-bit unsigned integer, native endian (uint32_t)
+ *   l - 32-bit signed integer, native endian (int32_t)
+ *   Q - 64-bit unsigned integer, native endian (uint64_t)
+ *   q - 64-bit signed integer, native endian (int64_t)
+ *   n - 16-bit unsigned integer, network byte order
+ *   N - 32-bit unsigned integer, network byte order
+ *   v - 16-bit unsigned integer, little endian
+ *   V - 32-bit unsigned integer, little endian
+ *   f - single precision float, native format
+ *   d - double precision float, native format
+ *   A - ASCII string, space padded
+ *   a - ASCII string, null padded
+ *   Z - null-terminated string
+ *   H - hex string, high nibble first
+ *   h - hex string, low nibble first
+ *   x - null byte
+ *   X - back up one byte
+ *   @ - null fill to absolute position
+ *
+ *   [1, 2, 3].pack("CCC")     #=> "\x01\x02\x03"
+ *   [1, 2].pack("S*")         #=> "\x01\x00\x02\x00" (little endian)
+ *   ["hello"].pack("A10")     #=> "hello     "
+ */
+static mrb_value
+mrb_pack_pack(mrb_state *mrb, mrb_value ary)
+{
+  mrb_value o;
+  struct tmpl tmpl;
+  enum pack_type type;
+  mrb_int count;
+  mrb_int size;
+  unsigned int flags;
+  enum pack_dir dir;
+
+  prepare_tmpl(mrb, &tmpl);
+
+  mrb_value result = mrb_str_new(mrb, NULL, 128);  /* allocate initial buffer */
+  mrb_int aidx = 0;
+  mrb_int ridx = 0;
+  while (has_tmpl(&tmpl)) {
+    dir = read_tmpl(mrb, &tmpl, &type, &size, &count, &flags);
+
+    if (dir == PACK_DIR_NONE) break;
+    if (dir == PACK_DIR_NUL) {
+    grow:
+      if (ridx > INT_MAX - count) goto overflow;
+      ridx += pack_nul(mrb, result, ridx, (int)count);
+      continue;
+    }
+    else if (dir == PACK_DIR_BACK) {
+      check_x(mrb, ridx, count, 'X');
+      ridx -= count;
+      continue;
+    }
+    else if (dir == PACK_DIR_ABS) {
+      count -= ridx;
+      if (count > 0) goto grow;
+      count = -count;
+      check_x(mrb, ridx, count, '@');
+      ridx -= count;
+      continue;
+    }
+
+    if ((flags & PACK_FLAG_WIDTH) && aidx >= RARRAY_LEN(ary)) {
+      mrb_raise(mrb, E_ARGUMENT_ERROR, "too few arguments");
+    }
+    for (; aidx < RARRAY_LEN(ary); aidx++) {
+      if (count == 0 && !(flags & PACK_FLAG_WIDTH))
+        break;
+
+      o = RARRAY_PTR(ary)[aidx];
+      if (type == PACK_TYPE_INTEGER) {
+        o = mrb_ensure_int_type(mrb, o);
+      }
+#ifndef MRB_NO_FLOAT
+      else if (type == PACK_TYPE_FLOAT) {
+        if (!mrb_float_p(o)) {
+          o = mrb_ensure_float_type(mrb, o);
+        }
+      }
+#endif
+      else if (type == PACK_TYPE_STRING) {
+        if (!mrb_string_p(o)) {
+          mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %T into String", o);
+        }
+      }
+
+      /* Optimized dispatch using grouped format handling for better branch prediction */
+      switch (dir) {
+      /* Integer formats - all use (mrb, o, result, ridx, flags) signature */
+      case PACK_DIR_CHAR:
+        ridx += pack_char(mrb, o, result, ridx, flags);
+        break;
+      case PACK_DIR_SHORT:
+        ridx += pack_short(mrb, o, result, ridx, flags);
+        break;
+      case PACK_DIR_LONG:
+        ridx += pack_long(mrb, o, result, ridx, flags);
+        break;
+      case PACK_DIR_QUAD:
+        ridx += pack_quad(mrb, o, result, ridx, flags);
+        break;
+      case PACK_DIR_BER:
+        ridx += pack_BER(mrb, o, result, ridx, flags);
+        break;
+
+#ifndef MRB_NO_FLOAT
+      /* Float formats - all use (mrb, o, result, ridx, flags) signature */
+      case PACK_DIR_DOUBLE:
+        ridx += pack_double(mrb, o, result, ridx, flags);
+        break;
+      case PACK_DIR_FLOAT:
+        ridx += pack_float(mrb, o, result, ridx, flags);
+        break;
+#endif
+
+      /* String formats with count - use (mrb, o, result, ridx, count, flags) signature */
+      case PACK_DIR_HEX:
+        ridx += pack_hex(mrb, o, result, ridx, (int)count, flags);
+        break;
+      case PACK_DIR_BSTR:
+        ridx += pack_bstr(mrb, o, result, ridx, (int)count, flags);
+        break;
+      case PACK_DIR_STR:
+        ridx += pack_str(mrb, o, result, ridx, (int)count, flags);
+        break;
+
+      /* String formats with count only - use (mrb, o, result, ridx, count) signature */
+      case PACK_DIR_BASE64:
+        ridx += pack_base64(mrb, o, result, ridx, (int)count);
+        break;
+      case PACK_DIR_UU:
+        ridx += pack_uu(mrb, o, result, ridx, (int)count);
+        break;
+      case PACK_DIR_QENC:
+        ridx += pack_qenc(mrb, o, result, ridx, (int)count);
+        break;
+
+      /* UTF8 format - special signature (mrb, o, result, ridx, count, flags) */
+      case PACK_DIR_UTF8:
+        ridx += pack_utf8(mrb, o, result, ridx, (int)count, flags);
+        break;
+
+      default:
+        break;
+      }
+      if (flags & PACK_FLAG_COUNT2) {
+        /* always consumes 1 entry */
+        aidx++;
+        break;
+      }
+      if (count > 0) {
+        count--;
+      }
+    }
+    if (ridx < 0) {
+    overflow:
+      mrb_raise(mrb, E_RANGE_ERROR, "negative (or overflowed) template size");
+    }
+  }
+
+  mrb_str_resize(mrb, result, ridx);
+  return result;
+}
+
+static mrb_value
+pack_unpack(mrb_state *mrb, mrb_value str, mrb_bool single)
+{
+  struct tmpl tmpl;
+  mrb_int count;
+  unsigned int flags;
+  enum pack_type type;
+  mrb_int size;
+  const unsigned char *sptr;
+
+  prepare_tmpl(mrb, &tmpl);
+
+  mrb_int srcidx = 0;
+  mrb_int srclen = RSTRING_LEN(str);
+
+  mrb_value result = mrb_ary_new(mrb);
+  while (has_tmpl(&tmpl)) {
+    enum pack_dir dir = read_tmpl(mrb, &tmpl, &type, &size, &count, &flags);
+
+    if (dir == PACK_DIR_NONE) break;
+    if (dir == PACK_DIR_NUL) {
+      check_x(mrb, srclen-srcidx, count, 'x');
+      srcidx += count;
+      continue;
+    }
+    else if (dir == PACK_DIR_BACK) {
+      check_x(mrb, srcidx, count, 'X');
+      srcidx -= count;
+      continue;
+    }
+    else if (dir == PACK_DIR_ABS) {
+      check_x(mrb, srclen, count, '@');
+      srcidx = count;
+      continue;
+    }
+
+    /* Optimized dispatch for PACK_FLAG_COUNT2 formats - grouped by signature */
+    sptr = (const unsigned char*)RSTRING_PTR(str) + srcidx;
+    switch (dir) {
+    /* String formats with count and flags - (mrb, sptr, len, result, count, flags) */
+    case PACK_DIR_HEX:
+      srcidx += unpack_hex(mrb, sptr, srclen - srcidx, result, (int)count, flags);
+      if (single) goto single_return;
+      continue;
+    case PACK_DIR_BSTR:
+      srcidx += unpack_bstr(mrb, sptr, srclen - srcidx, result, (int)count, flags);
+      if (single) goto single_return;
+      continue;
+    case PACK_DIR_STR:
+      srcidx += unpack_str(mrb, sptr, srclen - srcidx, result, (int)count, flags);
+      if (single) goto single_return;
+      continue;
+
+    /* String formats without flags - (mrb, sptr, len, result) */
+    case PACK_DIR_BASE64:
+      srcidx += unpack_base64(mrb, sptr, srclen - srcidx, result);
+      if (single) goto single_return;
+      continue;
+    case PACK_DIR_UU:
+      srcidx += unpack_uu(mrb, sptr, srclen - srcidx, result);
+      if (single) goto single_return;
+      continue;
+    case PACK_DIR_QENC:
+      srcidx += unpack_qenc(mrb, sptr, srclen - srcidx, result);
+      if (single) goto single_return;
+      continue;
+
+    default:
+      break;
+    }
+
+    while (count != 0 && srcidx < srclen) {
+      if (srclen - srcidx < size) {
+        while (count-- > 0) {
+          mrb_ary_push(mrb, result, mrb_nil_value());
+        }
+        break;
+      }
+
+      sptr = (const unsigned char*)RSTRING_PTR(str) + srcidx;
+      /* Optimized dispatch for element-by-element formats - grouped by signature */
+      switch (dir) {
+      /* Integer formats - all use (mrb, sptr, len, result, flags) signature */
+      case PACK_DIR_CHAR:
+        srcidx += unpack_char(mrb, sptr, srclen - srcidx, result, flags);
+        break;
+      case PACK_DIR_SHORT:
+        srcidx += unpack_short(mrb, sptr, srclen - srcidx, result, flags);
+        break;
+      case PACK_DIR_LONG:
+        srcidx += unpack_long(mrb, sptr, srclen - srcidx, result, flags);
+        break;
+      case PACK_DIR_QUAD:
+        srcidx += unpack_quad(mrb, sptr, srclen - srcidx, result, flags);
+        break;
+      case PACK_DIR_BER:
+        srcidx += unpack_BER(mrb, sptr, srclen - srcidx, result, flags);
+        break;
+
+#ifndef MRB_NO_FLOAT
+      /* Float formats - all use (mrb, sptr, len, result, flags) signature */
+      case PACK_DIR_FLOAT:
+        srcidx += unpack_float(mrb, sptr, srclen - srcidx, result, flags);
+        break;
+      case PACK_DIR_DOUBLE:
+        srcidx += unpack_double(mrb, sptr, srclen - srcidx, result, flags);
+        break;
+#endif
+
+      /* UTF8 format - uses (mrb, sptr, len, result, flags) signature */
+      case PACK_DIR_UTF8:
+        srcidx += unpack_utf8(mrb, sptr, srclen - srcidx, result, flags);
+        break;
+
+      default:
+        mrb_raise(mrb, E_RUNTIME_ERROR, "mruby-pack's bug");
+      }
+      if (count > 0) {
+        count--;
+      }
+    }
+  }
+  if (single) {
+  single_return:
+    if (RARRAY_LEN(result) > 0) {
+      return RARRAY_PTR(result)[0];
+    }
+    return mrb_nil_value();
+  }
+  return result;
+}
+
+/*
+ * call-seq:
+ *   string.unpack(template) -> array
+ *
+ * Unpacks the contents of string according to the template string,
+ * returning an array of values. Template uses the same format as
+ * Array#pack. See Array#pack for template string format.
+ *
+ *   "\x01\x02\x03".unpack("CCC")     #=> [1, 2, 3]
+ *   "\x01\x00\x02\x00".unpack("S*")  #=> [1, 2] (little endian)
+ *   "hello     ".unpack("A10")       #=> ["hello"]
+ */
+static mrb_value
+mrb_pack_unpack(mrb_state *mrb, mrb_value str)
+{
+  return pack_unpack(mrb, str, FALSE);
+}
+
+/*
+ * call-seq:
+ *   string.unpack1(template) -> object
+ *
+ * Unpacks the first value from string according to the template string.
+ * This is equivalent to string.unpack(template)[0] but more efficient
+ * when only the first value is needed.
+ *
+ *   "\x01\x02\x03".unpack1("C")      #=> 1
+ *   "\x01\x00\x02\x00".unpack1("S")  #=> 1 (little endian)
+ *   "hello     ".unpack1("A10")      #=> "hello"
+ */
+static mrb_value
+mrb_pack_unpack1(mrb_state *mrb, mrb_value str)
+{
+  return pack_unpack(mrb, str, TRUE);
+}
+
+void
+mrb_mruby_pack_gem_init(mrb_state *mrb)
+{
+  mrb_define_method_id(mrb, mrb->array_class, MRB_SYM(pack), mrb_pack_pack, MRB_ARGS_REQ(1));
+  mrb_define_method_id(mrb, mrb->string_class, MRB_SYM(unpack), mrb_pack_unpack, MRB_ARGS_REQ(1));
+  mrb_define_method_id(mrb, mrb->string_class, MRB_SYM(unpack1), mrb_pack_unpack1, MRB_ARGS_REQ(1));
+}
+
+void
+mrb_mruby_pack_gem_final(mrb_state *mrb)
+{
+}