bin_utils 0.0.4 → 0.0.5

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MmIxYzY2OWZjNTMyM2YyNzI0NDBiOGEwNTc4ZDRiYmNjNTdhOWY1ZQ==
+  data.tar.gz: !binary |-
+    ZDM4MzEwZGQ2OGVmOTJhMjlkY2RiMzgyMTljZDdlYmVhOTVjYmUxMg==
+SHA512:
+  metadata.gz: !binary |-
+    ZDE3ZTlmYjc3MDRjNzA2NTFlMzMzY2VlYzAxZjhkZWU0YzczNGU3M2NiNzgz
+    NDhkNjM3ZjM2NmI3ZGU1ZDA0MjNmYTFkMTRmODA4Y2JjOWFkYmJjMmUwZGQ0
+    M2ZmZmE3N2ViOTcxMWY4MDE4NjA0OWE4MWE4MzkxZTcyNWYzNzI=
+  data.tar.gz: !binary |-
+    M2QzMGE4YTdlMjBjMDg2MjUxNDM5ZjczZGMzZDA5YjViODUzYmY3MzkxN2Qy
+    OWMzZTBkOWRmNzlkYTY1YjVjMzI2MGMyOWI0MDBiODhjNjVmMTJlYzBhZDA1
+    YTY0ODlhYjdhOGFhZmNlNmI3MTFkNjYzN2EwZTk1YjM3OTgyNzI=

data/ext/bin_utils/extconf.rb

@@ -1,9 +1,12 @@
-if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
+begin
+  unless RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
+    raise "Uh"
+  end
   require 'mkmf'
   # rubinius has no rb_str_drop_bytes
   have_func('rb_str_drop_bytes')
   create_makefile("bin_utils")
-else
+rescue
   File.open(File.dirname(__FILE__) + "/Makefile", 'w') do |f|
     f.write("install:\n\t#nothing to build")
   end

data/ext/bin_utils/native.c

@@ -61,16 +61,31 @@ ID rshft;
 ID band;
 #ifndef HAVE_RB_STR_DROP_BYTES
 /* rubinius has no rb_str_drop_bytes */
-ID aset;
+ID aslice;
 static VALUE
 rb_str_drop_bytes(VALUE str, long bytes)
 {
-    VALUE args[3] = {INT2FIX(0), INT2FIX(bytes), rb_str_new(0, 0)};
-    rb_funcall2(str, aset, 3, args);
+    VALUE args[2] = {0, INT2FIX(bytes)};
+    rb_funcall2(str, aslice, 2, args);
     return str;
 }
 #endif
 
+static int64_t
+safe_int64_t(VALUE i)
+{
+    if (FIXNUM_P(i)) {
+        return NUM2I64(i);
+    }
+    else {
+        VALUE argm = UINT2NUM(0xffffffff);
+        VALUE arg32 = INT2FIX(32);
+        uint64_t i0 = NUM2I64(rb_funcall2(i, band, 1, &argm));
+        i = rb_funcall2(i, rshft, 1, &arg32);
+        return i0 + (NUM2I64(rb_funcall2(i, band, 1, &argm)) << 32);
+    }
+}
+
 static long
 check_size(long i, long strlen, long ilen)
 {
@@ -81,788 +96,768 @@ check_size(long i, long strlen, long ilen)
     return i;
 }
 
-static int32_t
-get_int8(VALUE rstr, VALUE ri)
+static VALUE
+check_argc(int argc, VALUE *argv)
 {
-    long i = NUM2LONG(ri);
-    StringValue(rstr);
-    i = check_size(i, RSTRING_LEN(rstr), 1);
-    return (uint8_t)(RSTRING_PTR(rstr)[i]);
+    if (argc == 0 || argc > 2) {
+        rb_raise(rb_eArgError, "accepts 1 or 2 arguments: (string[, offset=0])");
+    }
+    return argc == 2 ? argv[1] : INT2FIX(0);
 }
 
-static int32_t
-get_sint8(VALUE rstr, VALUE ri)
-{
-    long i = NUM2LONG(ri);
-    StringValue(rstr);
-    i = check_size(i, RSTRING_LEN(rstr), 1);
-    return (int8_t)(RSTRING_PTR(rstr)[i]);
-}
+typedef struct append_args {
+    VALUE str;
+    int argc;
+    VALUE *argv;
+} append_args;
 
-static int32_t
-get_int16_le(VALUE rstr, VALUE ri)
+typedef struct append_args2 {
+    VALUE str;
+    int argc;
+    VALUE *argv;
+    VALUE int0;
+} append_args2;
+
+static void
+check_argc_append(int argc, VALUE *argv, append_args *args, int bits)
 {
-    long i = NUM2LONG(ri);
-    const uint8_t *ptr;
-    uint32_t byte0, byte1;
-    StringValue(rstr);
-    i = check_size(i, RSTRING_LEN(rstr), 2);
-    ptr = (const uint8_t*)RSTRING_PTR(rstr);
-    byte0 = ptr[i];
-    byte1 = ptr[i+1];
-    return byte0 + (byte1 << 8);
+    if (argc < 1) {
+        rb_raise(rb_eArgError, "accepts at least 1 argument: (string[, *int%ds])", bits);
+    }
+    args->str = RTEST(argv[0]) ? argv[0] : rb_str_new(0, 0);
+    if (argc == 2 && TYPE(argv[1]) == T_ARRAY) {
+        args->argc = RARRAY_LEN(argv[1]);
+        args->argv = RARRAY_PTR(argv[1]);
+    }
+    else {
+        args->argc = argc-1;
+        args->argv = argv+1;
+    }
 }
 
-static int32_t
-get_sint16_le(VALUE rstr, VALUE ri)
+static void
+check_argc_append_2(int argc, VALUE *argv, append_args2 *args, int bits, int bits1)
 {
-    int32_t res = get_int16_le(rstr, ri);
-    return res - ((res >> 15)<<16);
+    if (argc < 2) {
+        rb_raise(rb_eArgError, "accepts at least 2 arguments: (string, int%d[, *int%ds])", bits, bits1);
+    }
+    args->str = RTEST(argv[0]) ? argv[0] : rb_str_new(0, 0);
+    args->int0 = argv[1];
+    if (argc == 3 && TYPE(argv[2]) == T_ARRAY) {
+        args->argc = RARRAY_LEN(argv[2]);
+        args->argv = RARRAY_PTR(argv[2]);
+    }
+    else {
+        args->argc = argc-2;
+        args->argv = argv+2;
+    }
 }
 
-static int32_t
-get_int16_be(VALUE rstr, VALUE ri)
+
+static uint32_t
+get_int8(VALUE rstr, VALUE ri)
 {
     long i = NUM2LONG(ri);
     const uint8_t *ptr;
-    uint32_t byte0, byte1;
     StringValue(rstr);
-    i = check_size(i, RSTRING_LEN(rstr), 2);
+    i = check_size(i, RSTRING_LEN(rstr), 1);
     ptr = (const uint8_t*)RSTRING_PTR(rstr);
-    byte0 = ptr[i+1];
-    byte1 = ptr[i];
-    return byte0 + (byte1 << 8);
+    return
+        (((uint32_t)ptr[i + 0]) << 0 ) |
+        (uint32_t)0;
 }
 
 static int32_t
-get_sint16_be(VALUE rstr, VALUE ri)
+get_sint8(VALUE rstr, VALUE ri)
 {
-    int32_t res = get_int16_be(rstr, ri);
-    return res - ((res >> 15) << 16);
+    int32_t res = (int32_t)get_int8(rstr, ri);
+    return res - ((res >> 7) << 8);
 }
 
-static int32_t
-get_int24_le(VALUE rstr, VALUE ri)
+static VALUE
+rb_get_int8(int argc, VALUE *argv, VALUE self)
 {
-    long i = NUM2LONG(ri);
-    const uint8_t *ptr;
-    uint32_t byte0, byte1, byte2;
-    StringValue(rstr);
-    i = check_size(i, RSTRING_LEN(rstr), 3);
-    ptr = (const uint8_t*)RSTRING_PTR(rstr);
-    byte0 = ptr[i];
-    byte1 = ptr[i+1];
-    byte2 = ptr[i+2];
-    return byte0 + (byte1 << 8) + (byte2 << 16);
+    return INT2FIX(get_int8(argv[0], check_argc(argc, argv)));
 }
 
-static int32_t
-get_sint24_le(VALUE rstr, VALUE ri)
+static VALUE
+rb_get_sint8(int argc, VALUE *argv, VALUE self)
 {
-    int32_t res = get_int24_le(rstr, ri);
-    return res - ((res >> 23) << 24);
+    return INT2FIX(get_sint8(argv[0], check_argc(argc, argv)));
 }
 
-static int32_t
-get_int24_be(VALUE rstr, VALUE ri)
+static VALUE
+rb_slice_int8(VALUE self, VALUE rstr)
 {
-    long i = NUM2LONG(ri);
-    const uint8_t *ptr;
-    uint32_t byte0, byte1, byte2;
-    StringValue(rstr);
-    i = check_size(i, RSTRING_LEN(rstr), 3);
-    ptr = (const uint8_t*)RSTRING_PTR(rstr);
-    byte0 = ptr[i+2];
-    byte1 = ptr[i+1];
-    byte2 = ptr[i];
-    return byte0 + (byte1 << 8) + (byte2 << 16);
+    uint32_t res = get_int8(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 1);
+    return INT2FIX(res);
 }
 
-static int32_t
-get_sint24_be(VALUE rstr, VALUE ri)
+static VALUE
+rb_slice_sint8(VALUE self, VALUE rstr)
 {
-    int32_t res = get_int24_be(rstr, ri);
-    return res - ((res >> 23) << 24);
+    int32_t res = get_sint8(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 1);
+    return INT2FIX(res);
 }
 
