diff --git a/skeletons/Makefile.am b/skeletons/Makefile.am
index d61c66c..4427360 100644
--- a/skeletons/Makefile.am
+++ b/skeletons/Makefile.am
@@ -59,7 +59,8 @@
 	VisibleString.c VisibleString.h			\
 	asn_SEQUENCE_OF.c asn_SEQUENCE_OF.h		\
 	asn_SET_OF.c asn_SET_OF.h			\
-	asn_application.h asn_codecs.h			\
+	asn_application.c asn_application.h			\
+	asn_codecs.h			\
 	asn_codecs_prim.c asn_codecs_prim.h		\
 	asn_internal.h asn_system.h			\
 	asn_bit_data.c asn_bit_data.h			\
@@ -88,3 +89,9 @@
 	xer_encoder.c xer_encoder.h			\
 	xer_support.c xer_support.h
 
+check_PROGRAMS = check-converter_sample
+LDADD = -lm
+
+check_converter_sample_CFLAGS = $(SKELETONS_CFLAGS) -DNO_ASN_PDU
+check_converter_sample_SOURCES = converter-sample.c
+check_converter_sample_LDADD = libasn1cskeletons.la
diff --git a/skeletons/asn_application.c b/skeletons/asn_application.c
new file mode 100644
index 0000000..60c8e78
--- /dev/null
+++ b/skeletons/asn_application.c
@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <asn_application.h>
+#include <errno.h>
+
+static asn_enc_rval_t asn_encode_internal(
+    const asn_codec_ctx_t *opt_codec_parameters,
+    enum asn_transfer_syntax syntax, asn_TYPE_descriptor_t *td,
+    void *sptr, asn_app_consume_bytes_f *callback, void *callback_key);
+
+
+struct callback_count_bytes_key {
+    asn_app_consume_bytes_f *callback;
+    void *callback_key;
+    size_t computed_size;
+};
+
+/*
+ * Encoder which just counts bytes that come through it.
+ */
+static int
+callback_count_bytes_cb(const void *data, size_t size, void *keyp) {
+    struct callback_count_bytes_key *key = keyp;
+    int ret;
+
+    ret = key->callback(data, size, key->callback_key);
+    if(ret >= 0) {
+        key->computed_size += size;
+    }
+
+    return ret;
+}
+
+struct overrun_encoder_key {
+    void *buffer;
+    size_t buffer_size;
+    size_t computed_size;
+};
+
+struct callback_failure_catch_key {
+    asn_app_consume_bytes_f *callback;
+    void *callback_key;
+    int callback_failed;
+};
+
+/*
+ * Encoder which doesn't stop counting bytes
+ * even if it reaches the end of the buffer.
+ */
+static int
+overrun_encoder_cb(const void *data, size_t size, void *keyp) {
+    struct overrun_encoder_key *key = keyp;
+
+    if(key->computed_size + size > key->buffer_size) {
+        /*
+         * Avoid accident on the next call:
+         * stop adding bytes to the buffer.
+         */
+        key->buffer_size = 0;
+    } else {
+        memcpy((char *)key->buffer + key->computed_size, data, size);
+        key->computed_size += size;
+    }
+
+    return 0;
+}
+
+/*
+ * Encoder which help convert the application level encoder failure into EIO.
+ */
+static int
+callback_failure_catch_cb(const void *data, size_t size, void *keyp) {
+    struct callback_failure_catch_key *key = keyp;
+    int ret;
+
+    ret = key->callback(data, size, key->callback_key);
+    if(ret < 0) {
+        key->callback_failed = 1;
+    }
+
+    return ret;
+}
+
+asn_enc_rval_t
+asn_encode(const asn_codec_ctx_t *opt_codec_parameters,
+           enum asn_transfer_syntax syntax, asn_TYPE_descriptor_t *td,
+           void *sptr, asn_app_consume_bytes_f *callback, void *callback_key) {
+    struct callback_failure_catch_key cb_key;
+    asn_enc_rval_t er;
+
+    if(!callback) {
+        errno = EINVAL;
+        ASN__ENCODE_FAILED;
+    }
+
+    cb_key.callback = callback;
+    cb_key.callback_key = callback_key;
+    cb_key.callback_failed = 0;
+
+    er = asn_encode_internal(opt_codec_parameters, syntax, td, sptr,
+                             callback_failure_catch_cb, &cb_key);
+    if(cb_key.callback_failed) {
+        assert(er.encoded == -1);
+        assert(errno == EBADF);
+        errno = EIO;
+    }
+
+    return er;
+}
+
+asn_enc_rval_t
+asn_encode_to_buffer(const asn_codec_ctx_t *opt_codec_parameters,
+                     enum asn_transfer_syntax syntax, asn_TYPE_descriptor_t *td,
+                     void *sptr, void *buffer, size_t buffer_size) {
+    struct overrun_encoder_key buf_key;
+    asn_enc_rval_t er;
+
+    if(buffer_size > 0 && !buffer) {
+        errno = EINVAL;
+        ASN__ENCODE_FAILED;
+    }
+
+    buf_key.buffer = buffer;
+    buf_key.buffer_size = buffer_size;
+    buf_key.computed_size = 0;
+
+    er = asn_encode_internal(opt_codec_parameters, syntax, td, sptr,
+                             overrun_encoder_cb, &buf_key);
+
+    assert(er.encoded < 0 || (size_t)er.encoded == buf_key.computed_size);
+
+    return er;
+}
+
+static asn_enc_rval_t
+asn_encode_internal(const asn_codec_ctx_t *opt_codec_parameters,
+                    enum asn_transfer_syntax syntax, asn_TYPE_descriptor_t *td,
+                    void *sptr, asn_app_consume_bytes_f *callback,
+                    void *callback_key) {
+    asn_enc_rval_t er;
+    enum xer_encoder_flags_e xer_flags = XER_F_CANONICAL;
+
+    (void)opt_codec_parameters; /* Parameters are not checked on encode yet. */
+
+    if(!td || !sptr) {
+        errno = EINVAL;
+        ASN__ENCODE_FAILED;
+    }
+
+    switch(syntax) {
+    case ATS_BER:
+        /* BER is a superset of DER. */
+        /* Fall through. */
+    case ATS_DER:
+        if(td->op->der_encoder) {
+            er = der_encode(td, sptr, callback, callback_key);
+            if(er.encoded == -1) {
+                if(er.failed_type && er.failed_type->op->der_encoder) {
+                    errno = EBADF;  /* Structure has incorrect form. */
+                } else {
+                    errno = ENOENT; /* DER is not defined for this type. */
+                }
+            }
+        } else {
+            errno = ENOENT; /* Transfer syntax is not defined for this type. */
+            ASN__ENCODE_FAILED;
+        }
+        break;
+    case ATS_CER:
+        errno = ENOENT; /* Transfer syntax is not defined for any type. */
+        ASN__ENCODE_FAILED;
+
+#ifdef  ASN_DISABLE_OER_SUPPORT
+    case ATS_BASIC_OER:
+    case ATS_CANONICAL_OER:
+        errno = ENOENT; /* PER is not defined. */
+        ASN__ENCODE_FAILED;
+        break;
+#else /* ASN_DISABLE_OER_SUPPORT */
+    case ATS_BASIC_OER:
+        /* CANONICAL-OER is a superset of BASIC-OER. */
+        /* Fall through. */
+    case ATS_CANONICAL_OER:
+        if(td->op->oer_encoder) {
+            er = oer_encode(td, sptr, callback, callback_key);
+            if(er.encoded == -1) {
+                if(er.failed_type && er.failed_type->op->oer_encoder) {
+                    errno = EBADF;  /* Structure has incorrect form. */
+                } else {
+                    errno = ENOENT; /* OER is not defined for this type. */
+                }
+            }
+        } else {
+            errno = ENOENT; /* Transfer syntax is not defined for this type. */
+            ASN__ENCODE_FAILED;
+        }
+        break;
+#endif /* ASN_DISABLE_OER_SUPPORT */
+
+#ifdef  ASN_DISABLE_PER_SUPPORT
+    case ATS_UNALIGNED_BASIC_PER:
+    case ATS_UNALIGNED_CANONICAL_PER:
+        errno = ENOENT; /* PER is not defined. */
+        ASN__ENCODE_FAILED;
+        break;
+#else /* ASN_DISABLE_PER_SUPPORT */
+    case ATS_UNALIGNED_BASIC_PER:
+        /* CANONICAL-UPER is a superset of BASIC-UPER. */
+        /* Fall through. */
+    case ATS_UNALIGNED_CANONICAL_PER:
+        if(td->op->uper_encoder) {
+            er = uper_encode(td, sptr, callback, callback_key);
+            if(er.encoded == -1) {
+                if(er.failed_type && er.failed_type->op->uper_encoder) {
+                    errno = EBADF;  /* Structure has incorrect form. */
+                } else {
+                    errno = ENOENT; /* UPER is not defined for this type. */
+                }
+            } else {
+                ASN_DEBUG("Complete encoded in %ld bits", (long)er.encoded);
+                if(er.encoded == 0) {
+                    /* Enforce "Complete Encoding" of X.691 #11.1 */
+                    if(callback("\0", 1, callback_key) < 0) {
+                        errno = EBADF;
+                        ASN__ENCODE_FAILED;
+                    }
+                    er.encoded = 8; /* Exactly 8 zero bits is added. */
+                }
+                /* Convert bits into bytes */
+                er.encoded = (er.encoded + 7) >> 3;
+            }
+        } else {
+            errno = ENOENT; /* Transfer syntax is not defined for this type. */
+            ASN__ENCODE_FAILED;
+        }
+        break;
+#endif  /* ASN_DISABLE_PER_SUPPORT */
+
+    case ATS_BASIC_XER:
+        /* CANONICAL-XER is a superset of BASIC-XER. */
+        xer_flags &= ~XER_F_CANONICAL;
+        xer_flags |= XER_F_BASIC;
+        /* Fall through. */
+    case ATS_CANONICAL_XER:
+        if(td->op->xer_encoder) {
+            er = xer_encode(td, sptr, xer_flags, callback, callback_key);
+            if(er.encoded == -1) {
+                if(er.failed_type && er.failed_type->op->xer_encoder) {
+                    errno = EBADF;  /* Structure has incorrect form. */
+                } else {
+                    errno = ENOENT; /* XER is not defined for this type. */
+                }
+            }
+        } else {
+            errno = ENOENT; /* Transfer syntax is not defined for this type. */
+            ASN__ENCODE_FAILED;
+        }
+        break;
+
+    case ATS_NONSTANDARD_PLAINTEXT:
+        if(td->op->print_struct) {
+            struct callback_count_bytes_key cb_key;
+            cb_key.callback = callback;
+            cb_key.callback_key = callback_key;
+            cb_key.computed_size = 0;
+            if(td->op->print_struct(td, sptr, 1, callback_count_bytes_cb,
+                                    &cb_key)
+                   < 0
+               || callback_count_bytes_cb("\n", 1, &cb_key) < 0) {
+                errno = EBADF; /* Structure has incorrect form. */
+                er.encoded = -1;
+                er.failed_type = td;
+                er.structure_ptr = sptr;
+            } else {
+                er.encoded = cb_key.computed_size;
+                er.failed_type = 0;
+                er.structure_ptr = 0;
+            }
+        } else {
+            errno = ENOENT; /* Transfer syntax is not defined for this type. */
+            ASN__ENCODE_FAILED;
+        }
+        break;
+
+    default:
+        errno = ENOENT;
+        ASN__ENCODE_FAILED;
+    }
+
+    return er;
+}
diff --git a/skeletons/asn_application.h b/skeletons/asn_application.h
index 71e9ba6..0a24018 100644
--- a/skeletons/asn_application.h
+++ b/skeletons/asn_application.h
@@ -16,14 +16,101 @@
 #endif
 
 /*
+ * A selection of ASN.1 Transfer Syntaxes to use with generalized
+ * encoder and decoders declared further in this .h file.
+ */
+enum asn_transfer_syntax {
+    /* Avoid appearance of a default transfer syntax. */
+    ATS_INVALID = 0,
+    /* Plaintext output, useful for debugging. */
+    ATS_NONSTANDARD_PLAINTEXT,
+    /*
+     * X.690:
+     * BER: Basic Encoding Rules.
+     * DER: Distinguished Encoding Rules.
+     * CER: Canonical Encoding Rules.
+     * DER and CER are more strict variants of BER.
+     */
+    ATS_BER,
+    ATS_DER,
+    ATS_CER, /* Only decoding is supported */
+    /*
+     * X.696:
+     * OER: Octet Encoding Rules.
+     * CANONICAL-OER is a more strict variant of BASIC-OER.
+     */
+    ATS_BASIC_OER,
+    ATS_CANONICAL_OER,
+    /*
+     * X.691:
+     * PER: Packed Encoding Rules.
+     * CANONICAL-PER is a more strict variant of BASIC-PER.
+     * NOTE: Produces or consumes a complete encoding (X.691 (08/2015) #11.1).
+     */
+    ATS_UNALIGNED_BASIC_PER,
+    ATS_UNALIGNED_CANONICAL_PER,
+    /*
+     * X.693:
+     * XER: XML Encoding Rules.
+     * CANONICAL-XER is a more strict variant of BASIC-XER.
+     */
+    ATS_BASIC_XER,
+    ATS_CANONICAL_XER,
+};
+
+/*
+ * A generic encoder for any supported transfer syntax.
+ * RETURN VALUES:
+ * The (.encoded) field of the return value is REDEFINED to mean the following:
+ * >=0: The computed size of the encoded data. Can exceed the (buffer_size).
+ *  -1: Error encoding the structure. See the error code in (errno):
+ *      EINVAL: Incorrect parameters to the function, such as NULLs.
+ *      ENOENT: Encoding transfer syntax is not defined (for this type).
+ *      EBADF:  The structure has invalid form or content constraint failed.
+ *      The (.failed_type) and (.structure_ptr) MIGHT be set to the appropriate
+ *      values at the place of failure, if at all possible.
+ * WARNING: The (.encoded) field of the return value can exceed the buffer_size.
+ * This is similar to snprintf(3) contract which might return values
+ * greater than the buffer size.
+ */
+asn_enc_rval_t asn_encode_to_buffer(
+    const asn_codec_ctx_t *opt_codec_parameters, /* See asn_codecs.h */
+    enum asn_transfer_syntax,
+    struct asn_TYPE_descriptor_s *type_to_encode,
+    void *structure_to_encode,
+    void *buffer, size_t buffer_size);
+
+
+/*
  * Generic type of an application-defined callback to return various
  * types of data to the application.
  * EXPECTED RETURN VALUES:
  *  -1: Failed to consume bytes. Abort the mission.
  * Non-negative return values indicate success, and ignored.
  */
