diff --git a/skeletons/OPEN_TYPE.c b/skeletons/OPEN_TYPE.c
index 72bc88c..fc2571b 100644
--- a/skeletons/OPEN_TYPE.c
+++ b/skeletons/OPEN_TYPE.c
@@ -23,8 +23,8 @@
 	0,	/* Use generic outmost tag fetcher */
 };
 
-#undef  XER_ADVANCE
-#define XER_ADVANCE(num_bytes)           \
+#undef  ADVANCE
+#define ADVANCE(num_bytes)               \
     do {                                 \
         size_t num = num_bytes;          \
         ptr = ((const char *)ptr) + num; \
@@ -33,6 +33,84 @@
     } while(0)
 
 asn_dec_rval_t
+OPEN_TYPE_ber_get(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+                  void *sptr, asn_TYPE_member_t *elm, const void *ptr,
+                  size_t size) {
+    size_t consumed_myself = 0;
+    asn_type_selector_result_t selected;
+    void *memb_ptr;   /* Pointer to the member */
+    void **memb_ptr2; /* Pointer to that pointer */
+    void *inner_value;
+    asn_dec_rval_t rv;
+
+    if(!(elm->flags & ATF_OPEN_TYPE) || !elm->type_selector) {
+        ASN__DECODE_FAILED;
+    }
+
+    selected = elm->type_selector(td, sptr);
+    if(!selected.presence_index) {
+        ASN__DECODE_FAILED;
+    }
+
+    /* Fetch the pointer to this member */
+    if(elm->flags & ATF_POINTER) {
+        memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
+    } else {
+        memb_ptr = (char *)sptr + elm->memb_offset;
+        memb_ptr2 = &memb_ptr;
+    }
+    if(*memb_ptr2 != NULL) {
+        /* Make sure we reset the structure first before encoding */
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2, 0) != 0) {
+            ASN__DECODE_FAILED;
+        }
+    }
+
+    inner_value =
+        (char *)*memb_ptr2
+        + elm->type->elements[selected.presence_index - 1].memb_offset;
+
+    ASN_DEBUG("presence %d\n", selected.presence_index);
+
+    rv = selected.type_descriptor->op->ber_decoder(
+        opt_codec_ctx, selected.type_descriptor, &inner_value, ptr, size,
+        elm->tag_mode);
+    ADVANCE(rv.consumed);
+    rv.consumed = 0;
+    switch(rv.code) {
+    case RC_OK:
+        if(CHOICE_variant_set_presence(elm->type, *memb_ptr2,
+                                       selected.presence_index)
+           == 0) {
+            rv.code = RC_OK;
+            rv.consumed = consumed_myself;
+            return rv;
+        } else {
+            /* Oh, now a full-blown failure failure */
+        }
+        /* Fall through */
+    case RC_FAIL:
+        rv.consumed = consumed_myself;
+        /* Fall through */
+    case RC_WMORE:
+        break;
+    }
+
+    if(*memb_ptr2) {
+        asn_CHOICE_specifics_t *specs = selected.type_descriptor->specifics;
+        if(elm->flags & ATF_POINTER) {
+            ASN_STRUCT_FREE(*selected.type_descriptor, inner_value);
+            *memb_ptr2 = NULL;
+        } else {
+            ASN_STRUCT_FREE_CONTENTS_ONLY(*selected.type_descriptor,
+                                          inner_value);
+            memset(*memb_ptr2, 0, specs->struct_size);
+        }
+    }
+    return rv;
+}
+
+asn_dec_rval_t
 OPEN_TYPE_xer_get(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
                   void *sptr, asn_TYPE_member_t *elm, const void *ptr,
                   size_t size) {
@@ -86,7 +164,7 @@
                 ASN__DECODE_STARVED;
             case PXER_COMMENT:
             case PXER_TEXT:
-                XER_ADVANCE(ch_size);
+                ADVANCE(ch_size);
                 continue;
             case PXER_TAG:
                 break;
@@ -100,7 +178,7 @@
      */
     switch(xer_check_tag(ptr, ch_size, elm->name)) {
     case XCT_OPENING:
-        XER_ADVANCE(ch_size);
+        ADVANCE(ch_size);
         break;
     case XCT_BROKEN:
     default:
@@ -113,7 +191,7 @@
 
     rv = selected.type_descriptor->op->xer_decoder(
         opt_codec_ctx, selected.type_descriptor, &inner_value, NULL, ptr, size);
-    XER_ADVANCE(rv.consumed);
+    ADVANCE(rv.consumed);
     rv.consumed = 0;
     switch(rv.code) {
     case RC_OK:
@@ -161,7 +239,7 @@
                 ASN__DECODE_STARVED;
             case PXER_COMMENT:
             case PXER_TEXT:
-                XER_ADVANCE(ch_size);
+                ADVANCE(ch_size);
                 continue;
             case PXER_TAG:
                 break;
@@ -175,7 +253,7 @@
      */
     switch(xer_check_tag(ptr, ch_size, elm->name)) {
     case XCT_CLOSING:
-        XER_ADVANCE(ch_size);
+        ADVANCE(ch_size);
         break;
     case XCT_BROKEN:
     default:
diff --git a/skeletons/OPEN_TYPE.h b/skeletons/OPEN_TYPE.h
index d49b3e6..22583b8 100644
--- a/skeletons/OPEN_TYPE.h
+++ b/skeletons/OPEN_TYPE.h
@@ -27,6 +27,12 @@
  * Decode an Open Type which is potentially constraiend
  * by the other members of the parent structure.
  */
+asn_dec_rval_t OPEN_TYPE_ber_get(asn_codec_ctx_t *opt_codec_ctx,
+                                 asn_TYPE_descriptor_t *parent_type,
+                                 void *parent_structure,
+                                 asn_TYPE_member_t *element, const void *ptr,
+                                 size_t size);
+
 asn_dec_rval_t OPEN_TYPE_xer_get(asn_codec_ctx_t *opt_codec_ctx,
                                  asn_TYPE_descriptor_t *parent_type,
                                  void *parent_structure,
diff --git a/skeletons/constr_SEQUENCE.c b/skeletons/constr_SEQUENCE.c
index ba74067..856cc6f 100644
--- a/skeletons/constr_SEQUENCE.c
+++ b/skeletons/constr_SEQUENCE.c
@@ -410,10 +410,14 @@
 		/*
 		 * Invoke the member fetch routine according to member's type
 		 */
-		rval = elements[edx].type->op->ber_decoder(opt_codec_ctx,
-				elements[edx].type,
-				memb_ptr2, ptr, LEFT,
-				elements[edx].tag_mode);
+		if((elements[edx].flags & ATF_OPEN_TYPE) && elements[edx].type_selector) {
+			rval = OPEN_TYPE_ber_get(opt_codec_ctx, td, st, &elements[edx], ptr, LEFT);
+        } else {
+			rval = elements[edx].type->op->ber_decoder(opt_codec_ctx,
+					elements[edx].type,
+					memb_ptr2, ptr, LEFT,
+					elements[edx].tag_mode);
+		}
 		ASN_DEBUG("In %s SEQUENCE decoded %zu %s of %d "
 			"in %d bytes rval.code %d, size=%d",
 			td->name, edx, elements[edx].type->name,