-static uint32_t
-get_int32_le(VALUE rstr, VALUE ri)
+static void
+append_int8(VALUE rstr, int32_t v)
 {
-    long i = NUM2LONG(ri);
-    const uint8_t *ptr;
-    uint32_t byte0, byte1, byte2, byte3;
-    StringValue(rstr);
-    i = check_size(i, RSTRING_LEN(rstr), 4);
-    ptr = (const uint8_t*)RSTRING_PTR(rstr);
-    
-    byte0 = ptr[i];
-    byte1 = ptr[i+1];
-    byte2 = ptr[i+2];
-    byte3 = ptr[i+3];
-    return byte0 + (byte1 << 8) + (byte2 << 16) + (byte3 << 24);
+    char a[] = {
+                (v >> 0) & 0xff,
+        0
+    };
+    rb_str_cat(rstr, a, 1);
 }
 
-static int32_t
-get_sint32_le(VALUE rstr, VALUE ri)
+static VALUE
+append_var_int8(int argc, VALUE* argv, VALUE str)
+{
+    int i;
+    for(i = 0; i < argc; i++) {
+
+        append_int8(str, NUM2INT(argv[i]));
+
+    }
+    return str;
+}
+
+static VALUE
+rb_append_int8(int argc, VALUE* argv, VALUE self)
 {
-    return (int32_t)get_int32_le(rstr, ri);
+    append_args args;
+    check_argc_append(argc, argv, &args, 8);
+    return append_var_int8(args.argc, args.argv, args.str);
 }
 
+#define append_var_int8_le append_var_int8
+#define append_var_int8_be append_var_int8
 static uint32_t
-get_int32_be(VALUE rstr, VALUE ri)
+get_int16_le(VALUE rstr, VALUE ri)
 {
     long i = NUM2LONG(ri);
     const uint8_t *ptr;
-    uint32_t byte0, byte1, byte2, byte3;
     StringValue(rstr);
-    i = check_size(i, RSTRING_LEN(rstr), 4);
+    i = check_size(i, RSTRING_LEN(rstr), 2);
     ptr = (const uint8_t*)RSTRING_PTR(rstr);
-    byte0 = ptr[i+3];
-    byte1 = ptr[i+2];
-    byte2 = ptr[i+1];
-    byte3 = ptr[i+0];
-    return byte0 + (byte1 << 8) + (byte2 << 16) + (byte3 << 24);
+    return
+        (((uint32_t)ptr[i + 0]) << 0 ) |
+        (((uint32_t)ptr[i + 1]) << 8 ) |
+        (uint32_t)0;
 }
 
 static int32_t
-get_sint32_be(VALUE rstr, VALUE ri)
+get_sint16_le(VALUE rstr, VALUE ri)
 {
-    return (int32_t)get_int32_be(rstr, ri);
+    int32_t res = (int32_t)get_int16_le(rstr, ri);
+    return res - ((res >> 15) << 16);
 }
 
-static int64_t
-get_int40_le(VALUE rstr, VALUE ri)
+static VALUE
+rb_get_int16_le(int argc, VALUE *argv, VALUE self)
 {
-    long i = NUM2LONG(ri);
-    const uint8_t *ptr;
-    uint32_t byte0, byte1, byte2, byte3;
-    int64_t res;
-    StringValue(rstr);
-    i = check_size(i, RSTRING_LEN(rstr), 5);
-    ptr = (const uint8_t*)RSTRING_PTR(rstr);
-    
-    byte0 = ptr[i];
-    byte1 = ptr[i+1];
-    byte2 = ptr[i+2];
-    byte3 = ptr[i+3];
-    res = byte0 + (byte1 << 8) + (byte2 << 16) + (byte3 << 24);
-    byte0 = ptr[i+4];
-    return res + ((int64_t)byte0 << 32);
+    return INT2FIX(get_int16_le(argv[0], check_argc(argc, argv)));
 }
 
-static int64_t
-get_sint40_le(VALUE rstr, VALUE ri)
+static VALUE
+rb_get_sint16_le(int argc, VALUE *argv, VALUE self)
 {
-    int64_t res = get_int40_le(rstr, ri);
-    return res - ((res >> 39) << 40);
+    return INT2FIX(get_sint16_le(argv[0], check_argc(argc, argv)));
 }
 
-static int64_t
-get_int40_be(VALUE rstr, VALUE ri)
+static VALUE
+rb_slice_int16_le(VALUE self, VALUE rstr)
 {
-    long i = NUM2LONG(ri);
-    const uint8_t *ptr;
-    uint32_t byte0, byte1, byte2, byte3;
-    int64_t res;
-    StringValue(rstr);
-    i = check_size(i, RSTRING_LEN(rstr), 5);
-    ptr = (const uint8_t*)RSTRING_PTR(rstr);
-    
-    byte0 = ptr[i+4];
-    byte1 = ptr[i+3];
-    byte2 = ptr[i+2];
-    byte3 = ptr[i+1];
-    res = byte0 + (byte1 << 8) + (byte2 << 16) + (byte3 << 24);
-    byte0 = ptr[i];
-    return res + ((int64_t)byte0 << 32);
+    uint32_t res = get_int16_le(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 2);
+    return INT2FIX(res);
 }
 
-static int64_t
-get_sint40_be(VALUE rstr, VALUE ri)
+static VALUE
+rb_slice_sint16_le(VALUE self, VALUE rstr)
 {
-    int64_t res = get_int40_be(rstr, ri);
-    return res - ((res >> 39) << 40);
+    int32_t res = get_sint16_le(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 2);
+    return INT2FIX(res);
 }
 
-static int64_t
-get_int48_le(VALUE rstr, VALUE ri)
+static void
+append_int16_le(VALUE rstr, int32_t v)
 {
-    long i = NUM2LONG(ri);
-    const uint8_t *ptr;
-    uint32_t byte0, byte1, byte2, byte3;
-    int64_t res, res1;
-    StringValue(rstr);
-    i = check_size(i, RSTRING_LEN(rstr), 6);
-    ptr = (const uint8_t*)RSTRING_PTR(rstr);
-    
-    byte0 = ptr[i];
-    byte1 = ptr[i+1];
-    byte2 = ptr[i+2];
-    byte3 = ptr[i+3];
-    res = byte0 + (byte1 << 8) + (byte2 << 16) + (byte3 << 24);
-    byte0 = ptr[i+4];
-    byte1 = ptr[i+5];
-    res1 = byte0 + (byte1 << 8);
-    return res + (res1 << 32);
+    char a[] = {
+                (v >> 0) & 0xff,
+                (v >> 8) & 0xff,
+        0
+    };
+    rb_str_cat(rstr, a, 2);
 }
 
-static int64_t
-get_sint48_le(VALUE rstr, VALUE ri)
+static VALUE
+append_var_int16_le(int argc, VALUE* argv, VALUE str)
 {
-    int64_t res = get_int48_le(rstr, ri);
-    return res - ((res >> 47) << 48);
-}
+    int i;
+    for(i = 0; i < argc; i++) {
 
-static int64_t
-get_int48_be(VALUE rstr, VALUE ri)
-{
-    long i = NUM2LONG(ri);
-    const uint8_t *ptr;
-    uint32_t byte0, byte1, byte2, byte3;
-    int64_t res, res1;
-    StringValue(rstr);
-    i = check_size(i, RSTRING_LEN(rstr), 6);
-    ptr = (const uint8_t*)RSTRING_PTR(rstr);
-    
-    byte0 = ptr[i+5];
-    byte1 = ptr[i+4];
-    byte2 = ptr[i+3];
-    byte3 = ptr[i+2];
-    res = byte0 + (byte1 << 8) + (byte2 << 16) + (byte3 << 24);
-    byte0 = ptr[i+1];
-    byte1 = ptr[i+0];
-    res1 = byte0 + (byte1 << 8);
-    return res + (res1 << 32);
+        append_int16_le(str, NUM2INT(argv[i]));
+
+    }
+    return str;
 }
 
-static int64_t
-get_sint48_be(VALUE rstr, VALUE ri)
+static VALUE
+rb_append_int16_le(int argc, VALUE* argv, VALUE self)
 {
-    int64_t res = get_int48_be(rstr, ri);
-    return res - ((res >> 47) << 48);
+    append_args args;
+    check_argc_append(argc, argv, &args, 16);
+    return append_var_int16_le(args.argc, args.argv, args.str);
 }
 
-static int64_t
-get_int56_le(VALUE rstr, VALUE ri)
+static uint32_t
+get_int24_le(VALUE rstr, VALUE ri)
 {
     long i = NUM2LONG(ri);
     const uint8_t *ptr;
-    uint32_t byte0, byte1, byte2, byte3;
-    int64_t res, res1;
     StringValue(rstr);
-    i = check_size(i, RSTRING_LEN(rstr), 7);
+    i = check_size(i, RSTRING_LEN(rstr), 3);
     ptr = (const uint8_t*)RSTRING_PTR(rstr);
-    
-    byte0 = ptr[i];
-    byte1 = ptr[i+1];
-    byte2 = ptr[i+2];
-    byte3 = ptr[i+3];
-    res = byte0 + (byte1 << 8) + (byte2 << 16) + (byte3 << 24);
-    byte0 = ptr[i+4];
-    byte1 = ptr[i+5];
-    byte2 = ptr[i+6];
-    res1 = byte0 + (byte1 << 8) + (byte2 << 16);
-    return res + (res1 << 32);
+    return
+        (((uint32_t)ptr[i + 0]) << 0 ) |
+        (((uint32_t)ptr[i + 1]) << 8 ) |
+        (((uint32_t)ptr[i + 2]) << 16 ) |
+        (uint32_t)0;
 }
 
-static int64_t
-get_sint56_le(VALUE rstr, VALUE ri)
+static int32_t
+get_sint24_le(VALUE rstr, VALUE ri)
 {
-    int64_t res = get_int56_le(rstr, ri);
-    return res - ((res >> 55) << 56);
+    int32_t res = (int32_t)get_int24_le(rstr, ri);
+    return res - ((res >> 23) << 24);
 }
 