-typedef int (asn_app_consume_bytes_f)(const void *buffer, size_t size,
-	void *application_specific_key);
+typedef int(asn_app_consume_bytes_f)(const void *buffer, size_t size,
+                                     void *application_specific_key);
+
+
+/*
+ * A generic encoder for any supported transfer syntax.
+ * Returns the comprehensive encoding result descriptor (see asn_codecs.h).
+ * RETURN VALUES:
+ * The negative (.encoded) field of the return values is accompanied with the
+ * following error codes (errno):
+ *      EINVAL: Incorrect parameters to the function, such as NULLs.
+ *      ENOENT: Encoding transfer syntax is not defined (for this type).
+ *      EBADF:  The structure has invalid form or content constraint failed.
+ *      EIO:    The (callback) has returned negative value during encoding.
+ */
+asn_enc_rval_t asn_encode(
+    const asn_codec_ctx_t *opt_codec_parameters, /* See asn_codecs.h */
+    enum asn_transfer_syntax,
+    struct asn_TYPE_descriptor_s *type_to_encode,
+    void *structure_to_encode,
+    asn_app_consume_bytes_f *callback, void *callback_key);
+
+
 
 /*
  * A callback of this type is called whenever constraint validation fails
@@ -38,6 +125,7 @@
 	const void *structure_which_failed_ptr,
 	const char *error_message_format, ...) GCC_PRINTFLIKE(4, 5);
 
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/skeletons/converter-sample.c b/skeletons/converter-sample.c
index 8ec45f2..bbf276c 100644
--- a/skeletons/converter-sample.c
+++ b/skeletons/converter-sample.c
@@ -22,20 +22,31 @@
 #include <asn_internal.h>    /* for ASN__DEFAULT_STACK_MAX */
 
 /* Convert "Type" defined by -DPDU into "asn_DEF_Type" */