-static int64_t
-get_int56_be(VALUE rstr, VALUE ri)
+static VALUE
+rb_get_int24_le(int argc, VALUE *argv, VALUE self)
 {
-    long i = NUM2LONG(ri);
-    const uint8_t *ptr;
-    uint32_t byte0, byte1, byte2, byte3;
-    int64_t res, res1;
-    StringValue(rstr);
-    i = check_size(i, RSTRING_LEN(rstr), 7);
-    ptr = (const uint8_t*)RSTRING_PTR(rstr);
-    
-    byte0 = ptr[i+6];
-    byte1 = ptr[i+5];
-    byte2 = ptr[i+4];
-    byte3 = ptr[i+3];
-    res = byte0 + (byte1 << 8) + (byte2 << 16) + (byte3 << 24);
-    byte0 = ptr[i+2];
-    byte1 = ptr[i+1];
-    byte2 = ptr[i];
-    res1 = byte0 + (byte1 << 8) + (byte2 << 16);
-    return res + (res1 << 32);
+    return INT2FIX(get_int24_le(argv[0], check_argc(argc, argv)));
 }
 
-static int64_t
-get_sint56_be(VALUE rstr, VALUE ri)
+static VALUE
+rb_get_sint24_le(int argc, VALUE *argv, VALUE self)
 {
-    int64_t res = get_int56_be(rstr, ri);
-    return res - ((res >> 55) << 56);
+    return INT2FIX(get_sint24_le(argv[0], check_argc(argc, argv)));
 }
 
-static uint64_t
-get_int64_le(VALUE rstr, VALUE ri)
+static VALUE
+rb_slice_int24_le(VALUE self, VALUE rstr)
 {
-    long i = NUM2LONG(ri);
-    const uint8_t *ptr;
-    uint32_t byte0, byte1, byte2, byte3;
-    int64_t res, res1;
-    StringValue(rstr);
-    i = check_size(i, RSTRING_LEN(rstr), 8);
-    ptr = (const uint8_t*)RSTRING_PTR(rstr);
-    
-    byte0 = ptr[i];
-    byte1 = ptr[i+1];
-    byte2 = ptr[i+2];
-    byte3 = ptr[i+3];
-    res = byte0 + (byte1 << 8) + (byte2 << 16) + (byte3 << 24);
-    byte0 = ptr[i+4];
-    byte1 = ptr[i+5];
-    byte2 = ptr[i+6];
-    byte3 = ptr[i+7];
-    res1 = byte0 + (byte1 << 8) + (byte2 << 16) + (byte3 << 24);
-    return res + (res1 << 32);
+    uint32_t res = get_int24_le(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 3);
+    return INT2FIX(res);
 }
 
-static int64_t
-get_sint64_le(VALUE rstr, VALUE ri)
+static VALUE
+rb_slice_sint24_le(VALUE self, VALUE rstr)
 {
-    return (int64_t)get_int64_le(rstr, ri);
+    int32_t res = get_sint24_le(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 3);
+    return INT2FIX(res);
 }
 
-static uint64_t
-get_int64_be(VALUE rstr, VALUE ri)
+static void
+append_int24_le(VALUE rstr, int32_t v)
 {
-    long i = NUM2LONG(ri);
-    const uint8_t *ptr;
-    uint32_t byte0, byte1, byte2, byte3;
-    int64_t res, res1;
-    StringValue(rstr);
-    i = check_size(i, RSTRING_LEN(rstr), 8);
-    ptr = (const uint8_t*)RSTRING_PTR(rstr);
-    
-    byte0 = ptr[i+7];
-    byte1 = ptr[i+6];
-    byte2 = ptr[i+5];
-    byte3 = ptr[i+4];
-    res = byte0 + (byte1 << 8) + (byte2 << 16) + (byte3 << 24);
-    byte0 = ptr[i+3];
-    byte1 = ptr[i+2];
-    byte2 = ptr[i+1];
-    byte3 = ptr[i];
-    res1 = byte0 + (byte1 << 8) + (byte2 << 16) + (byte3 << 24);
-    return res + (res1 << 32);
+    char a[] = {
+                (v >> 0) & 0xff,
+                (v >> 8) & 0xff,
+                (v >> 16) & 0xff,
+        0
+    };
+    rb_str_cat(rstr, a, 3);
 }
 
-static int64_t
-get_sint64_be(VALUE rstr, VALUE ri)
+static VALUE
+append_var_int24_le(int argc, VALUE* argv, VALUE str)
 {
-    return (int64_t)get_int64_be(rstr, ri);
+    int i;
+    for(i = 0; i < argc; i++) {
+
+        append_int24_le(str, NUM2INT(argv[i]));
+
+    }
+    return str;
 }
 
-static uint64_t
-parse_ber(const uint8_t *ptr, long max, long *i)
+static VALUE
+rb_append_int24_le(int argc, VALUE* argv, VALUE self)
 {
-    uint64_t res = 0;
-    while (1) {
-        if (*ptr < 128) {
-            res += *ptr;
-            break;
-        }
-        if (res > LLU(0xFFFFFFFFFFFFFFFF) / 128) {
-            rb_raise(rb_eArgError, "BER integer is greater then 2**64, could not parse such big");
-        }
-        res = (res + ((*ptr) - 128)) * 128;
-        ptr++;
-        if (++(*i) >= max) {
-            rb_raise(rb_eArgError, "String unexpectedly finished while parsing BER integer");
-        }
-    }
-    return res;
+    append_args args;
+    check_argc_append(argc, argv, &args, 24);
+    return append_var_int24_le(args.argc, args.argv, args.str);
 }
 
-static uint64_t
-get_ber(VALUE rstr, VALUE ri)
+static uint32_t
+get_int32_le(VALUE rstr, VALUE ri)
 {
-    long i = NUM2LONG(ri), len;
+    long i = NUM2LONG(ri);
     const uint8_t *ptr;
     StringValue(rstr);
-    len = RSTRING_LEN(rstr);
-    i = check_size(i, len, 1);
-    ptr = (const uint8_t*)RSTRING_PTR(rstr) + i;
-    return parse_ber(ptr, len, &i);
+    i = check_size(i, RSTRING_LEN(rstr), 4);
+    ptr = (const uint8_t*)RSTRING_PTR(rstr);
+    return
+        (((uint32_t)ptr[i + 0]) << 0 ) |
+        (((uint32_t)ptr[i + 1]) << 8 ) |
+        (((uint32_t)ptr[i + 2]) << 16 ) |
+        (((uint32_t)ptr[i + 3]) << 24 ) |
+        (uint32_t)0;
 }
 
-static int64_t
-safe_int64_t(VALUE i)
+static int32_t
+get_sint32_le(VALUE rstr, VALUE ri)
 {
-    if (FIXNUM_P(i)) {
-        return NUM2I64(i);
-    }
-    else {
-        VALUE argm = UINT2NUM(0xffffffff);
-        VALUE arg32 = INT2FIX(32);
-        uint64_t i0 = NUM2I64(rb_funcall2(i, band, 1, &argm));
-        i = rb_funcall2(i, rshft, 1, &arg32);
-        return i0 + (NUM2I64(rb_funcall2(i, band, 1, &argm)) << 32);
-    }
+    int32_t res = (int32_t)get_int32_le(rstr, ri);
+    return res;
 }
 
 static VALUE
-check_argc(int argc, VALUE *argv)
+rb_get_int32_le(int argc, VALUE *argv, VALUE self)
 {
-    if (argc == 0 || argc > 2) {
-        rb_raise(rb_eArgError, "accepts 1 or 2 arguments: (string[, offset=0])");
-    }
-    return argc == 2 ? argv[1] : INT2FIX(0);
+    return UINT2NUM(get_int32_le(argv[0], check_argc(argc, argv)));
 }
 
-/**** GET ****/
-/**** 32bit ***/
 static VALUE