+
+#ifndef NO_ASN_PDU
+#ifndef PDU
+#error Define -DPDU to compile this sample converter.
+#endif
+#ifdef    ASN_PDU_COLLECTION        /* Generated by asn1c: -pdu=... */
+extern asn_TYPE_descriptor_t *asn_pdu_collection[];
+#endif
 #define    ASN_DEF_PDU(t)    asn_DEF_ ## t
 #define    DEF_PDU_Type(t)    ASN_DEF_PDU(t)
 #define    PDU_Type    DEF_PDU_Type(PDU)
 
 extern asn_TYPE_descriptor_t PDU_Type;    /* ASN.1 type to be decoded */
-#ifdef    ASN_PDU_COLLECTION        /* Generated by asn1c: -pdu=... */
-extern asn_TYPE_descriptor_t *asn_pdu_collection[];
-#endif
+#define PDU_Type_Ptr (&PDU_Type)
+#else   /* NO_ASN_PDU */
+#define PDU_Type_Ptr    NULL
+#endif  /* NO_ASN_PDU */
 
 /*
  * Open file and parse its contens.
  */
-static void *data_decode_from_file(asn_TYPE_descriptor_t *asnTypeOfPDU,
-    FILE *file, const char *name, ssize_t suggested_bufsize, int first_pdu);
+static void *data_decode_from_file(enum asn_transfer_syntax,
+                                   asn_TYPE_descriptor_t *asnTypeOfPDU,
+                                   FILE *file, const char *name,
+                                   ssize_t suggested_bufsize, int first_pdu);
 static int write_out(const void *buffer, size_t size, void *key);
 static FILE *argument_to_file(char *av[], int idx);
 static char *argument_to_name(char *av[], int idx);
@@ -46,24 +57,6 @@
 static int opt_nopad;    /* -per-nopad (PER input is not padded) */
 static int opt_onepdu;    /* -1 (decode single PDU) */
 
-/* Input data format selector */
-static enum input_format {
-    INP_BER,    /* -iber: BER input */
-    INP_XER,    /* -ixer: XER input */
-    INP_OER,    /* -ioer: OER input */
-    INP_PER        /* -iper: Unaligned PER input */
-} iform;    /* -i<format> */
-
-/* Output data format selector */
-static enum output_format {
-    OUT_XER,    /* -oxer: XER (XML) output */
-    OUT_DER,    /* -oder: DER (BER) output */
-    OUT_OER,    /* -ooer: Canonical OER output */
-    OUT_PER,    /* -oper: Unaligned PER output */
-    OUT_TEXT,    /* -otext: semi-structured text */
-    OUT_NULL    /* -onull: No pretty-printing */
-} oform;    /* -o<format> */
-
 #ifdef    JUNKTEST        /* Enable -J <probability> */
 #define    JUNKOPT    "J:"
 static double opt_jprob;    /* Junk bit probability */
@@ -85,20 +78,60 @@
     fprintf(stderr, "\n");
 }
 
+static const char *
+ats_simple_name(enum asn_transfer_syntax syntax) {
+    switch(syntax) {
+    case ATS_INVALID:
+        return "/dev/null";
+    case ATS_NONSTANDARD_PLAINTEXT:
+        return "plaintext";
+    case ATS_BER:
+        return "BER";
+    case ATS_DER:
+        return "DER";
+    case ATS_CER:
+        return "CER";
+    case ATS_BASIC_OER:
+    case ATS_CANONICAL_OER:
+        return "OER";
+    case ATS_BASIC_XER:
+    case ATS_CANONICAL_XER:
+        return "XER";
+    case ATS_UNALIGNED_BASIC_PER:
+    case ATS_UNALIGNED_CANONICAL_PER:
+        return "PER";
+    default:
+        return "<?>";
+    }
+}
+
 int
 main(int ac, char *av[]) {
     FILE *binary_out;
-    static asn_TYPE_descriptor_t *pduType = &PDU_Type;
+    static asn_TYPE_descriptor_t *pduType = PDU_Type_Ptr;
     ssize_t suggested_bufsize = 8192;  /* close or equal to stdio buffer */
     int number_of_iterations = 1;
     int num;
     int ch;
+    enum asn_transfer_syntax isyntax = ATS_INVALID;
+    enum asn_transfer_syntax osyntax = ATS_INVALID;
+
+#ifndef  PDU
+    if(!pduType) {
+        fprintf(stderr, "No -DPDU defined during compilation.\n");
+#ifdef  NO_ASN_PDU
+        exit(0);
+#else
+        exit(EX_SOFTWARE);
+#endif
+    }
+#endif
 
     /* Figure out if specialty decoder needs to be default */
     if(pduType->op->oer_decoder)
-        iform = INP_OER;
+        isyntax = ATS_BASIC_OER;
     else if(pduType->op->uper_decoder)
-        iform = INP_PER;
+        isyntax = ATS_UNALIGNED_BASIC_PER;
 
     /*
      * Pocess the command-line argments.
@@ -106,24 +139,24 @@
     while((ch = getopt(ac, av, "i:o:1b:cdn:p:hs:" JUNKOPT)) != -1)
     switch(ch) {
     case 'i':
-        if(optarg[0] == 'b') { iform = INP_BER; break; }
-        if(optarg[0] == 'x') { iform = INP_XER; break; }
+        if(optarg[0] == 'b') { isyntax = ATS_BER; break; }
+        if(optarg[0] == 'x') { isyntax = ATS_BASIC_XER; break; }
         if(pduType->op->oer_decoder
-        && optarg[0] == 'o') { iform = INP_OER; break; }
+        && optarg[0] == 'o') { isyntax = ATS_BASIC_OER; break; }
         if(pduType->op->uper_decoder
-        && optarg[0] == 'p') { iform = INP_PER; break; }
+        && optarg[0] == 'p') { isyntax = ATS_UNALIGNED_BASIC_PER; break; }
         fprintf(stderr, "-i<format>: '%s': improper format selector\n",
             optarg);
         exit(EX_UNAVAILABLE);
     case 'o':
-        if(optarg[0] == 'd') { oform = OUT_DER; break; }
+        if(optarg[0] == 'd') { osyntax = ATS_DER; break; }
         if(pduType->op->oer_encoder
-        && optarg[0] == 'o') { oform = OUT_OER; break; }
+        && optarg[0] == 'o') { osyntax = ATS_CANONICAL_OER; break; }
         if(pduType->op->uper_encoder
-        && optarg[0] == 'p') { oform = OUT_PER; break; }
-        if(optarg[0] == 'x') { oform = OUT_XER; break; }
-        if(optarg[0] == 't') { oform = OUT_TEXT; break; }
-        if(optarg[0] == 'n') { oform = OUT_NULL; break; }
+        && optarg[0] == 'p') { osyntax = ATS_UNALIGNED_CANONICAL_PER; break; }
+        if(optarg[0] == 'x') { osyntax = ATS_BASIC_XER; break; }
+        if(optarg[0] == 't') { osyntax = ATS_NONSTANDARD_PLAINTEXT; break; }
+        if(optarg[0] == 'n') { osyntax = ATS_INVALID; break; }
         fprintf(stderr, "-o<format>: '%s': improper format selector\n",
             optarg);
         exit(EX_UNAVAILABLE);
@@ -219,14 +252,14 @@
         if(pduType->op->oer_decoder)
         fprintf(stderr,
         "  -ioer        Input is in OER (Octet Encoding Rules)%s\n",
-            iform == INP_OER ? " (DEFAULT)" : "");
+            isyntax == ATS_BASIC_OER ? " (DEFAULT)" : "");
         if(pduType->op->uper_decoder)
         fprintf(stderr,
         "  -iper        Input is in Unaligned PER (Packed Encoding Rules)%s\n",
-            iform == INP_PER ? " (DEFAULT)" : "");
+            isyntax == ATS_UNALIGNED_BASIC_PER ? " (DEFAULT)" : "");
         fprintf(stderr,
         "  -iber        Input is in BER (Basic Encoding Rules)%s\n",
-            iform == INP_BER ? " (DEFAULT)" : "");
+            isyntax == ATS_BER ? " (DEFAULT)" : "");
         fprintf(stderr,
         "  -ixer        Input is in XER (XML Encoding Rules)\n");
         if(pduType->op->oer_encoder)
@@ -273,7 +306,7 @@
     }
 
     if(isatty(1)) {
-        const int is_text_output = oform == OUT_TEXT || oform == OUT_XER;
+        const int is_text_output = osyntax == ATS_NONSTANDARD_PLAINTEXT || osyntax == ATS_CANONICAL_XER || osyntax == ATS_BASIC_XER;
         if(is_text_output) {
             binary_out = stdout;
         } else {
@@ -301,11 +334,11 @@
         char *name = argument_to_name(av, ac_i);
         int first_pdu;
 
-        for(first_pdu = 1; first_pdu || !opt_onepdu; first_pdu = 0) {
+        for(first_pdu = 1; file && (first_pdu || !opt_onepdu); first_pdu = 0) {
             /*
              * Decode the encoded structure from file.
              */
-            structure = data_decode_from_file(pduType, file, name,
+            structure = data_decode_from_file(isyntax, pduType, file, name,
                                               suggested_bufsize, first_pdu);
             if(!structure) {
                 if(errno) {
@@ -330,59 +363,24 @@
                 }
             }
 
-            switch(oform) {
-            case OUT_NULL:
+            if(osyntax == ATS_INVALID) {
 #ifdef JUNKTEST
-                if(opt_jprob == 0.0)
-#endif
+                if(opt_jprob == 0.0) {
                     fprintf(stderr, "%s: decoded successfully\n", name);
-                break;
-            case OUT_TEXT: /* -otext */
-                asn_fprint(stdout, pduType, structure);
-                break;
-            case OUT_XER: /* -oxer */
-                if(xer_fprint(stdout, pduType, structure)) {
-                    fprintf(stderr, "%s: Cannot convert %s into XML\n", name,
-                            pduType->name);
-                    exit(EX_UNAVAILABLE);
                 }
-                break;
-            case OUT_DER:
-                erv = der_encode(pduType, structure, write_out, binary_out);
-                if(erv.encoded < 0) {
-                    fprintf(stderr, "%s: Cannot convert %s into DER\n", name,
-                            pduType->name);
-                    exit(EX_UNAVAILABLE);
-                }
-                DEBUG("Encoded in %ld bytes of DER", (long)erv.encoded);
-                break;
-            case OUT_OER:
-#ifdef  ASN_DISABLE_OER_SUPPORT
-                erv.encoded = -1;
 #else
-                erv = oer_encode(pduType, structure, write_out, binary_out);
+                fprintf(stderr, "%s: decoded successfully\n", name);
 #endif
-                if(erv.encoded < 0) {
-                    fprintf(stderr, "%s: Cannot convert %s into OER\n", name,
-                            pduType->name);
+            } else {
+                erv = asn_encode(NULL, osyntax, pduType, structure, write_out, binary_out);
+
+                if(erv.encoded == -1) {
+                    fprintf(stderr, "%s: Cannot convert %s into %s\n", name,
+                            pduType->name, ats_simple_name(osyntax));
                     exit(EX_UNAVAILABLE);
                 }
-                DEBUG("Encoded in %ld bytes of OER", (long)erv.encoded);
-                break;
-            case OUT_PER:
-#ifdef  ASN_DISABLE_PER_SUPPORT
-                erv.encoded = -1;
-#else
-                erv = uper_encode(pduType, structure, write_out, binary_out);
-#endif
-                if(erv.encoded < 0) {
-                    fprintf(stderr,
-                            "%s: Cannot convert %s into Unaligned PER\n", name,
-                            pduType->name);
-                    exit(EX_UNAVAILABLE);
-                }
-                DEBUG("Encoded in %ld bits of UPER", (long)erv.encoded);
-                break;
+                DEBUG("Encoded in %zd bytes of %s", erv.encoded,
+                      ats_simple_name(osyntax));
             }
 
             ASN_STRUCT_FREE(*pduType, structure);
@@ -610,7 +608,7 @@
 }
 
 static void *
-data_decode_from_file(asn_TYPE_descriptor_t *pduType, FILE *file, const char *name, ssize_t suggested_bufsize, int on_first_pdu) {
+data_decode_from_file(enum asn_transfer_syntax isyntax, asn_TYPE_descriptor_t *pduType, FILE *file, const char *name, ssize_t suggested_bufsize, int on_first_pdu) {
     static uint8_t *fbuf;
     static ssize_t fbuf_size;
     static asn_codec_ctx_t s_codec_ctx;
@@ -688,12 +686,12 @@
         junk_bytes_with_probability(i_bptr, i_size, opt_jprob);
 #endif
 
-        switch(iform) {
-        case INP_BER:
+        switch(isyntax) {
+        case ATS_BER:
             rval = ber_decode(opt_codec_ctx, pduType,
                 (void **)&structure, i_bptr, i_size);
             break;
-        case INP_OER:
+        case ATS_BASIC_OER:
 #ifdef ASN_DISABLE_OER_SUPPORT
             rval.code = RC_FAIL;
             rval.consumed = 0;
@@ -702,11 +700,11 @@
                 (void **)&structure, i_bptr, i_size);
 #endif
             break;
-        case INP_XER:
+        case ATS_BASIC_XER:
             rval = xer_decode(opt_codec_ctx, pduType,
                 (void **)&structure, i_bptr, i_size);
             break;
-        case INP_PER:
+        case ATS_UNALIGNED_BASIC_PER:
 #ifdef ASN_DISABLE_PER_SUPPORT
             rval.code = RC_FAIL;
             rval.consumed = 0;
@@ -740,6 +738,9 @@
                 break;
             }
             break;
+        default:
+            rval.consumed = 0;
+            /* Fall through */
         }
         DEBUG("decode(%ld) consumed %ld+%db (%ld), code %d",
             (long)DynamicBuffer.length,
@@ -804,7 +805,7 @@
      */
     if(on_first_pdu
     || DynamicBuffer.length
-    || new_offset - old_offset > ((iform == INP_XER)?sizeof("\r\n")-1:0)
+    || new_offset - old_offset > ((isyntax == ATS_BASIC_XER)?sizeof("\r\n")-1:0)
     ) {
 
 #ifdef    JUNKTEST
diff --git a/skeletons/file-dependencies b/skeletons/file-dependencies
index 8814d68..e13e7d1 100644
--- a/skeletons/file-dependencies
+++ b/skeletons/file-dependencies
@@ -41,7 +41,7 @@
 constr_SET_OF.h constr_SET_OF.c asn_SET_OF.h
 
 COMMON-FILES:			# THIS IS A SPECIAL SECTION
-asn_application.h		# Applications should include this file
+asn_application.h asn_application.c		# Applications should include this file
 asn_ioc.h			# Information Object Classes, runtime support
 asn_system.h			# Platform-dependent types
 asn_codecs.h			# Return types of encoders and decoders
diff --git a/skeletons/per_decoder.h b/skeletons/per_decoder.h
index 803341a..0a50705 100644
--- a/skeletons/per_decoder.h
+++ b/skeletons/per_decoder.h
@@ -15,8 +15,8 @@
 struct asn_TYPE_descriptor_s;	/* Forward declaration */
 
 /*
- * Unaligned PER decoder of a "complete encoding" as per X.691#10.1.
- * On success, this call always returns (.consumed >= 1), as per X.691#10.1.3.
+ * Unaligned PER decoder of a "complete encoding" as per X.691 (08/2015) #11.1.
+ * On success, this call always returns (.consumed >= 1), as per #11.1.3.
  */
 asn_dec_rval_t uper_decode_complete(struct asn_codec_ctx_s *opt_codec_ctx,
 	struct asn_TYPE_descriptor_s *type_descriptor,	/* Type to decode */