-rb_get_int8(int argc, VALUE *argv, VALUE self)
+rb_get_sint32_le(int argc, VALUE *argv, VALUE self)
 {
-    return INT2FIX(get_int8(argv[0], check_argc(argc, argv)));
+    return INT2NUM(get_sint32_le(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
-rb_get_sint8(int argc, VALUE *argv, VALUE self)
+rb_slice_int32_le(VALUE self, VALUE rstr)
 {
-    return INT2FIX(get_sint8(argv[0], check_argc(argc, argv)));
+    uint32_t res = get_int32_le(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 4);
+    return UINT2NUM(res);
 }
 
 static VALUE
-rb_get_int16_le(int argc, VALUE *argv, VALUE self)
+rb_slice_sint32_le(VALUE self, VALUE rstr)
 {
-    return INT2FIX(get_int16_le(argv[0], check_argc(argc, argv)));
+    int32_t res = get_sint32_le(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 4);
+    return INT2NUM(res);
 }
 
-static VALUE
-rb_get_sint16_le(int argc, VALUE *argv, VALUE self)
+static void
+append_int32_le(VALUE rstr, int32_t v)
 {
-    return INT2FIX(get_sint16_le(argv[0], check_argc(argc, argv)));
+    char a[] = {
+                (v >> 0) & 0xff,
+                (v >> 8) & 0xff,
+                (v >> 16) & 0xff,
+                (v >> 24) & 0xff,
+        0
+    };
+    rb_str_cat(rstr, a, 4);
 }
 
 static VALUE
-rb_get_int16_be(int argc, VALUE *argv, VALUE self)
+append_var_int32_le(int argc, VALUE* argv, VALUE str)
 {
-    return INT2FIX(get_int16_be(argv[0], check_argc(argc, argv)));
-}
+    int i;
+    for(i = 0; i < argc; i++) {
 
-static VALUE
-rb_get_sint16_be(int argc, VALUE *argv, VALUE self)
-{
-    return INT2FIX(get_sint16_be(argv[0], check_argc(argc, argv)));
+        append_int32_le(str, (int32_t)NUM2I64(argv[i]));
+
+    }
+    return str;
 }
 
 static VALUE
-rb_get_int24_le(int argc, VALUE *argv, VALUE self)
+rb_append_int32_le(int argc, VALUE* argv, VALUE self)
 {
-    return INT2FIX(get_int24_le(argv[0], check_argc(argc, argv)));
+    append_args args;
+    check_argc_append(argc, argv, &args, 32);
+    return append_var_int32_le(args.argc, args.argv, args.str);
 }
 
-static VALUE
-rb_get_sint24_le(int argc, VALUE *argv, VALUE self)
+static uint32_t
+get_int16_be(VALUE rstr, VALUE ri)
 {
-    return INT2FIX(get_sint24_le(argv[0], check_argc(argc, argv)));
+    long i = NUM2LONG(ri);
+    const uint8_t *ptr;
+    StringValue(rstr);
+    i = check_size(i, RSTRING_LEN(rstr), 2);
+    ptr = (const uint8_t*)RSTRING_PTR(rstr);
+    return
+        (((uint32_t)ptr[i + 1]) << 0 ) |
+        (((uint32_t)ptr[i + 0]) << 8 ) |
+        (uint32_t)0;
 }
 
-static VALUE
-rb_get_int24_be(int argc, VALUE *argv, VALUE self)
+static int32_t
+get_sint16_be(VALUE rstr, VALUE ri)
 {
-    return INT2FIX(get_int24_be(argv[0], check_argc(argc, argv)));
+    int32_t res = (int32_t)get_int16_be(rstr, ri);
+    return res - ((res >> 15) << 16);
 }
 
 static VALUE
-rb_get_sint24_be(int argc, VALUE *argv, VALUE self)
+rb_get_int16_be(int argc, VALUE *argv, VALUE self)
 {
-    return INT2FIX(get_sint24_be(argv[0], check_argc(argc, argv)));
+    return INT2FIX(get_int16_be(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
-rb_get_int32_le(int argc, VALUE *argv, VALUE self)
+rb_get_sint16_be(int argc, VALUE *argv, VALUE self)
 {
-    return UINT2NUM(get_int32_le(argv[0], check_argc(argc, argv)));
+    return INT2FIX(get_sint16_be(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
-rb_get_sint32_le(int argc, VALUE *argv, VALUE self)
+rb_slice_int16_be(VALUE self, VALUE rstr)
 {
-    return INT2NUM(get_sint32_le(argv[0], check_argc(argc, argv)));
+    uint32_t res = get_int16_be(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 2);
+    return INT2FIX(res);
 }
 
 static VALUE
-rb_get_int32_be(int argc, VALUE *argv, VALUE self)
+rb_slice_sint16_be(VALUE self, VALUE rstr)
 {
-    return UINT2NUM(get_int32_be(argv[0], check_argc(argc, argv)));
+    int32_t res = get_sint16_be(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 2);
+    return INT2FIX(res);
 }
 
-static VALUE
-rb_get_sint32_be(int argc, VALUE *argv, VALUE self)
+static void
+append_int16_be(VALUE rstr, int32_t v)
 {
-    return INT2NUM(get_sint32_be(argv[0], check_argc(argc, argv)));
+    char a[] = {
+                (v >> 8) & 0xff,
+                (v >> 0) & 0xff,
+        0
+    };
+    rb_str_cat(rstr, a, 2);
 }
-/*** 32BIT END ***/
 
-/*** 64BIT ***/
 static VALUE
-rb_get_int40_le(int argc, VALUE *argv, VALUE self)
+append_var_int16_be(int argc, VALUE* argv, VALUE str)
 {
-    return I642NUM(get_int40_le(argv[0], check_argc(argc, argv)));
+    int i;
+    for(i = 0; i < argc; i++) {
+
+        append_int16_be(str, NUM2INT(argv[i]));
+
+    }
+    return str;
 }
 
 static VALUE
-rb_get_sint40_le(int argc, VALUE *argv, VALUE self)
+rb_append_int16_be(int argc, VALUE* argv, VALUE self)
 {
-    return I642NUM(get_sint40_le(argv[0], check_argc(argc, argv)));
+    append_args args;
+    check_argc_append(argc, argv, &args, 16);
+    return append_var_int16_be(args.argc, args.argv, args.str);
 }
 
-static VALUE
-rb_get_int40_be(int argc, VALUE *argv, VALUE self)
+static uint32_t
+get_int24_be(VALUE rstr, VALUE ri)
 {
-    return I642NUM(get_int40_be(argv[0], check_argc(argc, argv)));
+    long i = NUM2LONG(ri);
+    const uint8_t *ptr;
+    StringValue(rstr);
+    i = check_size(i, RSTRING_LEN(rstr), 3);
+    ptr = (const uint8_t*)RSTRING_PTR(rstr);
+    return
+        (((uint32_t)ptr[i + 2]) << 0 ) |
+        (((uint32_t)ptr[i + 1]) << 8 ) |
+        (((uint32_t)ptr[i + 0]) << 16 ) |
+        (uint32_t)0;
 }
 
-static VALUE
-rb_get_sint40_be(int argc, VALUE *argv, VALUE self)
+static int32_t
+get_sint24_be(VALUE rstr, VALUE ri)
 {
-    return I642NUM(get_sint40_be(argv[0], check_argc(argc, argv)));
+    int32_t res = (int32_t)get_int24_be(rstr, ri);
+    return res - ((res >> 23) << 24);
 }
 
 static VALUE
-rb_get_int48_le(int argc, VALUE *argv, VALUE self)
+rb_get_int24_be(int argc, VALUE *argv, VALUE self)
 {
-    return I642NUM(get_int48_le(argv[0], check_argc(argc, argv)));
+    return INT2FIX(get_int24_be(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
-rb_get_sint48_le(int argc, VALUE *argv, VALUE self)
+rb_get_sint24_be(int argc, VALUE *argv, VALUE self)
 {
-    return I642NUM(get_sint48_le(argv[0], check_argc(argc, argv)));
+    return INT2FIX(get_sint24_be(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
-rb_get_int48_be(int argc, VALUE *argv, VALUE self)
+rb_slice_int24_be(VALUE self, VALUE rstr)
 {
-    return I642NUM(get_int48_be(argv[0], check_argc(argc, argv)));
+    uint32_t res = get_int24_be(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 3);
+    return INT2FIX(res);
 }
 
 static VALUE
-rb_get_sint48_be(int argc, VALUE *argv, VALUE self)
+rb_slice_sint24_be(VALUE self, VALUE rstr)
 {
-    return I642NUM(get_sint48_be(argv[0], check_argc(argc, argv)));
+    int32_t res = get_sint24_be(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 3);
+    return INT2FIX(res);
 }
 
-static VALUE
-rb_get_int56_le(int argc, VALUE *argv, VALUE self)
+static void
+append_int24_be(VALUE rstr, int32_t v)
 {
-    return I642NUM(get_int56_le(argv[0], check_argc(argc, argv)));
+    char a[] = {
+                (v >> 16) & 0xff,
+                (v >> 8) & 0xff,
+                (v >> 0) & 0xff,
+        0
+    };
+    rb_str_cat(rstr, a, 3);
 }
 
 static VALUE
-rb_get_sint56_le(int argc, VALUE *argv, VALUE self)
+append_var_int24_be(int argc, VALUE* argv, VALUE str)
 {
-    return I642NUM(get_sint56_le(argv[0], check_argc(argc, argv)));
+    int i;
+    for(i = 0; i < argc; i++) {
+
+        append_int24_be(str, NUM2INT(argv[i]));
+
+    }
+    return str;
 }
 
 static VALUE
-rb_get_int56_be(int argc, VALUE *argv, VALUE self)
+rb_append_int24_be(int argc, VALUE* argv, VALUE self)
 {
-    return I642NUM(get_int56_be(argv[0], check_argc(argc, argv)));
+    append_args args;
+    check_argc_append(argc, argv, &args, 24);
+    return append_var_int24_be(args.argc, args.argv, args.str);
 }
 
-static VALUE
-rb_get_sint56_be(int argc, VALUE *argv, VALUE self)
+static uint32_t
+get_int32_be(VALUE rstr, VALUE ri)
 {
-    return I642NUM(get_sint56_be(argv[0], check_argc(argc, argv)));
+    long i = NUM2LONG(ri);
+    const uint8_t *ptr;
+    StringValue(rstr);
+    i = check_size(i, RSTRING_LEN(rstr), 4);
+    ptr = (const uint8_t*)RSTRING_PTR(rstr);
+    return
+        (((uint32_t)ptr[i + 3]) << 0 ) |
+        (((uint32_t)ptr[i + 2]) << 8 ) |
+        (((uint32_t)ptr[i + 1]) << 16 ) |
+        (((uint32_t)ptr[i + 0]) << 24 ) |
+        (uint32_t)0;
 }
 
-static VALUE
-rb_get_int64_le(int argc, VALUE *argv, VALUE self)
+static int32_t
+get_sint32_be(VALUE rstr, VALUE ri)
 {
-    return U642NUM(get_int64_le(argv[0], check_argc(argc, argv)));
+    int32_t res = (int32_t)get_int32_be(rstr, ri);
+    return res;
 }
 
 static VALUE
-rb_get_sint64_le(int argc, VALUE *argv, VALUE self)
+rb_get_int32_be(int argc, VALUE *argv, VALUE self)
 {
-    return I642NUM(get_sint64_le(argv[0], check_argc(argc, argv)));
+    return UINT2NUM(get_int32_be(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
-rb_get_int64_be(int argc, VALUE *argv, VALUE self)
+rb_get_sint32_be(int argc, VALUE *argv, VALUE self)
 {
-    return U642NUM(get_int64_be(argv[0], check_argc(argc, argv)));
+    return INT2NUM(get_sint32_be(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
-rb_get_sint64_be(int argc, VALUE *argv, VALUE self)
+rb_slice_int32_be(VALUE self, VALUE rstr)
 {
-    return I642NUM(get_sint64_be(argv[0], check_argc(argc, argv)));
+    uint32_t res = get_int32_be(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 4);
+    return UINT2NUM(res);
 }
-/*** 64BIT END ***/
 
 static VALUE
-rb_get_ber(int argc, VALUE *argv, VALUE self)
+rb_slice_sint32_be(VALUE self, VALUE rstr)
 {
-    return U642NUM(get_ber(argv[0], check_argc(argc, argv)));
+    int32_t res = get_sint32_be(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 4);
+    return INT2NUM(res);
 }
-/** GET END **/
 
-/** SLICE **/
-/*** 32BIT ***/
-static VALUE
-rb_slice_int8(VALUE self, VALUE rstr)
+static void
+append_int32_be(VALUE rstr, int32_t v)
 {
-    int32_t res = get_int8(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 1);
-    return INT2FIX(res);
+    char a[] = {
+                (v >> 24) & 0xff,
+                (v >> 16) & 0xff,
+                (v >> 8) & 0xff,
+                (v >> 0) & 0xff,
+        0
+    };
+    rb_str_cat(rstr, a, 4);
 }
 
 static VALUE
-rb_slice_sint8(VALUE self, VALUE rstr)
+append_var_int32_be(int argc, VALUE* argv, VALUE str)
 {
-    int32_t res = get_sint8(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 1);
-    return INT2FIX(res);
-}
+    int i;
+    for(i = 0; i < argc; i++) {
 
-static VALUE
-rb_slice_int16_le(VALUE self, VALUE rstr)
-{
-    int32_t res = get_int16_le(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 2);
-    return INT2FIX(res);
-}
+        append_int32_be(str, (int32_t)NUM2I64(argv[i]));
 
-static VALUE
-rb_slice_sint16_le(VALUE self, VALUE rstr)
-{
-    int32_t res = get_sint16_le(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 2);
-    return INT2FIX(res);
+    }
+    return str;
 }
 
 static VALUE
-rb_slice_int16_be(VALUE self, VALUE rstr)
+rb_append_int32_be(int argc, VALUE* argv, VALUE self)
 {
-    int32_t res = get_int16_be(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 2);
-    return INT2FIX(res);
+    append_args args;
+    check_argc_append(argc, argv, &args, 32);
+    return append_var_int32_be(args.argc, args.argv, args.str);
 }
 
-static VALUE
-rb_slice_sint16_be(VALUE self, VALUE rstr)
+
+
+
+static uint64_t
+get_int40_le(VALUE rstr, VALUE ri)
 {
-    int32_t res = get_sint16_be(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 2);
-    return INT2FIX(res);
+    long i = NUM2LONG(ri);
+    const uint8_t *ptr;
+    StringValue(rstr);
+    i = check_size(i, RSTRING_LEN(rstr), 5);
+    ptr = (const uint8_t*)RSTRING_PTR(rstr);
+    return (uint64_t)(
+        (((uint32_t)ptr[i + 0]) << 0) |
+        (((uint32_t)ptr[i + 1]) << 8) |
+        (((uint32_t)ptr[i + 2]) << 16) |
+        (((uint32_t)ptr[i + 3]) << 24) |
+        0) | ((uint64_t)(
+        (((uint32_t)ptr[i + 4]) << 0) |
+        0) << 32);
 }
 
-static VALUE
-rb_slice_int24_le(VALUE self, VALUE rstr)
+static int64_t
+get_sint40_le(VALUE rstr, VALUE ri)
 {
-    int32_t res = get_int24_le(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 3);
-    return INT2FIX(res);
+    int64_t res = (int64_t)get_int40_le(rstr, ri);
+    return res - ((res >> 39) << 40);
 }
 
 static VALUE
-rb_slice_sint24_le(VALUE self, VALUE rstr)
+rb_get_int40_le(int argc, VALUE *argv, VALUE self)
 {
-    int32_t res = get_sint24_le(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 3);
-    return INT2FIX(res);
+    return I642NUM(get_int40_le(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
-rb_slice_int24_be(VALUE self, VALUE rstr)
+rb_get_sint40_le(int argc, VALUE *argv, VALUE self)
 {
-    int32_t res = get_int24_be(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 3);
-    return INT2FIX(res);
+    return I642NUM(get_sint40_le(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
-rb_slice_sint24_be(VALUE self, VALUE rstr)
+rb_slice_int40_le(VALUE self, VALUE rstr)
 {
-    int32_t res = get_sint24_be(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 3);
-    return INT2FIX(res);
+    uint64_t res = get_int40_le(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 5);
+    return I642NUM(res);
 }
 
 static VALUE
-rb_slice_int32_le(VALUE self, VALUE rstr)
+rb_slice_sint40_le(VALUE self, VALUE rstr)
 {
-    uint32_t res = get_int32_le(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 4);
-    return UINT2NUM(res);
+    uint64_t res = get_sint40_le(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 5);
+    return I642NUM(res);
 }
 
-static VALUE
-rb_slice_sint32_le(VALUE self, VALUE rstr)
+static void
+append_int40_le(VALUE rstr, int64_t v)
 {
-    int32_t res = get_sint32_le(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 4);
-    return INT2NUM(res);
+    char a[] = {
+                (v >> 0) & 0xff,
+                (v >> 8) & 0xff,
+                (v >> 16) & 0xff,
+                (v >> 24) & 0xff,
+                (v >> 32) & 0xff,
+        0
+    };
+    rb_str_cat(rstr, a, 5);
 }
 
 static VALUE
-rb_slice_int32_be(VALUE self, VALUE rstr)
+append_var_int40_le(int argc, VALUE* argv, VALUE str)
 {
-    uint32_t res = get_int32_be(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 4);
-    return UINT2NUM(res);
+    int i;
+    for(i = 0; i < argc; i++) {
+
+        append_int40_le(str, NUM2I64(argv[i]));
+
+    }
+    return str;
 }
 
 static VALUE
-rb_slice_sint32_be(VALUE self, VALUE rstr)
+rb_append_int40_le(int argc, VALUE* argv, VALUE self)
 {
-    int32_t res = get_sint32_be(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 4);
-    return INT2NUM(res);
+    append_args args;
+    check_argc_append(argc, argv, &args, 40);
+    return append_var_int40_le(args.argc, args.argv, args.str);
 }
-/*** 32BIT END ***/
 
-/*** 64BIT ***/
-static VALUE
-rb_slice_int40_le(VALUE self, VALUE rstr)
+static uint64_t
+get_int48_le(VALUE rstr, VALUE ri)
 {
-    int64_t res = get_int40_le(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 5);
-    return I642NUM(res);
+    long i = NUM2LONG(ri);
+    const uint8_t *ptr;
+    StringValue(rstr);
+    i = check_size(i, RSTRING_LEN(rstr), 6);
+    ptr = (const uint8_t*)RSTRING_PTR(rstr);
+    return (uint64_t)(
+        (((uint32_t)ptr[i + 0]) << 0) |
+        (((uint32_t)ptr[i + 1]) << 8) |
+        (((uint32_t)ptr[i + 2]) << 16) |
+        (((uint32_t)ptr[i + 3]) << 24) |
+        0) | ((uint64_t)(
+        (((uint32_t)ptr[i + 4]) << 0) |
+        (((uint32_t)ptr[i + 5]) << 8) |
+        0) << 32);
 }
 
-static VALUE
-rb_slice_sint40_le(VALUE self, VALUE rstr)
+static int64_t
+get_sint48_le(VALUE rstr, VALUE ri)
 {
-    int64_t res = get_sint40_le(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 5);
-    return I642NUM(res);
+    int64_t res = (int64_t)get_int48_le(rstr, ri);
+    return res - ((res >> 47) << 48);
 }
 
 static VALUE
-rb_slice_int40_be(VALUE self, VALUE rstr)
+rb_get_int48_le(int argc, VALUE *argv, VALUE self)
 {
-    int64_t res = get_int40_be(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 5);
-    return I642NUM(res);
+    return I642NUM(get_int48_le(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
-rb_slice_sint40_be(VALUE self, VALUE rstr)
+rb_get_sint48_le(int argc, VALUE *argv, VALUE self)
 {
-    int64_t res = get_sint40_be(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 5);
-    return I642NUM(res);
+    return I642NUM(get_sint48_le(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
 rb_slice_int48_le(VALUE self, VALUE rstr)
 {
-    int64_t res = get_int48_le(rstr, INT2FIX(0));
+    uint64_t res = get_int48_le(rstr, INT2FIX(0));
     rb_str_drop_bytes(rstr, 6);
     return I642NUM(res);
 }
@@ -870,476 +865,669 @@ rb_slice_int48_le(VALUE self, VALUE rstr)
 static VALUE
 rb_slice_sint48_le(VALUE self, VALUE rstr)
 {
-    int64_t res = get_sint48_le(rstr, INT2FIX(0));
+    uint64_t res = get_sint48_le(rstr, INT2FIX(0));
     rb_str_drop_bytes(rstr, 6);
     return I642NUM(res);
 }
 
-static VALUE
-rb_slice_int48_be(VALUE self, VALUE rstr)
+static void
+append_int48_le(VALUE rstr, int64_t v)
 {
-    int64_t res = get_int48_be(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 6);
-    return I642NUM(res);
+    char a[] = {
+                (v >> 0) & 0xff,
+                (v >> 8) & 0xff,
+                (v >> 16) & 0xff,
+                (v >> 24) & 0xff,
+                (v >> 32) & 0xff,
+                (v >> 40) & 0xff,
+        0
+    };
+    rb_str_cat(rstr, a, 6);
 }
 
 static VALUE
-rb_slice_sint48_be(VALUE self, VALUE rstr)
+append_var_int48_le(int argc, VALUE* argv, VALUE str)
 {
-    int64_t res = get_sint48_be(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 6);
-    return I642NUM(res);
+    int i;
+    for(i = 0; i < argc; i++) {
+
+        append_int48_le(str, NUM2I64(argv[i]));
+
+    }
+    return str;
 }
 
 static VALUE
-rb_slice_int56_le(VALUE self, VALUE rstr)
+rb_append_int48_le(int argc, VALUE* argv, VALUE self)
 {
-    int64_t res = get_int56_le(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 7);
-    return I642NUM(res);
+    append_args args;
+    check_argc_append(argc, argv, &args, 48);
+    return append_var_int48_le(args.argc, args.argv, args.str);
+}
+
+static uint64_t
+get_int56_le(VALUE rstr, VALUE ri)
+{
+    long i = NUM2LONG(ri);
+    const uint8_t *ptr;
+    StringValue(rstr);
+    i = check_size(i, RSTRING_LEN(rstr), 7);
+    ptr = (const uint8_t*)RSTRING_PTR(rstr);
+    return (uint64_t)(
+        (((uint32_t)ptr[i + 0]) << 0) |
+        (((uint32_t)ptr[i + 1]) << 8) |
+        (((uint32_t)ptr[i + 2]) << 16) |
+        (((uint32_t)ptr[i + 3]) << 24) |
+        0) | ((uint64_t)(
+        (((uint32_t)ptr[i + 4]) << 0) |
+        (((uint32_t)ptr[i + 5]) << 8) |
+        (((uint32_t)ptr[i + 6]) << 16) |
+        0) << 32);
+}
+
+static int64_t
+get_sint56_le(VALUE rstr, VALUE ri)
+{
+    int64_t res = (int64_t)get_int56_le(rstr, ri);
+    return res - ((res >> 55) << 56);
 }
 
 static VALUE
-rb_slice_sint56_le(VALUE self, VALUE rstr)
+rb_get_int56_le(int argc, VALUE *argv, VALUE self)
 {
-    int64_t res = get_sint56_le(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 7);
-    return I642NUM(res);
+    return I642NUM(get_int56_le(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
-rb_slice_int56_be(VALUE self, VALUE rstr)
+rb_get_sint56_le(int argc, VALUE *argv, VALUE self)
 {
-    int64_t res = get_int56_be(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 7);
-    return I642NUM(res);
+    return I642NUM(get_sint56_le(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
-rb_slice_sint56_be(VALUE self, VALUE rstr)
+rb_slice_int56_le(VALUE self, VALUE rstr)
 {
-    int64_t res = get_sint56_be(rstr, INT2FIX(0));
+    uint64_t res = get_int56_le(rstr, INT2FIX(0));
     rb_str_drop_bytes(rstr, 7);
     return I642NUM(res);
 }
 
 static VALUE
-rb_slice_int64_le(VALUE self, VALUE rstr)
+rb_slice_sint56_le(VALUE self, VALUE rstr)
 {
-    uint64_t res = get_int64_le(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 8);
-    return U642NUM(res);
+    uint64_t res = get_sint56_le(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 7);
+    return I642NUM(res);
 }
 
-static VALUE
-rb_slice_sint64_le(VALUE self, VALUE rstr)
+static void
+append_int56_le(VALUE rstr, int64_t v)
 {
-    int64_t res = get_sint64_le(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 8);
-    return I642NUM(res);
+    char a[] = {
+                (v >> 0) & 0xff,
+                (v >> 8) & 0xff,
+                (v >> 16) & 0xff,
+                (v >> 24) & 0xff,
+                (v >> 32) & 0xff,
+                (v >> 40) & 0xff,
+                (v >> 48) & 0xff,
+        0
+    };
+    rb_str_cat(rstr, a, 7);
 }
 
 static VALUE
-rb_slice_int64_be(VALUE self, VALUE rstr)
+append_var_int56_le(int argc, VALUE* argv, VALUE str)
 {
-    uint64_t res = get_int64_be(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 8);
-    return U642NUM(res);
+    int i;
+    for(i = 0; i < argc; i++) {
+
+        append_int56_le(str, NUM2I64(argv[i]));
+
+    }
+    return str;
 }
 
 static VALUE
-rb_slice_sint64_be(VALUE self, VALUE rstr)
+rb_append_int56_le(int argc, VALUE* argv, VALUE self)
 {
-    int64_t res = get_sint64_be(rstr, INT2FIX(0));
-    rb_str_drop_bytes(rstr, 8);
-    return I642NUM(res);
+    append_args args;
+    check_argc_append(argc, argv, &args, 56);
+    return append_var_int56_le(args.argc, args.argv, args.str);
 }
-/*** 64BIT END ***/
 
 static uint64_t
-slice_ber(VALUE rstr, long *i)
+get_int64_le(VALUE rstr, VALUE ri)
 {
-    long len;
+    long i = NUM2LONG(ri);
     const uint8_t *ptr;
     StringValue(rstr);
-    len = RSTRING_LEN(rstr);
+    i = check_size(i, RSTRING_LEN(rstr), 8);
     ptr = (const uint8_t*)RSTRING_PTR(rstr);
-    return parse_ber(ptr, len, i);
+    return (uint64_t)(
+        (((uint32_t)ptr[i + 0]) << 0) |
+        (((uint32_t)ptr[i + 1]) << 8) |
+        (((uint32_t)ptr[i + 2]) << 16) |
+        (((uint32_t)ptr[i + 3]) << 24) |
+        0) | ((uint64_t)(
+        (((uint32_t)ptr[i + 4]) << 0) |
+        (((uint32_t)ptr[i + 5]) << 8) |
+        (((uint32_t)ptr[i + 6]) << 16) |
+        (((uint32_t)ptr[i + 7]) << 24) |
+        0) << 32);
+}
+
+static int64_t
+get_sint64_le(VALUE rstr, VALUE ri)
+{
+    int64_t res = (int64_t)get_int64_le(rstr, ri);
+    return res;
 }
 
 static VALUE
-rb_slice_ber(VALUE self, VALUE rstr)
+rb_get_int64_le(int argc, VALUE *argv, VALUE self)
 {
-    long i = 0;
-    int64_t res = slice_ber(rstr, &i);
-    rb_str_drop_bytes(rstr, i+1);
+    return U642NUM(get_int64_le(argv[0], check_argc(argc, argv)));
+}
+
+static VALUE
+rb_get_sint64_le(int argc, VALUE *argv, VALUE self)
+{
+    return I642NUM(get_sint64_le(argv[0], check_argc(argc, argv)));
+}
+
+static VALUE
+rb_slice_int64_le(VALUE self, VALUE rstr)
+{
+    uint64_t res = get_int64_le(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 8);
     return U642NUM(res);
 }
-/** SLICE END **/
 
-/** APPEND **/
-static void
-append_int8(VALUE rstr, int32_t v)
+static VALUE
+rb_slice_sint64_le(VALUE self, VALUE rstr)
 {
-    char a[1] = {v & 255};
-    rb_str_cat(rstr, a, 1);
+    uint64_t res = get_sint64_le(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 8);
+    return I642NUM(res);
 }
 
 static void
-append_int16_le(VALUE rstr, int32_t v)
+append_int64_le(VALUE rstr, int64_t v)
 {
-    char a[2] = {v & 255, (v >> 8) & 255};
-    rb_str_cat(rstr, a, 2);
+    char a[] = {
+                (v >> 0) & 0xff,
+                (v >> 8) & 0xff,
+                (v >> 16) & 0xff,
+                (v >> 24) & 0xff,
+                (v >> 32) & 0xff,
+                (v >> 40) & 0xff,
+                (v >> 48) & 0xff,
+                (v >> 56) & 0xff,
+        0
+    };
+    rb_str_cat(rstr, a, 8);
 }
 
-static void
-append_int16_be(VALUE rstr, int32_t v)
+static VALUE
+append_var_int64_le(int argc, VALUE* argv, VALUE str)
 {
-    char a[2] = {(v >> 8) & 255, v & 255};
-    rb_str_cat(rstr, a, 2);
+    int i;
+    for(i = 0; i < argc; i++) {
+
+        append_int64_le(str, safe_int64_t(argv[i]));
+
+    }
+    return str;
 }
 
-static void
-append_int24_le(VALUE rstr, int32_t v)
+static VALUE
+rb_append_int64_le(int argc, VALUE* argv, VALUE self)
 {
-    char a[3] = {v & 255, (v >> 8) & 255, (v >> 16) & 255};
-    rb_str_cat(rstr, a, 3);
+    append_args args;
+    check_argc_append(argc, argv, &args, 64);
+    return append_var_int64_le(args.argc, args.argv, args.str);
 }
 
-static void
-append_int24_be(VALUE rstr, int32_t v)
+static uint64_t
+get_int40_be(VALUE rstr, VALUE ri)
 {
-    char a[3] = {(v >> 16) & 255, (v >> 8) & 255, v & 255};
-    rb_str_cat(rstr, a, 3);
+    long i = NUM2LONG(ri);
+    const uint8_t *ptr;
+    StringValue(rstr);
+    i = check_size(i, RSTRING_LEN(rstr), 5);
+    ptr = (const uint8_t*)RSTRING_PTR(rstr);
+    return (uint64_t)(
+        (((uint32_t)ptr[i + 4]) << 0) |
+        (((uint32_t)ptr[i + 3]) << 8) |
+        (((uint32_t)ptr[i + 2]) << 16) |
+        (((uint32_t)ptr[i + 1]) << 24) |
+        0) | ((uint64_t)(
+        (((uint32_t)ptr[i + 0]) << 0) |
+        0) << 32);
 }
 
-static void
-append_int32_le(VALUE rstr, int32_t v)
+static int64_t
+get_sint40_be(VALUE rstr, VALUE ri)
 {
-    char a[4] = {v & 255, (v >> 8) & 255, (v >> 16) & 255, (v >> 24) & 255};
-    rb_str_cat(rstr, a, 4);
+    int64_t res = (int64_t)get_int40_be(rstr, ri);
+    return res - ((res >> 39) << 40);
 }
 
-static void
-append_int32_be(VALUE rstr, int32_t v)
+static VALUE
+rb_get_int40_be(int argc, VALUE *argv, VALUE self)
 {
-    char a[4] = {(v >> 24) & 255, (v >> 16) & 255, (v >> 8) & 255, v & 255};
-    rb_str_cat(rstr, a, 4);
+    return I642NUM(get_int40_be(argv[0], check_argc(argc, argv)));
 }
 
-static void
-append_int40_le(VALUE rstr, int64_t v)
+static VALUE
+rb_get_sint40_be(int argc, VALUE *argv, VALUE self)
 {
-    char a[5] = {v & 255, (v >> 8) & 255, (v >> 16) & 255, (v >> 24) & 255,
-                 (v >> 32) & 255};
-    rb_str_cat(rstr, a, 5);
+    return I642NUM(get_sint40_be(argv[0], check_argc(argc, argv)));
 }
 
-static void
-append_int40_be(VALUE rstr, int64_t v)
+static VALUE
+rb_slice_int40_be(VALUE self, VALUE rstr)
 {
-    char a[5] = {(v >> 32) & 255,
-                 (v >> 24) & 255, (v >> 16) & 255, (v >> 8) & 255, v & 255};
-    rb_str_cat(rstr, a, 5);
+    uint64_t res = get_int40_be(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 5);
+    return I642NUM(res);
 }
 
-static void
-append_int48_le(VALUE rstr, int64_t v)
+static VALUE
+rb_slice_sint40_be(VALUE self, VALUE rstr)
 {
-    char a[6] = {v & 255, (v >> 8) & 255, (v >> 16) & 255, (v >> 24) & 255,
-                 (v >> 32) & 255, (v >> 40) & 255};
-    rb_str_cat(rstr, a, 6);
+    uint64_t res = get_sint40_be(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 5);
+    return I642NUM(res);
 }
 
 static void
-append_int48_be(VALUE rstr, int64_t v)
+append_int40_be(VALUE rstr, int64_t v)
 {
-    char a[6] = {(v >> 40) & 255, (v >> 32) & 255,
-                 (v >> 24) & 255, (v >> 16) & 255, (v >> 8) & 255, v & 255};
-    rb_str_cat(rstr, a, 6);
+    char a[] = {
+                (v >> 32) & 0xff,
+                (v >> 24) & 0xff,
+                (v >> 16) & 0xff,
+                (v >> 8) & 0xff,
+                (v >> 0) & 0xff,
+        0
+    };
+    rb_str_cat(rstr, a, 5);
 }
 
-static void
-append_int56_le(VALUE rstr, int64_t v)
+static VALUE
+append_var_int40_be(int argc, VALUE* argv, VALUE str)
 {
-    char a[7] = {v & 255, (v >> 8) & 255, (v >> 16) & 255, (v >> 24) & 255,
-                 (v >> 32) & 255, (v >> 40) & 255, (v >> 48) & 255};
-    rb_str_cat(rstr, a, 7);
+    int i;
+    for(i = 0; i < argc; i++) {
+
+        append_int40_be(str, NUM2I64(argv[i]));
+
+    }
+    return str;
 }
 
-static void
-append_int56_be(VALUE rstr, int64_t v)
+static VALUE
+rb_append_int40_be(int argc, VALUE* argv, VALUE self)
 {
-    char a[7] = {(v >> 48) & 255, (v >> 40) & 255, (v >> 32) & 255,
-                 (v >> 24) & 255, (v >> 16) & 255, (v >> 8) & 255, v & 255};
-    rb_str_cat(rstr, a, 7);
+    append_args args;
+    check_argc_append(argc, argv, &args, 40);
+    return append_var_int40_be(args.argc, args.argv, args.str);
 }
 
-static void
-append_int64_le(VALUE rstr, int64_t v)
+static uint64_t
+get_int48_be(VALUE rstr, VALUE ri)
 {
-    char a[8] = {v & 255, (v >> 8) & 255, (v >> 16) & 255, (v >> 24) & 255,
-                 (v >> 32) & 255, (v >> 40) & 255, (v >> 48) & 255, (v >> 56) & 255};
-    rb_str_cat(rstr, a, 8);
+    long i = NUM2LONG(ri);
+    const uint8_t *ptr;
+    StringValue(rstr);
+    i = check_size(i, RSTRING_LEN(rstr), 6);
+    ptr = (const uint8_t*)RSTRING_PTR(rstr);
+    return (uint64_t)(
+        (((uint32_t)ptr[i + 5]) << 0) |
+        (((uint32_t)ptr[i + 4]) << 8) |
+        (((uint32_t)ptr[i + 3]) << 16) |
+        (((uint32_t)ptr[i + 2]) << 24) |
+        0) | ((uint64_t)(
+        (((uint32_t)ptr[i + 1]) << 0) |
+        (((uint32_t)ptr[i + 0]) << 8) |
+        0) << 32);
 }
 
-static void
-append_int64_be(VALUE rstr, int64_t v)
+static int64_t
+get_sint48_be(VALUE rstr, VALUE ri)
 {
-    char a[8] = {(v >> 56) & 255, (v >> 48) & 255, (v >> 40) & 255, (v >> 32) & 255,
-                 (v >> 24) & 255, (v >> 16) & 255, (v >> 8) & 255, v & 255};
-    rb_str_cat(rstr, a, 8);
+    int64_t res = (int64_t)get_int48_be(rstr, ri);
+    return res - ((res >> 47) << 48);
 }
 
-static int
-append_ber(VALUE rstr, uint64_t ber)
+static VALUE
+rb_get_int48_be(int argc, VALUE *argv, VALUE self)
 {
-    int i = 10;
-    char a[11] = {128, 128, 128, 128,
-                  128, 128 ,128 ,128,
-                  128, 128, 0};
-    do {
-        a[i] += ber % 128;
-        ber /= 128;
-        i--;
-    } while (ber);
-    i++;
-    rb_str_cat(rstr, a+i, 11-i);
-    
-    return 11-i;
+    return I642NUM(get_int48_be(argv[0], check_argc(argc, argv)));
 }
 
-typedef struct append_args {
-    VALUE str;
-    int argc;
-    VALUE *argv;
-} append_args;
+static VALUE
+rb_get_sint48_be(int argc, VALUE *argv, VALUE self)
+{
+    return I642NUM(get_sint48_be(argv[0], check_argc(argc, argv)));
+}
 
-typedef struct append_args2 {
-    VALUE str;
-    int argc;
-    VALUE *argv;
-    VALUE int0;
-} append_args2;
+static VALUE
+rb_slice_int48_be(VALUE self, VALUE rstr)
+{
+    uint64_t res = get_int48_be(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 6);
+    return I642NUM(res);
+}
 
-static void
-check_argc_append(int argc, VALUE *argv, append_args *args, int bits)
+static VALUE
+rb_slice_sint48_be(VALUE self, VALUE rstr)
 {
-    if (argc < 1) {
-        rb_raise(rb_eArgError, "accepts at least 1 argument: (string[, *int%ds])", bits);
-    }
-    args->str = RTEST(argv[0]) ? argv[0] : rb_str_new(0, 0);
-    if (argc == 2 && TYPE(argv[1]) == T_ARRAY) {
-        args->argc = RARRAY_LEN(argv[1]);
-        args->argv = RARRAY_PTR(argv[1]);
-    }
-    else {
-        args->argc = argc-1;
-        args->argv = argv+1;
-    }
+    uint64_t res = get_sint48_be(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 6);
+    return I642NUM(res);
 }
 
 static void
-check_argc_append_2(int argc, VALUE *argv, append_args2 *args, int bits, int bits1)
+append_int48_be(VALUE rstr, int64_t v)
 {
-    if (argc < 2) {
-        rb_raise(rb_eArgError, "accepts at least 2 arguments: (string, int%d[, *int%ds])", bits, bits1);
-    }
-    args->str = RTEST(argv[0]) ? argv[0] : rb_str_new(0, 0);
-    args->int0 = argv[1];
-    if (argc == 3 && TYPE(argv[2]) == T_ARRAY) {
-        args->argc = RARRAY_LEN(argv[2]);
-        args->argv = RARRAY_PTR(argv[2]);
-    }
-    else {
-        args->argc = argc-2;
-        args->argv = argv+2;
-    }
+    char a[] = {
+                (v >> 40) & 0xff,
+                (v >> 32) & 0xff,
+                (v >> 24) & 0xff,
+                (v >> 16) & 0xff,
+                (v >> 8) & 0xff,
+                (v >> 0) & 0xff,
+        0
+    };
+    rb_str_cat(rstr, a, 6);
 }
 
-/*** 32BIT **/
 static VALUE
-append_var_int8(int argc, VALUE* argv, VALUE str)
+append_var_int48_be(int argc, VALUE* argv, VALUE str)
 {
     int i;
     for(i = 0; i < argc; i++) {
-        append_int8(str, NUM2INT(argv[i]));
+
+        append_int48_be(str, NUM2I64(argv[i]));
+
     }
     return str;
 }
-#define append_var_int8_le append_var_int8
-#define append_var_int8_be append_var_int8
 
 static VALUE
-append_var_int16_le(int argc, VALUE* argv, VALUE str)
+rb_append_int48_be(int argc, VALUE* argv, VALUE self)
 {
-    int i;
-    for(i = 0; i < argc; i++) {
-        append_int16_le(str, NUM2INT(argv[i]));
-    }
-    return str;
+    append_args args;
+    check_argc_append(argc, argv, &args, 48);
+    return append_var_int48_be(args.argc, args.argv, args.str);
+}
+
+static uint64_t
+get_int56_be(VALUE rstr, VALUE ri)
+{
+    long i = NUM2LONG(ri);
+    const uint8_t *ptr;
+    StringValue(rstr);
+    i = check_size(i, RSTRING_LEN(rstr), 7);
+    ptr = (const uint8_t*)RSTRING_PTR(rstr);
+    return (uint64_t)(
+        (((uint32_t)ptr[i + 6]) << 0) |
+        (((uint32_t)ptr[i + 5]) << 8) |
+        (((uint32_t)ptr[i + 4]) << 16) |
+        (((uint32_t)ptr[i + 3]) << 24) |
+        0) | ((uint64_t)(
+        (((uint32_t)ptr[i + 2]) << 0) |
+        (((uint32_t)ptr[i + 1]) << 8) |
+        (((uint32_t)ptr[i + 0]) << 16) |
+        0) << 32);
+}
+
+static int64_t
+get_sint56_be(VALUE rstr, VALUE ri)
+{
+    int64_t res = (int64_t)get_int56_be(rstr, ri);
+    return res - ((res >> 55) << 56);
 }
 
 static VALUE
-append_var_int24_le(int argc, VALUE* argv, VALUE str)
+rb_get_int56_be(int argc, VALUE *argv, VALUE self)
 {
-    int i;
-    for(i = 0; i < argc; i++) {
-        append_int24_le(str, NUM2INT(argv[i]));
-    }
-    return str;
+    return I642NUM(get_int56_be(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
-append_var_int32_le(int argc, VALUE* argv, VALUE str)
+rb_get_sint56_be(int argc, VALUE *argv, VALUE self)
 {
-    int i;
-    for(i = 0; i < argc; i++) {
-        append_int32_le(str, (int32_t)NUM2I64(argv[i]));
-    }
-    return str;
+    return I642NUM(get_sint56_be(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
-append_var_int16_be(int argc, VALUE* argv, VALUE str)
+rb_slice_int56_be(VALUE self, VALUE rstr)
 {
-    int i;
-    for(i = 0; i < argc; i++) {
-        append_int16_be(str, NUM2INT(argv[i]));
-    }
-    return str;
+    uint64_t res = get_int56_be(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 7);
+    return I642NUM(res);
 }
 
 static VALUE
-append_var_int24_be(int argc, VALUE* argv, VALUE str)
+rb_slice_sint56_be(VALUE self, VALUE rstr)
 {
-    int i;
-    for(i = 0; i < argc; i++) {
-        append_int24_be(str, NUM2INT(argv[i]));
-    }
-    return str;
+    uint64_t res = get_sint56_be(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 7);
+    return I642NUM(res);
+}
+
+static void
+append_int56_be(VALUE rstr, int64_t v)
+{
+    char a[] = {
+                (v >> 48) & 0xff,
+                (v >> 40) & 0xff,
+                (v >> 32) & 0xff,
+                (v >> 24) & 0xff,
+                (v >> 16) & 0xff,
+                (v >> 8) & 0xff,
+                (v >> 0) & 0xff,
+        0
+    };
+    rb_str_cat(rstr, a, 7);
 }
 
 static VALUE
-append_var_int32_be(int argc, VALUE* argv, VALUE str)
+append_var_int56_be(int argc, VALUE* argv, VALUE str)
 {
     int i;
     for(i = 0; i < argc; i++) {
-        append_int32_be(str, (int32_t)NUM2I64(argv[i]));
+
+        append_int56_be(str, NUM2I64(argv[i]));
+
     }
     return str;
 }
-/*** 32BIT END ***/
 
-/*** 64BIT ***/
 static VALUE
-append_var_int40_le(int argc, VALUE* argv, VALUE str)
+rb_append_int56_be(int argc, VALUE* argv, VALUE self)
 {
-    int i;
-    for(i = 0; i < argc; i++) {
-        append_int40_le(str, NUM2I64(argv[i]));
-    }
-    return str;
+    append_args args;
+    check_argc_append(argc, argv, &args, 56);
+    return append_var_int56_be(args.argc, args.argv, args.str);
+}
+
+static uint64_t
+get_int64_be(VALUE rstr, VALUE ri)
+{
+    long i = NUM2LONG(ri);
+    const uint8_t *ptr;
+    StringValue(rstr);
+    i = check_size(i, RSTRING_LEN(rstr), 8);
+    ptr = (const uint8_t*)RSTRING_PTR(rstr);
+    return (uint64_t)(
+        (((uint32_t)ptr[i + 7]) << 0) |
+        (((uint32_t)ptr[i + 6]) << 8) |
+        (((uint32_t)ptr[i + 5]) << 16) |
+        (((uint32_t)ptr[i + 4]) << 24) |
+        0) | ((uint64_t)(
+        (((uint32_t)ptr[i + 3]) << 0) |
+        (((uint32_t)ptr[i + 2]) << 8) |
+        (((uint32_t)ptr[i + 1]) << 16) |
+        (((uint32_t)ptr[i + 0]) << 24) |
+        0) << 32);
+}
+
+static int64_t
+get_sint64_be(VALUE rstr, VALUE ri)
+{
+    int64_t res = (int64_t)get_int64_be(rstr, ri);
+    return res;
 }
 
 static VALUE
-append_var_int48_le(int argc, VALUE* argv, VALUE str)
+rb_get_int64_be(int argc, VALUE *argv, VALUE self)
 {
-    int i;
-    for(i = 0; i < argc; i++) {
-        append_int48_le(str, NUM2I64(argv[i]));
-    }
-    return str;
+    return U642NUM(get_int64_be(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
-append_var_int56_le(int argc, VALUE* argv, VALUE str)
+rb_get_sint64_be(int argc, VALUE *argv, VALUE self)
 {
-    int i;
-    for(i = 0; i < argc; i++) {
-        append_int56_le(str, NUM2I64(argv[i]));
-    }
-    return str;
+    return I642NUM(get_sint64_be(argv[0], check_argc(argc, argv)));
 }
 
 static VALUE
-append_var_int64_le(int argc, VALUE* argv, VALUE str)
+rb_slice_int64_be(VALUE self, VALUE rstr)
 {
-    int i;
-    for(i = 0; i < argc; i++) {
-        append_int64_le(str, safe_int64_t(argv[i]));
-    }
-    return str;
+    uint64_t res = get_int64_be(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 8);
+    return U642NUM(res);
 }
 
 static VALUE
-append_var_int40_be(int argc, VALUE* argv, VALUE str)
+rb_slice_sint64_be(VALUE self, VALUE rstr)
 {
-    int i;
-    for(i = 0; i < argc; i++) {
-        append_int40_be(str, NUM2I64(argv[i]));
-    }
-    return str;
+    uint64_t res = get_sint64_be(rstr, INT2FIX(0));
+    rb_str_drop_bytes(rstr, 8);
+    return I642NUM(res);
+}
+
+static void
+append_int64_be(VALUE rstr, int64_t v)
+{
+    char a[] = {
+                (v >> 56) & 0xff,
+                (v >> 48) & 0xff,
+                (v >> 40) & 0xff,
+                (v >> 32) & 0xff,
+                (v >> 24) & 0xff,
+                (v >> 16) & 0xff,
+                (v >> 8) & 0xff,
+                (v >> 0) & 0xff,
+        0
+    };
+    rb_str_cat(rstr, a, 8);
 }
 
 static VALUE
-append_var_int48_be(int argc, VALUE* argv, VALUE str)
+append_var_int64_be(int argc, VALUE* argv, VALUE str)
 {
     int i;
     for(i = 0; i < argc; i++) {
-        append_int48_be(str, NUM2I64(argv[i]));
+
+        append_int64_be(str, safe_int64_t(argv[i]));
+
     }
     return str;
 }
 
 static VALUE
-append_var_int56_be(int argc, VALUE* argv, VALUE str)
+rb_append_int64_be(int argc, VALUE* argv, VALUE self)
 {
-    int i;
-    for(i = 0; i < argc; i++) {
-        append_int56_be(str, NUM2I64(argv[i]));
+    append_args args;
+    check_argc_append(argc, argv, &args, 64);
+    return append_var_int64_be(args.argc, args.argv, args.str);
+}
+
+
+/* BER */
+static uint64_t
+parse_ber(const uint8_t *ptr, long max, long *i)
+{
+    uint64_t res = 0;
+    while (1) {
+        if (*ptr < 128) {
+            res += *ptr;
+            break;
+        }
+        if (res > LLU(0xFFFFFFFFFFFFFFFF) / 128) {
+            rb_raise(rb_eArgError, "BER integer is greater then 2**64, could not parse such big");
+        }
+        res = (res + ((*ptr) - 128)) * 128;
+        ptr++;
+        if (++(*i) >= max) {
+            rb_raise(rb_eArgError, "String unexpectedly finished while parsing BER integer");
+        }
     }
-    return str;
+    return res;
+}
+
+static uint64_t
+get_ber(VALUE rstr, VALUE ri)
+{
+    long i = NUM2LONG(ri), len;
+    const uint8_t *ptr;
+    StringValue(rstr);
+    len = RSTRING_LEN(rstr);
+    i = check_size(i, len, 1);
+    ptr = (const uint8_t*)RSTRING_PTR(rstr) + i;
+    return parse_ber(ptr, len, &i);
 }
 
 static VALUE
-append_var_int64_be(int argc, VALUE* argv, VALUE str)
+rb_get_ber(int argc, VALUE *argv, VALUE self)
 {
-    int i;
-    for(i = 0; i < argc; i++) {
-        append_int64_be(str, safe_int64_t(argv[i]));
-    }
-    return str;
+    return U642NUM(get_ber(argv[0], check_argc(argc, argv)));
+}
+
+static uint64_t
+slice_ber(VALUE rstr, long *i)
+{
+    long len;
+    const uint8_t *ptr;
+    StringValue(rstr);
+    len = RSTRING_LEN(rstr);
+    ptr = (const uint8_t*)RSTRING_PTR(rstr);
+    return parse_ber(ptr, len, i);
 }
-/*** 64BIT END **/
 
+static VALUE
+rb_slice_ber(VALUE self, VALUE rstr)
+{
+    long i = 0;
+    int64_t res = slice_ber(rstr, &i);
+    rb_str_drop_bytes(rstr, i+1);
+    return U642NUM(res);
+}
 
-#define append_func(type, bits) \
-static VALUE                                          \
-rb_append_##type(int argc, VALUE* argv, VALUE self)   \
-{                                                     \
-    append_args args;                                 \
-    check_argc_append(argc, argv, &args, bits);       \
-    return append_var_##type(args.argc, args.argv, args.str);\
+static int
+append_ber(VALUE rstr, uint64_t ber)
+{
+    int i = 10;
+    char a[11] = {128, 128, 128, 128,
+                  128, 128 ,128 ,128,
+                  128, 128, 0};
+    do {
+        a[i] += ber % 128;
+        ber /= 128;
+        i--;
+    } while (ber);
+    i++;
+    rb_str_cat(rstr, a+i, 11-i);
+    
+    return 11-i;
 }
 
-append_func(int8, 8)
-append_func(int16_le, 16)
-append_func(int24_le, 24)
-append_func(int32_le, 32)
-append_func(int40_le, 40)
-append_func(int48_le, 48)
-append_func(int56_le, 56)
-append_func(int64_le, 64)
-append_func(int16_be, 16)
-append_func(int24_be, 24)
-append_func(int32_be, 32)
-append_func(int40_be, 40)
-append_func(int48_be, 48)
-append_func(int56_be, 56)
-append_func(int64_be, 64)
-
-/** APPEND END **/
 
 /** APPEND BERSIZE **/
 #define append_bersize_func(type, bytes) \
@@ -1600,7 +1788,7 @@ Init_bin_utils()
     rshft = rb_intern(">>");
     band = rb_intern("&");
 #ifndef HAVE_RB_STR_DROP_BYTES
-    aset = rb_intern("[]=");
+    aslice = rb_intern("slice!");
 #endif
 
     rb_define_method(mod_native, "get_ber", rb_get_ber, -1);