Replace tabs by spaces when editor modelines has "expandtab"

Change-Id: If7a6f2697be732ae4f94ed8b845fd293c32510f7
Also: tabs-stops should be 8
Reviewed-on: https://code.wireshark.org/review/7100
Reviewed-by: Bill Meier <wmeier@newsguy.com>

24 files changed, 4185 insertions, 4185 deletions

diff --git a/epan/address_types.c b/epan/address_types.c
index 61d3f52a2d..10fa0ca888 100644
--- a/epan/address_types.c
+++ b/epan/address_types.c
@@ -791,10 +791,10 @@ void address_types_initialize(void)
 }
 
 /* Given an address type id, return an address_type_t* */
-#define ADDR_TYPE_LOOKUP(addr_type, result)	\
-	/* Check input */		\
-	g_assert(addr_type < MAX_ADDR_TYPE_VALUE);	\
-	result = type_list[addr_type];
+#define ADDR_TYPE_LOOKUP(addr_type, result)    \
+    /* Check input */                          \
+    g_assert(addr_type < MAX_ADDR_TYPE_VALUE); \
+    result = type_list[addr_type];
 
 static int address_type_get_length(const address* addr)
 {
diff --git a/epan/conversation_table.c b/epan/conversation_table.c
index 3f0d828036..5ae0e81138 100644
--- a/epan/conversation_table.c
+++ b/epan/conversation_table.c
@@ -166,7 +166,7 @@ set_conv_gui_data(gpointer data, gpointer user_data)
     g_string_append(conv_cmd_str, proto_get_protocol_filter_name(table->proto_id));
     cmd_string_list_ = g_list_append(cmd_string_list_, conv_cmd_str->str);
     ui_info.group = REGISTER_STAT_GROUP_CONVERSATION_LIST;
-    ui_info.title = NULL;	/* construct this from the protocol info? */
+    ui_info.title = NULL;   /* construct this from the protocol info? */
     ui_info.cli_string = g_string_free(conv_cmd_str, FALSE);
     ui_info.tap_init_cb = dissector_conversation_init;
     ui_info.index = -1;
@@ -191,7 +191,7 @@ set_host_gui_data(gpointer data, gpointer user_data)
 
     g_string_printf(host_cmd_str, "%s,%s", HOSTLIST_TAP_PREFIX, proto_get_protocol_filter_name(table->proto_id));
     ui_info.group = REGISTER_STAT_GROUP_ENDPOINT_LIST;
-    ui_info.title = NULL;	/* construct this from the protocol info? */
+    ui_info.title = NULL;   /* construct this from the protocol info? */
     ui_info.cli_string = g_string_free(host_cmd_str, FALSE);
     ui_info.tap_init_cb = dissector_hostlist_init;
     ui_info.index = -1;
diff --git a/epan/dissectors/packet-3g-a11.c b/epan/dissectors/packet-3g-a11.c
index 8cd50a4d07..50c5d574cf 100644
--- a/epan/dissectors/packet-3g-a11.c
+++ b/epan/dissectors/packet-3g-a11.c
@@ -1585,7 +1585,7 @@ dissect_a11( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_
 
             /* flags */
             proto_tree_add_bitmask(a11_tree, tvb, offset, hf_a11_flags,
-			                ett_a11_flags, a11_flags, ENC_NA);
+                                   ett_a11_flags, a11_flags, ENC_NA);
             offset += 1;
 
             /* lifetime */
@@ -1905,7 +1905,7 @@ dissect_a11( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_
 
                /* flags */
                proto_tree_add_bitmask(a11_tree, tvb, offset, hf_a11_flags,
-			                ett_a11_flags, a11_flags, ENC_NA);
+                                      ett_a11_flags, a11_flags, ENC_NA);
                offset += 1;
 
                /* lifetime */
diff --git a/epan/dissectors/packet-ansi_683.c b/epan/dissectors/packet-ansi_683.c
index c62e082ddb..0cf7d2718c 100644
--- a/epan/dissectors/packet-ansi_683.c
+++ b/epan/dissectors/packet-ansi_683.c
@@ -1123,11 +1123,11 @@ msg_download_req(tvbuff_t *tvb, packet_info* pinfo, proto_tree *tree, guint len,
  * 4.5.1.3
  */
 static const value_string akey_protocol_revision_vals[] = {
-	{ 0x02,	"2G A-key generation" },
-	{ 0x03,	"2G A-key and 3G Root Key generation" },
-	{ 0x04,	"3G Root Key generation" },
-	{ 0x05,	"Enhanced 3G Root Key generation" },
-	{ 0, NULL },
+    { 0x02,     "2G A-key generation" },
+    { 0x03,     "2G A-key and 3G Root Key generation" },
+    { 0x04,     "3G Root Key generation" },
+    { 0x05,     "Enhanced 3G Root Key generation" },
+    { 0, NULL },
 };
 
 static void
diff --git a/epan/dissectors/packet-assa_r3.c b/epan/dissectors/packet-assa_r3.c
index 762a82ac23..3d69586c1c 100644
--- a/epan/dissectors/packet-assa_r3.c
+++ b/epan/dissectors/packet-assa_r3.c
@@ -6040,7 +6040,7 @@ dissect_r3_cmd_clearnvram (tvbuff_t *tvb, guint32 start_offset, guint32 length _
   proto_tree_add_item (tree, hf_r3_commandlength, tvb, start_offset + 0, 1, ENC_LITTLE_ENDIAN);
   proto_tree_add_item (tree, hf_r3_command,       tvb, start_offset + 1, 1, ENC_LITTLE_ENDIAN);
   proto_tree_add_bitmask(tree, tvb, start_offset + 2, hf_r3_nvramclearoptions,
-			       ett_r3clearnvram, r3_nvramclearoptions, ENC_LITTLE_ENDIAN);
+                         ett_r3clearnvram, r3_nvramclearoptions, ENC_LITTLE_ENDIAN);
 }
 
 static void
diff --git a/epan/dissectors/packet-dtn.c b/epan/dissectors/packet-dtn.c
index 9358bf6760..728262ece3 100644
--- a/epan/dissectors/packet-dtn.c
+++ b/epan/dissectors/packet-dtn.c
@@ -1072,13 +1072,13 @@ dissect_payload_header(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int
     /* This is really a SDNV but there are only 7 bits defined so leave it this way*/
 
     if (version == 4) {
-		static const gint *flags[] = {
-			&hf_bundle_payload_flags_replicate_hdr,
-			&hf_bundle_payload_flags_xmit_report,
-			&hf_bundle_payload_flags_discard_on_fail,
-			&hf_bundle_payload_flags_last_header,
-			NULL
-		};
+        static const gint *flags[] = {
+            &hf_bundle_payload_flags_replicate_hdr,
+            &hf_bundle_payload_flags_xmit_report,
+            &hf_bundle_payload_flags_discard_on_fail,
+            &hf_bundle_payload_flags_last_header,
+            NULL
+        };
         guint8      procflags;
 
         procflags = tvb_get_guint8(tvb, offset);
@@ -1088,8 +1088,8 @@ dissect_payload_header(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, int
         else {
             *lastheader = FALSE;
         }
-		proto_tree_add_bitmask(payload_tree, tvb, offset, hf_bundle_payload_flags,
-					ett_payload_flags, flags, ENC_BIG_ENDIAN);
+        proto_tree_add_bitmask(payload_tree, tvb, offset, hf_bundle_payload_flags,
+                               ett_payload_flags, flags, ENC_BIG_ENDIAN);
         ++offset;
     }
     else {      /*Bundle Protocol Version 5*/
diff --git a/epan/dissectors/packet-e212.h b/epan/dissectors/packet-e212.h
index 45f1c24f2d..8434a9b19f 100644
--- a/epan/dissectors/packet-e212.h
+++ b/epan/dissectors/packet-e212.h
@@ -30,10 +30,10 @@
 extern value_string_ext E212_codes_ext;
 
 typedef enum {
-	E212_NONE,
-	E212_LAI,
-	E212_RAI,
-	E212_SAI
+    E212_NONE,
+    E212_LAI,
+    E212_RAI,
+    E212_SAI
 } e212_number_type_t;
 
 gchar* dissect_e212_mcc_mnc_wmem_packet_str(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, e212_number_type_t number_type, gboolean little_endian);
diff --git a/epan/dissectors/packet-gsm_a_dtap.c b/epan/dissectors/packet-gsm_a_dtap.c
index 9a7d76ad95..75e6a18dcd 100644
--- a/epan/dissectors/packet-gsm_a_dtap.c
+++ b/epan/dissectors/packet-gsm_a_dtap.c
@@ -1100,8 +1100,8 @@ de_emerg_num_list(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, guint32 o
         item = proto_tree_add_string(subtree, hf_gsm_a_dtap_emergency_bcd_num, tvb, curr_offset, en_len, digit_str);
 
         /* Check for overdicadic digits, we used the standard digit map from tvbuff.c
-		 *  0   1   2   3   4   5   6   7   8   9   a   b   c   d   e  f
-		 * '0','1','2','3','4','5','6','7','8','9','?','?','?','?','?','?'
+         *  0   1   2   3   4   5   6   7   8   9   a   b   c   d   e  f
+         * '0','1','2','3','4','5','6','7','8','9','?','?','?','?','?','?'
          *
          */
         if(strchr(digit_str,'?')){
@@ -2171,10 +2171,10 @@ de_bcd_num(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, guint32 offset,
         a_bigbuf);
 
     /* Check for overdicadic digits, we used the standard digit map from tvbuff.c
-		*  0   1   2   3   4   5   6   7   8   9   a   b   c   d   e  f
-		* '0','1','2','3','4','5','6','7','8','9','?','?','?','?','?','?'
-        *
-        */
+     *  0   1   2   3   4   5   6   7   8   9   a   b   c   d   e  f
+     * '0','1','2','3','4','5','6','7','8','9','?','?','?','?','?','?'
+     *
+     */
     if(strchr(digit_str,'?')){
         expert_add_info(pinfo, item, &ei_gsm_a_dtap_end_mark_unexpected);
     }
diff --git a/epan/dissectors/packet-ieee80211-radio.c b/epan/dissectors/packet-ieee80211-radio.c
index 0280160a5b..da32cfd376 100644
--- a/epan/dissectors/packet-ieee80211-radio.c
+++ b/epan/dissectors/packet-ieee80211-radio.c
@@ -64,398 +64,398 @@ static const value_string bandwidth_vals[] = {
  *
  * Indices are:
  *
- *	the MCS index (0-76);
+ *  the MCS index (0-76);
  *
- *	0 for 20 MHz, 1 for 40 MHz;
+ *  0 for 20 MHz, 1 for 40 MHz;
  *
- *	0 for a long guard interval, 1 for a short guard interval.
+ *  0 for a long guard interval, 1 for a short guard interval.
  */
 WS_DLL_PUBLIC_DEF
 const float ieee80211_float_htrates[MAX_MCS_INDEX+1][2][2] = {
-	/* MCS  0  */
-	{	/* 20 Mhz */ {    6.5f,		/* SGI */    7.2f, },
-		/* 40 Mhz */ {   13.5f,		/* SGI */   15.0f, },
-	},
-
-	/* MCS  1  */
-	{	/* 20 Mhz */ {   13.0f,		/* SGI */   14.4f, },
-		/* 40 Mhz */ {   27.0f,		/* SGI */   30.0f, },
-	},
-
-	/* MCS  2  */
-	{	/* 20 Mhz */ {   19.5f,		/* SGI */   21.7f, },
-		/* 40 Mhz */ {   40.5f,		/* SGI */   45.0f, },
-	},
-
-	/* MCS  3  */
-	{	/* 20 Mhz */ {   26.0f,		/* SGI */   28.9f, },
-		/* 40 Mhz */ {   54.0f,		/* SGI */   60.0f, },
-	},
-
-	/* MCS  4  */
-	{	/* 20 Mhz */ {   39.0f,		/* SGI */   43.3f, },
-		/* 40 Mhz */ {   81.0f,		/* SGI */   90.0f, },
-	},
-
-	/* MCS  5  */
-	{	/* 20 Mhz */ {   52.0f,		/* SGI */   57.8f, },
-		/* 40 Mhz */ {  108.0f,		/* SGI */  120.0f, },
-	},
-
-	/* MCS  6  */
-	{	/* 20 Mhz */ {   58.5f,		/* SGI */   65.0f, },
-		/* 40 Mhz */ {  121.5f,		/* SGI */  135.0f, },
-	},
-
-	/* MCS  7  */
-	{	/* 20 Mhz */ {   65.0f,		/* SGI */   72.2f, },
-		/* 40 Mhz */ {   135.0f,	/* SGI */  150.0f, },
-	},
-
-	/* MCS  8  */
-	{	/* 20 Mhz */ {   13.0f,		/* SGI */   14.4f, },
-		/* 40 Mhz */ {   27.0f,		/* SGI */   30.0f, },
-	},
-
-	/* MCS  9  */
-	{	/* 20 Mhz */ {   26.0f,		/* SGI */   28.9f, },
-		/* 40 Mhz */ {   54.0f,		/* SGI */   60.0f, },
-	},
-
-	/* MCS 10  */
-	{	/* 20 Mhz */ {   39.0f,		/* SGI */   43.3f, },
-		/* 40 Mhz */ {   81.0f,		/* SGI */   90.0f, },
-	},
-
-	/* MCS 11  */
-	{	/* 20 Mhz */ {   52.0f,		/* SGI */   57.8f, },
-		/* 40 Mhz */ {  108.0f,		/* SGI */  120.0f, },
-	},
-
-	/* MCS 12  */
-	{	/* 20 Mhz */ {   78.0f,		/* SGI */   86.7f, },
-		/* 40 Mhz */ {  162.0f,		/* SGI */  180.0f, },
-	},
-
-	/* MCS 13  */
-	{	/* 20 Mhz */ {  104.0f,		/* SGI */  115.6f, },
-		/* 40 Mhz */ {  216.0f,		/* SGI */  240.0f, },
-	},
-
-	/* MCS 14  */
-	{	/* 20 Mhz */ {  117.0f,		/* SGI */  130.0f, },
-		/* 40 Mhz */ {  243.0f,		/* SGI */  270.0f, },
-	},
-
-	/* MCS 15  */
-	{	/* 20 Mhz */ {  130.0f,		/* SGI */  144.4f, },
-		/* 40 Mhz */ {  270.0f,		/* SGI */  300.0f, },
-	},
-
-	/* MCS 16  */
-	{	/* 20 Mhz */ {   19.5f,		/* SGI */   21.7f, },
-		/* 40 Mhz */ {   40.5f,		/* SGI */   45.0f, },
-	},
-
-	/* MCS 17  */
-	{	/* 20 Mhz */ {   39.0f,		/* SGI */   43.3f, },
-		/* 40 Mhz */ {   81.0f,		/* SGI */   90.0f, },
-	},
-
-	/* MCS 18  */
-	{	/* 20 Mhz */ {   58.5f,		/* SGI */   65.0f, },
-		/* 40 Mhz */ {  121.5f,		/* SGI */  135.0f, },
-	},
-
-	/* MCS 19  */
-	{	/* 20 Mhz */ {   78.0f,		/* SGI */   86.7f, },
-		/* 40 Mhz */ {  162.0f,		/* SGI */  180.0f, },
-	},
-
-	/* MCS 20  */
-	{	/* 20 Mhz */ {  117.0f,		/* SGI */  130.0f, },
-		/* 40 Mhz */ {  243.0f,		/* SGI */  270.0f, },
-	},
-
-	/* MCS 21  */
-	{	/* 20 Mhz */ {  156.0f,		/* SGI */  173.3f, },
-		/* 40 Mhz */ {  324.0f,		/* SGI */  360.0f, },
-	},
-
-	/* MCS 22  */
-	{	/* 20 Mhz */ {  175.5f,		/* SGI */  195.0f, },
-		/* 40 Mhz */ {  364.5f,		/* SGI */  405.0f, },
-	},
-
-	/* MCS 23  */
-	{	/* 20 Mhz */ {  195.0f,		/* SGI */  216.7f, },
-		/* 40 Mhz */ {  405.0f,		/* SGI */  450.0f, },
-	},
-
-	/* MCS 24  */
-	{	/* 20 Mhz */ {   26.0f,		/* SGI */   28.9f, },
-		/* 40 Mhz */ {   54.0f,		/* SGI */   60.0f, },
-	},
-
-	/* MCS 25  */
-	{	/* 20 Mhz */ {   52.0f,		/* SGI */   57.8f, },
-		/* 40 Mhz */ {  108.0f,		/* SGI */  120.0f, },
-	},
-
-	/* MCS 26  */
-	{	/* 20 Mhz */ {   78.0f,		/* SGI */   86.7f, },
-		/* 40 Mhz */ {  162.0f,		/* SGI */  180.0f, },
-	},
-
-	/* MCS 27  */
-	{	/* 20 Mhz */ {  104.0f,		/* SGI */  115.6f, },
-		/* 40 Mhz */ {  216.0f,		/* SGI */  240.0f, },
-	},
-
-	/* MCS 28  */
-	{	/* 20 Mhz */ {  156.0f,		/* SGI */  173.3f, },
-		/* 40 Mhz */ {  324.0f,		/* SGI */  360.0f, },
-	},
-
-	/* MCS 29  */
-	{	/* 20 Mhz */ {  208.0f,		/* SGI */  231.1f, },
-		/* 40 Mhz */ {  432.0f,		/* SGI */  480.0f, },
-	},
-
-	/* MCS 30  */
-	{	/* 20 Mhz */ {  234.0f,		/* SGI */  260.0f, },
-		/* 40 Mhz */ {  486.0f,		/* SGI */  540.0f, },
-	},
-
-	/* MCS 31  */
-	{	/* 20 Mhz */ {  260.0f,		/* SGI */  288.9f, },
-		/* 40 Mhz */ {  540.0f,		/* SGI */  600.0f, },
-	},
-
-	/* MCS 32  */
-	{	/* 20 Mhz */ {    0.0f,		/* SGI */    0.0f, }, /* not valid */
-		/* 40 Mhz */ {    6.0f,		/* SGI */    6.7f, },
-	},
-
-	/* MCS 33  */
-	{	/* 20 Mhz */ {   39.0f,		/* SGI */   43.3f, },
-		/* 40 Mhz */ {   81.0f,		/* SGI */   90.0f, },
-	},
-
-	/* MCS 34  */
-	{	/* 20 Mhz */ {   52.0f,		/* SGI */   57.8f, },
-		/* 40 Mhz */ {  108.0f,		/* SGI */  120.0f, },
-	},
-
-	/* MCS 35  */
-	{	/* 20 Mhz */ {   65.0f,		/* SGI */   72.2f, },
-		/* 40 Mhz */ {  135.0f,		/* SGI */  150.0f, },
-	},
-
-	/* MCS 36  */
-	{	/* 20 Mhz */ {   58.5f,		/* SGI */   65.0f, },
-		/* 40 Mhz */ {  121.5f,		/* SGI */  135.0f, },
-	},
-
-	/* MCS 37  */
-	{	/* 20 Mhz */ {   78.0f,		/* SGI */   86.7f, },
-		/* 40 Mhz */ {  162.0f,		/* SGI */  180.0f, },
-	},
-
-	/* MCS 38  */
-	{	/* 20 Mhz */ {   97.5f,		/* SGI */  108.3f, },
-		/* 40 Mhz */ {  202.5f,		/* SGI */  225.0f, },
-	},
-
-	/* MCS 39  */
-	{	/* 20 Mhz */ {   52.0f,		/* SGI */   57.8f, },
-		/* 40 Mhz */ {  108.0f,		/* SGI */  120.0f, },
-	},
-
-	/* MCS 40  */
-	{	/* 20 Mhz */ {   65.0f,		/* SGI */   72.2f, },
-		/* 40 Mhz */ {  135.0f,		/* SGI */  150.0f, },
-	},
-
-	/* MCS 41  */
-	{	/* 20 Mhz */ {   65.0f,		/* SGI */   72.2f, },
-		/* 40 Mhz */ {  135.0f,		/* SGI */  150.0f, },
-	},
-
-	/* MCS 42  */
-	{	/* 20 Mhz */ {   78.0f,		/* SGI */   86.7f, },
-		/* 40 Mhz */ {  162.0f,		/* SGI */  180.0f, },
-	},
-
-	/* MCS 43  */
-	{	/* 20 Mhz */ {   91.0f,		/* SGI */  101.1f, },
-		/* 40 Mhz */ {  189.0f,		/* SGI */  210.0f, },
-	},
-
-	/* MCS 44  */
-	{	/* 20 Mhz */ {   91.0f,		/* SGI */  101.1f, },
-		/* 40 Mhz */ {  189.0f,		/* SGI */  210.0f, },
-	},
-
-	/* MCS 45  */
-	{	/* 20 Mhz */ {  104.0f,		/* SGI */  115.6f, },
-		/* 40 Mhz */ {  216.0f,		/* SGI */  240.0f, },
-	},
-
-	/* MCS 46  */
-	{	/* 20 Mhz */ {   78.0f,		/* SGI */   86.7f, },
-		/* 40 Mhz */ {  162.0f,		/* SGI */  180.0f, },
-	},
-
-	/* MCS 47  */
-	{	/* 20 Mhz */ {   97.5f,		/* SGI */  108.3f, },
-		/* 40 Mhz */ {  202.5f,		/* SGI */  225.0f, },
-	},
-
-	/* MCS 48  */
-	{	/* 20 Mhz */ {   97.5f,		/* SGI */  108.3f, },
-		/* 40 Mhz */ {  202.5f,		/* SGI */  225.0f, },
-	},
-
-	/* MCS 49  */
-	{	/* 20 Mhz */ {  117.0f,		/* SGI */  130.0f, },
-		/* 40 Mhz */ {  243.0f,		/* SGI */  270.0f, },
-	},
-
-	/* MCS 50  */
-	{	/* 20 Mhz */ {  136.5f,		/* SGI */  151.7f, },
-		/* 40 Mhz */ {  283.5f,		/* SGI */  315.0f, },
-	},
-
-	/* MCS 51  */
-	{	/* 20 Mhz */ {  136.5f,		/* SGI */  151.7f, },
-		/* 40 Mhz */ {  283.5f,		/* SGI */  315.0f, },
-	},
-
-	/* MCS 52  */
-	{	/* 20 Mhz */ {  156.0f,		/* SGI */  173.3f, },
-		/* 40 Mhz */ {  324.0f,		/* SGI */  360.0f, },
-	},
-
-	/* MCS 53  */
-	{	/* 20 Mhz */ {   65.0f,		/* SGI */   72.2f, },
-		/* 40 Mhz */ {  135.0f,		/* SGI */  150.0f, },
-	},
-
-	/* MCS 54  */
-	{	/* 20 Mhz */ {   78.0f,		/* SGI */   86.7f, },
-		/* 40 Mhz */ {  162.0f,		/* SGI */  180.0f, },
-	},
-
-	/* MCS 55  */
-	{	/* 20 Mhz */ {   91.0f,		/* SGI */  101.1f, },
-		/* 40 Mhz */ {  189.0f,		/* SGI */  210.0f, },
-	},
-
-	/* MCS 56  */
-	{	/* 20 Mhz */ {   78.0f,		/* SGI */   86.7f, },
-		/* 40 Mhz */ {  162.0f,		/* SGI */  180.0f, },
-	},
-
-	/* MCS 57  */
-	{	/* 20 Mhz */ {   91.0f,		/* SGI */  101.1f, },
-		/* 40 Mhz */ {  189.0f,		/* SGI */  210.0f, },
-	},
-
-	/* MCS 58  */
-	{	/* 20 Mhz */ {  104.0f,		/* SGI */  115.6f, },
-		/* 40 Mhz */ {  216.0f,		/* SGI */  240.0f, },
-	},
-
-	/* MCS 59  */
-	{	/* 20 Mhz */ {  117.0f,		/* SGI */  130.0f, },
-		/* 40 Mhz */ {  243.0f,		/* SGI */  270.0f, },
-	},
-
-	/* MCS 60  */
-	{	/* 20 Mhz */ {  104.0f,		/* SGI */  115.6f, },
-		/* 40 Mhz */ {  216.0f,		/* SGI */  240.0f, },
-	},
-
-	/* MCS 61  */
-	{	/* 20 Mhz */ {  117.0f,		/* SGI */  130.0f, },
-		/* 40 Mhz */ {  243.0f,		/* SGI */  270.0f, },
-	},
-
-	/* MCS 62  */
-	{	/* 20 Mhz */ {  130.0f,		/* SGI */  144.4f, },
-		/* 40 Mhz */ {  270.0f,		/* SGI */  300.0f, },
-	},
-
-	/* MCS 63  */
-	{	/* 20 Mhz */ {  130.0f,		/* SGI */  144.4f, },
-		/* 40 Mhz */ {  270.0f,		/* SGI */  300.0f, },
-	},
-
-	/* MCS 64  */
-	{	/* 20 Mhz */ {  143.0f,		/* SGI */  158.9f, },
-		/* 40 Mhz */ {  297.0f,		/* SGI */  330.0f, },
-	},
-
-	/* MCS 65  */
-	{	/* 20 Mhz */ {   97.5f,		/* SGI */  108.3f, },
-		/* 40 Mhz */ {  202.5f,		/* SGI */  225.0f, },
-	},
-
-	/* MCS 66  */
-	{	/* 20 Mhz */ {  117.0f,		/* SGI */  130.0f, },
-		/* 40 Mhz */ {  243.0f,		/* SGI */  270.0f, },
-	},
-
-	/* MCS 67  */
-	{	/* 20 Mhz */ {  136.5f,		/* SGI */  151.7f, },
-		/* 40 Mhz */ {  283.5f,		/* SGI */  315.0f, },
-	},
-
-	/* MCS 68  */
-	{	/* 20 Mhz */ {  117.0f,		/* SGI */  130.0f, },
-		/* 40 Mhz */ {  243.0f,		/* SGI */  270.0f, },
-	},
-
-	/* MCS 69  */
-	{	/* 20 Mhz */ {  136.5f,		/* SGI */  151.7f, },
-		/* 40 Mhz */ {  283.5f,		/* SGI */  315.0f, },
-	},
-
-	/* MCS 70  */
-	{	/* 20 Mhz */ {  156.0f,		/* SGI */  173.3f, },
-		/* 40 Mhz */ {  324.0f,		/* SGI */  360.0f, },
-	},
-
-	/* MCS 71  */
-	{	/* 20 Mhz */ {  175.5f,		/* SGI */  195.0f, },
-		/* 40 Mhz */ {  364.5f,		/* SGI */  405.0f, },
-	},
-
-	/* MCS 72  */
-	{	/* 20 Mhz */ {  156.0f,		/* SGI */  173.3f, },
-		/* 40 Mhz */ {  324.0f,		/* SGI */  360.0f, },
-	},
-
-	/* MCS 73  */
-	{	/* 20 Mhz */ {  175.5f,		/* SGI */  195.0f, },
-		/* 40 Mhz */ {  364.5f,		/* SGI */  405.0f, },
-	},
-
-	/* MCS 74  */
-	{	/* 20 Mhz */ {  195.0f,		/* SGI */  216.7f, },
-		/* 40 Mhz */ {  405.0f,		/* SGI */  450.0f, },
-	},
-
-	/* MCS 75  */
-	{	/* 20 Mhz */ {  195.0f,		/* SGI */  216.7f, },
-		/* 40 Mhz */ {  405.0f,		/* SGI */  450.0f, },
-	},
-
-	/* MCS 76  */
-	{	/* 20 Mhz */ {  214.5f,		/* SGI */  238.3f, },
-		/* 40 Mhz */ {  445.5f,		/* SGI */  495.0f, },
-	},
+  /* MCS  0  */
+  { /* 20 Mhz */ {    6.5f,   /* SGI */    7.2f, },
+    /* 40 Mhz */ {   13.5f,   /* SGI */   15.0f, },
+  },
+
+  /* MCS  1  */
+  { /* 20 Mhz */ {   13.0f,   /* SGI */   14.4f, },
+    /* 40 Mhz */ {   27.0f,   /* SGI */   30.0f, },
+  },
+
+  /* MCS  2  */
+  { /* 20 Mhz */ {   19.5f,   /* SGI */   21.7f, },
+    /* 40 Mhz */ {   40.5f,   /* SGI */   45.0f, },
+  },
+
+  /* MCS  3  */
+  { /* 20 Mhz */ {   26.0f,   /* SGI */   28.9f, },
+    /* 40 Mhz */ {   54.0f,   /* SGI */   60.0f, },
+  },
+
+  /* MCS  4  */
+  { /* 20 Mhz */ {   39.0f,   /* SGI */   43.3f, },
+    /* 40 Mhz */ {   81.0f,   /* SGI */   90.0f, },
+  },
+
+  /* MCS  5  */
+  { /* 20 Mhz */ {   52.0f,   /* SGI */   57.8f, },
+    /* 40 Mhz */ {  108.0f,   /* SGI */  120.0f, },
+  },
+
+  /* MCS  6  */
+  { /* 20 Mhz */ {   58.5f,   /* SGI */   65.0f, },
+    /* 40 Mhz */ {  121.5f,   /* SGI */  135.0f, },
+  },
+
+  /* MCS  7  */
+  { /* 20 Mhz */ {   65.0f,   /* SGI */   72.2f, },
+    /* 40 Mhz */ {   135.0f,  /* SGI */  150.0f, },
+  },
+
+  /* MCS  8  */
+  { /* 20 Mhz */ {   13.0f,   /* SGI */   14.4f, },
+    /* 40 Mhz */ {   27.0f,   /* SGI */   30.0f, },
+  },
+
+  /* MCS  9  */
+  { /* 20 Mhz */ {   26.0f,   /* SGI */   28.9f, },
+    /* 40 Mhz */ {   54.0f,   /* SGI */   60.0f, },
+  },
+
+  /* MCS 10  */
+  { /* 20 Mhz */ {   39.0f,   /* SGI */   43.3f, },
+    /* 40 Mhz */ {   81.0f,   /* SGI */   90.0f, },
+  },
+
+  /* MCS 11  */
+  { /* 20 Mhz */ {   52.0f,   /* SGI */   57.8f, },
+    /* 40 Mhz */ {  108.0f,   /* SGI */  120.0f, },
+  },
+
+  /* MCS 12  */
+  { /* 20 Mhz */ {   78.0f,   /* SGI */   86.7f, },
+    /* 40 Mhz */ {  162.0f,   /* SGI */  180.0f, },
+  },
+
+  /* MCS 13  */
+  { /* 20 Mhz */ {  104.0f,   /* SGI */  115.6f, },
+    /* 40 Mhz */ {  216.0f,   /* SGI */  240.0f, },
+  },
+
+  /* MCS 14  */
+  { /* 20 Mhz */ {  117.0f,   /* SGI */  130.0f, },
+    /* 40 Mhz */ {  243.0f,   /* SGI */  270.0f, },
+  },
+
+  /* MCS 15  */
+  { /* 20 Mhz */ {  130.0f,   /* SGI */  144.4f, },
+    /* 40 Mhz */ {  270.0f,   /* SGI */  300.0f, },
+  },
+
+  /* MCS 16  */
+  { /* 20 Mhz */ {   19.5f,   /* SGI */   21.7f, },
+    /* 40 Mhz */ {   40.5f,   /* SGI */   45.0f, },
+  },
+
+  /* MCS 17  */
+  { /* 20 Mhz */ {   39.0f,   /* SGI */   43.3f, },
+    /* 40 Mhz */ {   81.0f,   /* SGI */   90.0f, },
+  },
+
+  /* MCS 18  */
+  { /* 20 Mhz */ {   58.5f,   /* SGI */   65.0f, },
+    /* 40 Mhz */ {  121.5f,   /* SGI */  135.0f, },
+  },
+
+  /* MCS 19  */
+  { /* 20 Mhz */ {   78.0f,   /* SGI */   86.7f, },
+    /* 40 Mhz */ {  162.0f,   /* SGI */  180.0f, },
+  },
+
+  /* MCS 20  */
+  { /* 20 Mhz */ {  117.0f,   /* SGI */  130.0f, },
+    /* 40 Mhz */ {  243.0f,   /* SGI */  270.0f, },
+  },
+
+  /* MCS 21  */
+  { /* 20 Mhz */ {  156.0f,   /* SGI */  173.3f, },
+    /* 40 Mhz */ {  324.0f,   /* SGI */  360.0f, },
+  },
+
+  /* MCS 22  */
+  { /* 20 Mhz */ {  175.5f,   /* SGI */  195.0f, },
+    /* 40 Mhz */ {  364.5f,   /* SGI */  405.0f, },
+  },
+
+  /* MCS 23  */
+  { /* 20 Mhz */ {  195.0f,   /* SGI */  216.7f, },
+    /* 40 Mhz */ {  405.0f,   /* SGI */  450.0f, },
+  },
+
+  /* MCS 24  */
+  { /* 20 Mhz */ {   26.0f,   /* SGI */   28.9f, },
+    /* 40 Mhz */ {   54.0f,   /* SGI */   60.0f, },
+  },
+
+  /* MCS 25  */
+  { /* 20 Mhz */ {   52.0f,   /* SGI */   57.8f, },
+    /* 40 Mhz */ {  108.0f,   /* SGI */  120.0f, },
+  },
+
+  /* MCS 26  */
+  { /* 20 Mhz */ {   78.0f,   /* SGI */   86.7f, },
+    /* 40 Mhz */ {  162.0f,   /* SGI */  180.0f, },
+  },
+
+  /* MCS 27  */
+  { /* 20 Mhz */ {  104.0f,   /* SGI */  115.6f, },
+    /* 40 Mhz */ {  216.0f,   /* SGI */  240.0f, },
+  },
+
+  /* MCS 28  */
+  { /* 20 Mhz */ {  156.0f,   /* SGI */  173.3f, },
+    /* 40 Mhz */ {  324.0f,   /* SGI */  360.0f, },
+  },
+
+  /* MCS 29  */
+  { /* 20 Mhz */ {  208.0f,   /* SGI */  231.1f, },
+    /* 40 Mhz */ {  432.0f,   /* SGI */  480.0f, },
+  },
+
+  /* MCS 30  */
+  { /* 20 Mhz */ {  234.0f,   /* SGI */  260.0f, },
+    /* 40 Mhz */ {  486.0f,   /* SGI */  540.0f, },
+  },
+
+  /* MCS 31  */
+  { /* 20 Mhz */ {  260.0f,   /* SGI */  288.9f, },
+    /* 40 Mhz */ {  540.0f,   /* SGI */  600.0f, },
+  },
+
+  /* MCS 32  */
+  { /* 20 Mhz */ {    0.0f,   /* SGI */    0.0f, }, /* not valid */
+    /* 40 Mhz */ {    6.0f,   /* SGI */    6.7f, },
+  },
+
+  /* MCS 33  */
+  { /* 20 Mhz */ {   39.0f,   /* SGI */   43.3f, },
+    /* 40 Mhz */ {   81.0f,   /* SGI */   90.0f, },
+  },
+
+  /* MCS 34  */
+  { /* 20 Mhz */ {   52.0f,   /* SGI */   57.8f, },
+    /* 40 Mhz */ {  108.0f,   /* SGI */  120.0f, },
+  },
+
+  /* MCS 35  */
+  { /* 20 Mhz */ {   65.0f,   /* SGI */   72.2f, },
+    /* 40 Mhz */ {  135.0f,   /* SGI */  150.0f, },
+  },
+
+  /* MCS 36  */
+  { /* 20 Mhz */ {   58.5f,   /* SGI */   65.0f, },
+    /* 40 Mhz */ {  121.5f,   /* SGI */  135.0f, },
+  },
+
+  /* MCS 37  */
+  { /* 20 Mhz */ {   78.0f,   /* SGI */   86.7f, },
+    /* 40 Mhz */ {  162.0f,   /* SGI */  180.0f, },
+  },
+
+  /* MCS 38  */
+  { /* 20 Mhz */ {   97.5f,   /* SGI */  108.3f, },
+    /* 40 Mhz */ {  202.5f,   /* SGI */  225.0f, },
+  },
+
+  /* MCS 39  */
+  { /* 20 Mhz */ {   52.0f,   /* SGI */   57.8f, },
+    /* 40 Mhz */ {  108.0f,   /* SGI */  120.0f, },
+  },
+
+  /* MCS 40  */
+  { /* 20 Mhz */ {   65.0f,   /* SGI */   72.2f, },
+    /* 40 Mhz */ {  135.0f,   /* SGI */  150.0f, },
+  },
+
+  /* MCS 41  */
+  { /* 20 Mhz */ {   65.0f,   /* SGI */   72.2f, },
+    /* 40 Mhz */ {  135.0f,   /* SGI */  150.0f, },
+  },
+
+  /* MCS 42  */
+  { /* 20 Mhz */ {   78.0f,   /* SGI */   86.7f, },
+    /* 40 Mhz */ {  162.0f,   /* SGI */  180.0f, },
+  },
+
+  /* MCS 43  */
+  { /* 20 Mhz */ {   91.0f,   /* SGI */  101.1f, },
+    /* 40 Mhz */ {  189.0f,   /* SGI */  210.0f, },
+  },
+
+  /* MCS 44  */
+  { /* 20 Mhz */ {   91.0f,   /* SGI */  101.1f, },
+    /* 40 Mhz */ {  189.0f,   /* SGI */  210.0f, },
+  },
+
+  /* MCS 45  */
+  { /* 20 Mhz */ {  104.0f,   /* SGI */  115.6f, },
+    /* 40 Mhz */ {  216.0f,   /* SGI */  240.0f, },
+  },
+
+  /* MCS 46  */
+  { /* 20 Mhz */ {   78.0f,   /* SGI */   86.7f, },
+    /* 40 Mhz */ {  162.0f,   /* SGI */  180.0f, },
+  },
+
+  /* MCS 47  */
+  { /* 20 Mhz */ {   97.5f,   /* SGI */  108.3f, },
+    /* 40 Mhz */ {  202.5f,   /* SGI */  225.0f, },
+  },
+
+  /* MCS 48  */
+  { /* 20 Mhz */ {   97.5f,   /* SGI */  108.3f, },
+    /* 40 Mhz */ {  202.5f,   /* SGI */  225.0f, },
+  },
+
+  /* MCS 49  */
+  { /* 20 Mhz */ {  117.0f,   /* SGI */  130.0f, },
+    /* 40 Mhz */ {  243.0f,   /* SGI */  270.0f, },
+  },
+
+  /* MCS 50  */
+  { /* 20 Mhz */ {  136.5f,   /* SGI */  151.7f, },
+    /* 40 Mhz */ {  283.5f,   /* SGI */  315.0f, },
+  },
+
+  /* MCS 51  */
+  { /* 20 Mhz */ {  136.5f,   /* SGI */  151.7f, },
+    /* 40 Mhz */ {  283.5f,   /* SGI */  315.0f, },
+  },
+
+  /* MCS 52  */
+  { /* 20 Mhz */ {  156.0f,   /* SGI */  173.3f, },
+    /* 40 Mhz */ {  324.0f,   /* SGI */  360.0f, },
+  },
+
+  /* MCS 53  */
+  { /* 20 Mhz */ {   65.0f,   /* SGI */   72.2f, },
+    /* 40 Mhz */ {  135.0f,   /* SGI */  150.0f, },
+  },
+
+  /* MCS 54  */
+  { /* 20 Mhz */ {   78.0f,   /* SGI */   86.7f, },
+    /* 40 Mhz */ {  162.0f,   /* SGI */  180.0f, },
+  },
+
+  /* MCS 55  */
+  { /* 20 Mhz */ {   91.0f,   /* SGI */  101.1f, },
+    /* 40 Mhz */ {  189.0f,   /* SGI */  210.0f, },
+  },
+
+  /* MCS 56  */
+  { /* 20 Mhz */ {   78.0f,   /* SGI */   86.7f, },
+    /* 40 Mhz */ {  162.0f,   /* SGI */  180.0f, },
+  },
+
+  /* MCS 57  */
+  { /* 20 Mhz */ {   91.0f,   /* SGI */  101.1f, },
+    /* 40 Mhz */ {  189.0f,   /* SGI */  210.0f, },
+  },
+
+  /* MCS 58  */
+  { /* 20 Mhz */ {  104.0f,   /* SGI */  115.6f, },
+    /* 40 Mhz */ {  216.0f,   /* SGI */  240.0f, },
+  },
+
+  /* MCS 59  */
+  { /* 20 Mhz */ {  117.0f,   /* SGI */  130.0f, },
+    /* 40 Mhz */ {  243.0f,   /* SGI */  270.0f, },
+  },
+
+  /* MCS 60  */
+  { /* 20 Mhz */ {  104.0f,   /* SGI */  115.6f, },
+    /* 40 Mhz */ {  216.0f,   /* SGI */  240.0f, },
+  },
+
+  /* MCS 61  */
+  { /* 20 Mhz */ {  117.0f,   /* SGI */  130.0f, },
+    /* 40 Mhz */ {  243.0f,   /* SGI */  270.0f, },
+  },
+
+  /* MCS 62  */
+  { /* 20 Mhz */ {  130.0f,   /* SGI */  144.4f, },
+    /* 40 Mhz */ {  270.0f,   /* SGI */  300.0f, },
+  },
+
+  /* MCS 63  */
+  { /* 20 Mhz */ {  130.0f,   /* SGI */  144.4f, },
+    /* 40 Mhz */ {  270.0f,   /* SGI */  300.0f, },
+  },
+
+  /* MCS 64  */
+  { /* 20 Mhz */ {  143.0f,   /* SGI */  158.9f, },
+    /* 40 Mhz */ {  297.0f,   /* SGI */  330.0f, },
+  },
+
+  /* MCS 65  */
+  { /* 20 Mhz */ {   97.5f,   /* SGI */  108.3f, },
+    /* 40 Mhz */ {  202.5f,   /* SGI */  225.0f, },
+  },
+
+  /* MCS 66  */
+  { /* 20 Mhz */ {  117.0f,   /* SGI */  130.0f, },
+    /* 40 Mhz */ {  243.0f,   /* SGI */  270.0f, },
+  },
+
+  /* MCS 67  */
+  { /* 20 Mhz */ {  136.5f,   /* SGI */  151.7f, },
+    /* 40 Mhz */ {  283.5f,   /* SGI */  315.0f, },
+  },
+
+  /* MCS 68  */
+  { /* 20 Mhz */ {  117.0f,   /* SGI */  130.0f, },
+    /* 40 Mhz */ {  243.0f,   /* SGI */  270.0f, },
+  },
+
+  /* MCS 69  */
+  { /* 20 Mhz */ {  136.5f,   /* SGI */  151.7f, },
+    /* 40 Mhz */ {  283.5f,   /* SGI */  315.0f, },
+  },
+
+  /* MCS 70  */
+  { /* 20 Mhz */ {  156.0f,   /* SGI */  173.3f, },
+    /* 40 Mhz */ {  324.0f,   /* SGI */  360.0f, },
+  },
+
+  /* MCS 71  */
+  { /* 20 Mhz */ {  175.5f,   /* SGI */  195.0f, },
+    /* 40 Mhz */ {  364.5f,   /* SGI */  405.0f, },
+  },
+
+  /* MCS 72  */
+  { /* 20 Mhz */ {  156.0f,   /* SGI */  173.3f, },
+    /* 40 Mhz */ {  324.0f,   /* SGI */  360.0f, },
+  },
+
+  /* MCS 73  */
+  { /* 20 Mhz */ {  175.5f,   /* SGI */  195.0f, },
+    /* 40 Mhz */ {  364.5f,   /* SGI */  405.0f, },
+  },
+
+  /* MCS 74  */
+  { /* 20 Mhz */ {  195.0f,   /* SGI */  216.7f, },
+    /* 40 Mhz */ {  405.0f,   /* SGI */  450.0f, },
+  },
+
+  /* MCS 75  */
+  { /* 20 Mhz */ {  195.0f,   /* SGI */  216.7f, },
+    /* 40 Mhz */ {  405.0f,   /* SGI */  450.0f, },
+  },
+
+  /* MCS 76  */
+  { /* 20 Mhz */ {  214.5f,   /* SGI */  238.3f, },
+    /* 40 Mhz */ {  445.5f,   /* SGI */  495.0f, },
+  },
 };
 
 static gint ett_radio = -1;
diff --git a/epan/dissectors/packet-mpls-psc.c b/epan/dissectors/packet-mpls-psc.c
index 1374fb6f40..e3400fa8d4 100644
--- a/epan/dissectors/packet-mpls-psc.c
+++ b/epan/dissectors/packet-mpls-psc.c
@@ -237,7 +237,7 @@ proto_register_mpls_psc(void)
 void
 proto_reg_handoff_mpls_psc(void)
 {
-	dissector_handle_t mpls_psc_handle;
+    dissector_handle_t mpls_psc_handle;
 
     mpls_psc_handle    = create_dissector_handle( dissect_mpls_psc, proto_mpls_psc );
     dissector_add_uint("pwach.channel_type", 0x0024, mpls_psc_handle); /* FF: PSC, RFC 6378 */
diff --git a/epan/dissectors/packet-mpls.c b/epan/dissectors/packet-mpls.c
index 75b0c9a5da..154477628d 100644
--- a/epan/dissectors/packet-mpls.c
+++ b/epan/dissectors/packet-mpls.c
@@ -399,10 +399,10 @@ dissect_pw_ach(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 
     next_tvb     = tvb_new_subset_remaining(tvb, 4);
 
-	if (!dissector_try_uint(pw_ach_subdissector_table, channel_type, next_tvb, pinfo, tree))
-	{
+    if (!dissector_try_uint(pw_ach_subdissector_table, channel_type, next_tvb, pinfo, tree))
+    {
         call_dissector(dissector_data, next_tvb, pinfo, tree);
-	}
+    }
 
     if (channel_type == ACH_TYPE_BFD_CV)
     {
diff --git a/epan/dissectors/packet-nbns.c b/epan/dissectors/packet-nbns.c
index ce849582ab..d2b0b0f03d 100644
--- a/epan/dissectors/packet-nbns.c
+++ b/epan/dissectors/packet-nbns.c
@@ -1108,15 +1108,15 @@ static dissector_handle_t data_handle;
 static void
 dissect_netbios_payload(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 {
-	heur_dtbl_entry_t *hdtbl_entry;
-
-	/*
-	 * Try the heuristic dissectors for NetBIOS; if none of them
-	 * accept the packet, dissect it as data.
-	 */
-	if (!dissector_try_heuristic(netbios_heur_subdissector_list,
-				    tvb, pinfo, tree, &hdtbl_entry, NULL))
-		call_dissector(data_handle,tvb, pinfo, tree);
+    heur_dtbl_entry_t *hdtbl_entry;
+
+    /*
+     * Try the heuristic dissectors for NetBIOS; if none of them
+     * accept the packet, dissect it as data.
+     */
+    if (!dissector_try_heuristic(netbios_heur_subdissector_list,
+                                 tvb, pinfo, tree, &hdtbl_entry, NULL))
+        call_dissector(data_handle,tvb, pinfo, tree);
 }
 
 /* NetBIOS datagram packet, from RFC 1002, page 32 */
diff --git a/epan/dissectors/packet-nsip.c b/epan/dissectors/packet-nsip.c
index 9022c74d23..128a50cf8f 100644
--- a/epan/dissectors/packet-nsip.c
+++ b/epan/dissectors/packet-nsip.c
@@ -603,7 +603,7 @@ decode_iei_control_bits(nsip_ie_t *ie _U_, build_info_t *bi, int ie_start_offset
 
   control_bits = tvb_get_guint8(bi->tvb, bi->offset);
   proto_tree_add_bitmask(bi->nsip_tree, bi->tvb, ie_start_offset, hf_nsip_control_bits,
-			       ett_nsip_control_bits, flags, ENC_NA);
+                         ett_nsip_control_bits, flags, ENC_NA);
   bi->offset++;
 
   if (control_bits & NSIP_MASK_CONTROL_BITS_R) {
diff --git a/epan/dissectors/packet-ppp.c b/epan/dissectors/packet-ppp.c
index 5a108a021c..d35dd4abb8 100644
--- a/epan/dissectors/packet-ppp.c
+++ b/epan/dissectors/packet-ppp.c
@@ -4116,13 +4116,13 @@ dissect_bcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
     guint8 mac_type;
     gint captured_length, reported_length, pad_length;
     tvbuff_t *next_tvb;
-	static const int * bcp_flags[] = {
-		&hf_bcp_fcs_present,
-		&hf_bcp_zeropad,
-		&hf_bcp_bcontrol,
-		&hf_bcp_pads,
-		NULL
-	};
+    static const int * bcp_flags[] = {
+        &hf_bcp_fcs_present,
+        &hf_bcp_zeropad,
+        &hf_bcp_bcontrol,
+        &hf_bcp_pads,
+        NULL
+    };
 
     col_set_str(pinfo->cinfo, COL_PROTOCOL, "PPP BCP");
     col_clear(pinfo->cinfo, COL_INFO);
@@ -5457,7 +5457,7 @@ proto_reg_handoff_ppp(void)
     dissector_add_uint("osinl.excl", NLPID_PPP, ppp_handle);
     dissector_add_uint("gre.proto", ETHERTYPE_PPP, ppp_hdlc_handle);
     dissector_add_uint("juniper.proto", JUNIPER_PROTO_PPP, ppp_handle);
-	dissector_add_uint("sflow_245.header_protocol", SFLOW_245_HEADER_PPP, ppp_hdlc_handle);
+    dissector_add_uint("sflow_245.header_protocol", SFLOW_245_HEADER_PPP, ppp_hdlc_handle);
 }
 
 void
diff --git a/epan/dissectors/packet-rgmp.c b/epan/dissectors/packet-rgmp.c
index 0729b69301..a0070f1185 100644
--- a/epan/dissectors/packet-rgmp.c
+++ b/epan/dissectors/packet-rgmp.c
@@ -43,7 +43,7 @@ static int hf_maddr        = -1;
 
 static int ett_rgmp = -1;
 
-#define MC_RGMP			0xe0000019
+#define MC_RGMP 0xe0000019
 
 static const value_string rgmp_types[] = {
     {IGMP_RGMP_LEAVE, "Leave"},
diff --git a/epan/dissectors/packet-rtse.c b/epan/dissectors/packet-rtse.c
index b28b3977b1..32a2a81e40 100644
--- a/epan/dissectors/packet-rtse.c
+++ b/epan/dissectors/packet-rtse.c
@@ -231,7 +231,7 @@ call_rtse_external_type_callback(gboolean implicit_tag _U_, tvbuff_t *tvb, int o
     }
 
     if (oid)
-    	offset = call_rtse_oid_callback(oid, tvb, offset, actx->pinfo, top_tree ? top_tree : tree, actx->private_data);
+   	offset = call_rtse_oid_callback(oid, tvb, offset, actx->pinfo, top_tree ? top_tree : tree, actx->private_data);
 
     return offset;
 }
diff --git a/epan/dissectors/packet-sflow.c b/epan/dissectors/packet-sflow.c
index 7fe4fba112..2f1a725726 100644
--- a/epan/dissectors/packet-sflow.c
+++ b/epan/dissectors/packet-sflow.c
@@ -688,11 +688,11 @@ dissect_sflow_245_sampled_header(tvbuff_t *tvb, packet_info *pinfo,
 
     TRY
     {
-	    if ((global_dissect_samp_headers == FALSE) ||
+        if ((global_dissect_samp_headers == FALSE) ||
             !dissector_try_uint(header_subdissector_table, header_proto, next_tvb, pinfo, sflow_245_header_tree))
-	    {
+        {
             call_dissector(data_handle, next_tvb, pinfo, sflow_245_header_tree);
-	    }
+        }
     }
 
     CATCH_BOUNDS_ERRORS {
diff --git a/epan/dissectors/packet-sigcomp.c b/epan/dissectors/packet-sigcomp.c
index 3dbbe5d089..531934bb21 100644
--- a/epan/dissectors/packet-sigcomp.c
+++ b/epan/dissectors/packet-sigcomp.c
@@ -331,7 +331,7 @@ static int dissect_sigcomp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree
 
 static proto_tree *top_tree;
 
-#define UDVM_MEMORY_SIZE						65536
+#define UDVM_MEMORY_SIZE   65536
 
 /**********************************************************************************************
  *
@@ -903,266 +903,266 @@ static GHashTable *state_buffer_table=NULL;
 
 
 static void
-sigcomp_init_udvm(void){
-
-	gchar *partial_state_str;
-	guint8 *sip_sdp_buff, *presence_buff;
-
-	/* Destroy any existing memory chunks / hashes. */
-	if (state_buffer_table){
-		g_hash_table_destroy(state_buffer_table);
-	}
-
-
-	state_buffer_table = g_hash_table_new_full(g_str_hash,
-		g_str_equal,
-		g_free, /* key_destroy_func */
-		g_free); /* value_destroy_func */
-	/*
-	 * Store static dictionaries in hash table
-	 */
-	sip_sdp_buff = (guint8 *)g_malloc(SIP_SDP_STATE_LENGTH + 8);
-
-	partial_state_str = bytes_to_str(NULL, sip_sdp_state_identifier, 6);
-
-	/*
-	 * Debug 	g_warning("Sigcomp init: Storing partial state =%s",partial_state_str);
-	 */
-	memset(sip_sdp_buff, 0, 8);
-	sip_sdp_buff[0] = SIP_SDP_STATE_LENGTH >> 8;
-	sip_sdp_buff[1] = SIP_SDP_STATE_LENGTH & 0xff;
-	memcpy(sip_sdp_buff+8, sip_sdp_static_dictionaty_for_sigcomp, SIP_SDP_STATE_LENGTH);
-
-	g_hash_table_insert(state_buffer_table, g_strdup(partial_state_str), sip_sdp_buff);
-	wmem_free(NULL, partial_state_str);
-	/*	Debug
-	 *	g_warning("g_hash_table_insert = 0x%x",sip_sdp_buff);
-	 *  g_warning("g_hash_table_insert = 0x%x",sip_sdp_buff);
-	 */
-
-	presence_buff = (guint8 *)g_malloc(PRESENCE_STATE_LENGTH + 8);
-
-	partial_state_str = bytes_to_str(NULL, presence_state_identifier, 6);
-
-	memset(presence_buff, 0, 8);
-	presence_buff[0] = PRESENCE_STATE_LENGTH >> 8;
-	presence_buff[1] = PRESENCE_STATE_LENGTH & 0xff;
-	memcpy(presence_buff+8, presence_static_dictionary_for_sigcomp, PRESENCE_STATE_LENGTH);
-
-	g_hash_table_insert(state_buffer_table, g_strdup(partial_state_str), presence_buff);
-	wmem_free(NULL, partial_state_str);
+sigcomp_init_udvm(void) {
+
+    gchar  *partial_state_str;
+    guint8 *sip_sdp_buff, *presence_buff;
+
+    /* Destroy any existing memory chunks / hashes. */
+    if (state_buffer_table) {
+        g_hash_table_destroy(state_buffer_table);
+    }
+
+
+    state_buffer_table = g_hash_table_new_full(g_str_hash,
+                                               g_str_equal,
+                                               g_free, /* key_destroy_func */
+                                               g_free); /* value_destroy_func */
+    /*
+     * Store static dictionaries in hash table
+     */
+    sip_sdp_buff = (guint8 *)g_malloc(SIP_SDP_STATE_LENGTH + 8);
+
+    partial_state_str = bytes_to_str(NULL, sip_sdp_state_identifier, 6);
+
+    /*
+     * Debug  g_warning("Sigcomp init: Storing partial state =%s",partial_state_str);
+     */
+    memset(sip_sdp_buff, 0, 8);
+    sip_sdp_buff[0] = SIP_SDP_STATE_LENGTH >> 8;
+    sip_sdp_buff[1] = SIP_SDP_STATE_LENGTH & 0xff;
+    memcpy(sip_sdp_buff+8, sip_sdp_static_dictionaty_for_sigcomp, SIP_SDP_STATE_LENGTH);
+
+    g_hash_table_insert(state_buffer_table, g_strdup(partial_state_str), sip_sdp_buff);
+    wmem_free(NULL, partial_state_str);
+    /* Debug
+     *  g_warning("g_hash_table_insert = 0x%x",sip_sdp_buff);
+     *  g_warning("g_hash_table_insert = 0x%x",sip_sdp_buff);
+     */
+
+    presence_buff = (guint8 *)g_malloc(PRESENCE_STATE_LENGTH + 8);
+
+    partial_state_str = bytes_to_str(NULL, presence_state_identifier, 6);
+
+    memset(presence_buff, 0, 8);
+    presence_buff[0] = PRESENCE_STATE_LENGTH >> 8;
+    presence_buff[1] = PRESENCE_STATE_LENGTH & 0xff;
+    memcpy(presence_buff+8, presence_static_dictionary_for_sigcomp, PRESENCE_STATE_LENGTH);
+
+    g_hash_table_insert(state_buffer_table, g_strdup(partial_state_str), presence_buff);
+    wmem_free(NULL, partial_state_str);
 }
 
 
 static int udvm_state_access(tvbuff_t *tvb, proto_tree *tree,guint8 *buff,guint16 p_id_start, guint16 p_id_length, guint16 state_begin, guint16 *state_length,
-					   guint16 *state_address, guint16 *state_instruction,
-					   gint hf_id)
+                             guint16 *state_address, guint16 *state_instruction,
+                             gint hf_id)
 {
-	int			result_code = 0;
-	guint32		n;
-	guint16		k;
-	guint16		buf_size_real;
-	guint16		byte_copy_right;
-	guint16		byte_copy_left;
-	char		partial_state[STATE_BUFFER_SIZE]; /* Size is 6 - 20 */
-	guint8		*state_buff;
-	gchar		*partial_state_str;
-
-	/*
-	 * Perform initial checks on validity of data
-	 * RFC 3320 :
-	 * 9.4.5.  STATE-ACCESS
-	 * :
-	 * Decompression failure occurs if partial_identifier_length does not
-	 * lie between 6 and 20 inclusive.  Decompression failure also occurs if
-	 * no state item matching the partial state identifier can be found, if
-	 * more than one state item matches the partial identifier, or if
-	 * partial_identifier_length is less than the minimum_access_length of
-	 * the matched state item. Otherwise, a state item is returned from the
-	 * state handler.
-	 */
-
-	if (( p_id_length < STATE_MIN_ACCESS_LEN ) || ( p_id_length > STATE_BUFFER_SIZE )){
-		result_code = 1;
-		return result_code;
-	}
-
-	n = 0;
-	while ( n < p_id_length && n < STATE_BUFFER_SIZE && p_id_start + n < UDVM_MEMORY_SIZE ){
-		partial_state[n] = buff[p_id_start + n];
-		n++;
-	}
-	partial_state_str = bytes_to_str(wmem_packet_scope(), partial_state, p_id_length);
-	proto_tree_add_text(tree,tvb, 0, -1,"### Accessing state ###");
-	proto_tree_add_string(tree,hf_id, tvb, 0, 0, partial_state_str);
-
-	/*  Debug
-	 *	g_warning("State Access: partial state =%s",partial_state_str);
-	 *	g_warning("g_hash_table_lookup = 0x%x",state_buff);
-	 * g_warning("State Access: partial state =%s",partial_state_str);
-	 */
-	state_buff = (guint8 *)g_hash_table_lookup(state_buffer_table, partial_state_str);
-	if ( state_buff == NULL ){
-		result_code = 2; /* No state match */
-		return result_code;
-	}
-	/*
-	 * sip_sdp_static_dictionaty
-	 *
-	 * 8.4.  Byte copying
-	 * :
-	 * The string of bytes is copied in ascending order of memory address,
-	 * respecting the bounds set by byte_copy_left and byte_copy_right.
-	 * More precisely, if a byte is copied from/to Address m then the next
-	 * byte is copied from/to Address n where n is calculated as follows:
-	 *
-	 * Set k := m + 1 (modulo 2^16)
-	 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
-	 *
-	 */
-
-	/*
-	 * buff					= Where "state" will be stored
-	 * p_id_start			= Partial state identifier start pos in the buffer(buff)
-	 * p-id_length			= Partial state identifier length
-	 * state_begin			= Where to start to read state from
-	 * state_length			= Length of state
-	 * state_address		= Address where to store the state in the buffer(buff)
-	 * state_instruction	=
-	 * FALSE				= Indicates that state_* is in the stored state
-	 */
-
-	buf_size_real = (state_buff[0] << 8) | state_buff[1];
-
-	/*
-	 * The value of
-	 * state_length MUST be taken from the returned item of state in the
-	 * case that the state_length operand is set to 0.
-	 *
-	 * The same is true of state_address, state_instruction.
-	 */
-	if (*state_length == 0) {
-		*state_length = buf_size_real;
-	}
-	if ( *state_address == 0 ){
-		*state_address = state_buff[2] << 8;
-		*state_address = *state_address | state_buff[3];
-	}
-	if ( *state_instruction == 0 ){
-		*state_instruction = state_buff[4] << 8;
-		*state_instruction = *state_instruction | state_buff[5];
-	}
-
-	/*
-	 * Decompression failure occurs if bytes are copied from beyond the end of
-	 * the state_value.
-	 */
-	if ((state_begin + *state_length) > buf_size_real) {
-		return 3;
-	}
-
-	/*
-	 * Note that decompression failure will always occur if the state_length
-	 * operand is set to 0 but the state_begin operand is non-zero.
-	 */
-	if (*state_length == 0 && state_begin != 0) {
-		return 17;
-	}
-
-	n = state_begin + 8;
-	k = *state_address;
-
-	/*
-	 * NOTE: Strictly speaking, byte_copy_left and byte_copy_right should
-	 *       not be used if this has been called for bytecode referenced in
-	 *       the message header. However, since the memory is initialised
-	 *       to zero, the code works OK.
-	 */
-	byte_copy_right = buff[66] << 8;
-	byte_copy_right = byte_copy_right | buff[67];
-	byte_copy_left = buff[64] << 8;
-	byte_copy_left = byte_copy_left | buff[65];
-	/* debug
-	 *g_warning(" state_begin %u state_address %u",state_begin , *state_address);
-	 */
-	while ( (gint32) n < (state_begin + *state_length + 8) && n < UDVM_MEMORY_SIZE ){
-		buff[k] = state_buff[n];
-		/*  debug
-		 g_warning(" Loading 0x%x at address %u",buff[k] , k);
-		 */
-		k = ( k + 1 ) & 0xffff;
-		if ( k == byte_copy_right ){
-			k = byte_copy_left;
-		}
-		n++;
-	}
-	return 0;
-	/*
-	 * End SIP
-	 */
+    int      result_code = 0;
+    guint32  n;
+    guint16  k;
+    guint16  buf_size_real;
+    guint16  byte_copy_right;
+    guint16  byte_copy_left;
+    char     partial_state[STATE_BUFFER_SIZE]; /* Size is 6 - 20 */
+    guint8  *state_buff;
+    gchar   *partial_state_str;
+
+    /*
+     * Perform initial checks on validity of data
+     * RFC 3320 :
+     * 9.4.5.  STATE-ACCESS
+     * :
+     * Decompression failure occurs if partial_identifier_length does not
+     * lie between 6 and 20 inclusive.  Decompression failure also occurs if
+     * no state item matching the partial state identifier can be found, if
+     * more than one state item matches the partial identifier, or if
+     * partial_identifier_length is less than the minimum_access_length of
+     * the matched state item. Otherwise, a state item is returned from the
+     * state handler.
+     */
+
+    if (( p_id_length < STATE_MIN_ACCESS_LEN ) || ( p_id_length > STATE_BUFFER_SIZE )) {
+        result_code = 1;
+        return result_code;
+    }
+
+    n = 0;
+    while ( n < p_id_length && n < STATE_BUFFER_SIZE && p_id_start + n < UDVM_MEMORY_SIZE ) {
+        partial_state[n] = buff[p_id_start + n];
+        n++;
+    }
+    partial_state_str = bytes_to_str(wmem_packet_scope(), partial_state, p_id_length);
+    proto_tree_add_text(tree,tvb, 0, -1,"### Accessing state ###");
+    proto_tree_add_string(tree,hf_id, tvb, 0, 0, partial_state_str);
+
+    /* Debug
+     * g_warning("State Access: partial state =%s",partial_state_str);
+     * g_warning("g_hash_table_lookup = 0x%x",state_buff);
+     * g_warning("State Access: partial state =%s",partial_state_str);
+     */
+    state_buff = (guint8 *)g_hash_table_lookup(state_buffer_table, partial_state_str);
+    if ( state_buff == NULL ) {
+        result_code = 2; /* No state match */
+        return result_code;
+    }
+    /*
+     * sip_sdp_static_dictionaty
+     *
+     * 8.4.  Byte copying
+     * :
+     * The string of bytes is copied in ascending order of memory address,
+     * respecting the bounds set by byte_copy_left and byte_copy_right.
+     * More precisely, if a byte is copied from/to Address m then the next
+     * byte is copied from/to Address n where n is calculated as follows:
+     *
+     * Set k := m + 1 (modulo 2^16)
+     * If k = byte_copy_right then set n := byte_copy_left, else set n := k
+     *
+     */
+
+    /*
+     * buff              = Where "state" will be stored
+     * p_id_start        = Partial state identifier start pos in the buffer(buff)
+     * p-id_length       = Partial state identifier length
+     * state_begin       = Where to start to read state from
+     * state_length      = Length of state
+     * state_address     = Address where to store the state in the buffer(buff)
+     * state_instruction =
+     * FALSE             = Indicates that state_* is in the stored state
+     */
+
+    buf_size_real = (state_buff[0] << 8) | state_buff[1];
+
+    /*
+     * The value of
+     * state_length MUST be taken from the returned item of state in the
+     * case that the state_length operand is set to 0.
+     *
+     * The same is true of state_address, state_instruction.
+     */
+    if (*state_length == 0) {
+        *state_length = buf_size_real;
+    }
+    if ( *state_address == 0 ) {
+        *state_address = state_buff[2] << 8;
+        *state_address = *state_address | state_buff[3];
+    }
+    if ( *state_instruction == 0 ) {
+        *state_instruction = state_buff[4] << 8;
+        *state_instruction = *state_instruction | state_buff[5];
+    }
+
+    /*
+     * Decompression failure occurs if bytes are copied from beyond the end of
+     * the state_value.
+     */
+    if ((state_begin + *state_length) > buf_size_real) {
+        return 3;
+    }
+
+    /*
+     * Note that decompression failure will always occur if the state_length
+     * operand is set to 0 but the state_begin operand is non-zero.
+     */
+    if (*state_length == 0 && state_begin != 0) {
+        return 17;
+    }
+
+    n = state_begin + 8;
+    k = *state_address;
+
+    /*
+     * NOTE: Strictly speaking, byte_copy_left and byte_copy_right should
+     *       not be used if this has been called for bytecode referenced in
+     *       the message header. However, since the memory is initialised
+     *       to zero, the code works OK.
+     */
+    byte_copy_right = buff[66] << 8;
+    byte_copy_right = byte_copy_right | buff[67];
+    byte_copy_left = buff[64] << 8;
+    byte_copy_left = byte_copy_left | buff[65];
+    /* debug
+     *g_warning(" state_begin %u state_address %u",state_begin , *state_address);
+     */
+    while ( (gint32) n < (state_begin + *state_length + 8) && n < UDVM_MEMORY_SIZE ) {
+        buff[k] = state_buff[n];
+        /*  debug
+            g_warning(" Loading 0x%x at address %u",buff[k] , k);
+        */
+        k = ( k + 1 ) & 0xffff;
+        if ( k == byte_copy_right ) {
+            k = byte_copy_left;
+        }
+        n++;
+    }
+    return 0;
+    /*
+     * End SIP
+     */
 
 }
 
-static void udvm_state_create(guint8 *state_buff,guint8 *state_identifier,guint16 p_id_length){
-
-	char partial_state[STATE_BUFFER_SIZE];
-	guint i;
-	gchar *partial_state_str;
-	gchar *dummy_buff;
-	/*
-	 * Debug
-	g_warning("Received items of state,state_length_buff[0]= %u, state_length_buff[1]= %u",
-		state_length_buff[0],state_length_buff[1]);
-
-	 */
-	i = 0;
-	while ( i < p_id_length && i < STATE_BUFFER_SIZE ){
-		partial_state[i] = state_identifier[i];
-		i++;
-	}
-	partial_state_str = bytes_to_str(NULL, partial_state, p_id_length);
-
-	dummy_buff = (gchar *)g_hash_table_lookup(state_buffer_table, partial_state_str);
-	if ( dummy_buff == NULL ){
-		g_hash_table_insert(state_buffer_table, g_strdup(partial_state_str), state_buff);
-	}else{
-		/* The buffer allocated by sigcomp-udvm.c wasen't needed so free it
-		 */
-		g_free(state_buff);
-
-	}
-	wmem_free(NULL, partial_state_str);
+static void udvm_state_create(guint8 *state_buff,guint8 *state_identifier,guint16 p_id_length) {
+
+    char   partial_state[STATE_BUFFER_SIZE];
+    guint  i;
+    gchar *partial_state_str;
+    gchar *dummy_buff;
+    /*
+     * Debug
+     g_warning("Received items of state,state_length_buff[0]= %u, state_length_buff[1]= %u",
+     state_length_buff[0],state_length_buff[1]);
+
+    */
+    i = 0;
+    while ( i < p_id_length && i < STATE_BUFFER_SIZE ) {
+        partial_state[i] = state_identifier[i];
+        i++;
+    }
+    partial_state_str = bytes_to_str(NULL, partial_state, p_id_length);
+
+    dummy_buff = (gchar *)g_hash_table_lookup(state_buffer_table, partial_state_str);
+    if ( dummy_buff == NULL ) {
+        g_hash_table_insert(state_buffer_table, g_strdup(partial_state_str), state_buff);
+    } else {
+        /* The buffer allocated by sigcomp-udvm.c wasen't needed so free it
+         */
+        g_free(state_buff);
+
+    }
+    wmem_free(NULL, partial_state_str);
 }
 
 #if 1
-static void udvm_state_free(guint8 buff[] _U_,guint16 p_id_start _U_,guint16 p_id_length _U_){
+static void udvm_state_free(guint8 buff[] _U_,guint16 p_id_start _U_,guint16 p_id_length _U_) {
 }
 #else
-void udvm_state_free(guint8 buff[],guint16 p_id_start,guint16 p_id_length){
-	char partial_state[STATE_BUFFER_SIZE];
-	guint i;
-	gchar *partial_state_str;
-
-	gchar *dummy_buff;
-
-	i = 0;
-	while ( i < p_id_length && i < STATE_BUFFER_SIZE && p_id_start + i < UDVM_MEMORY_SIZE ){
-		partial_state[i] = buff[p_id_start + i];
-		i++;
-	}
-	partial_state_str = bytes_to_str(NULL, partial_state, p_id_length);
-	/* TODO Implement a state create counter before actually freeing states
-	 * Hmm is it a good idea to free the buffer at all?
-	 */
-	g_warning("State-free on  %s ",partial_state_str);
-	dummy_buff = g_hash_table_lookup(state_buffer_table, partial_state_str);
-	if ( dummy_buff == NULL ){
-		g_warning("State-free, state not found  %s",partial_state_str);
-	}else{
-		g_hash_table_remove (state_buffer_table, partial_state_str);
-		g_free(dummy_buff);
-	}
-	wmem_free(NULL, partial_state_str);
+void udvm_state_free(guint8 buff[],guint16 p_id_start,guint16 p_id_length) {
+    char   partial_state[STATE_BUFFER_SIZE];
+    guint  i;
+    gchar *partial_state_str;
+
+    gchar *dummy_buff;
+
+    i = 0;
+    while ( i < p_id_length && i < STATE_BUFFER_SIZE && p_id_start + i < UDVM_MEMORY_SIZE ) {
+        partial_state[i] = buff[p_id_start + i];
+        i++;
+    }
+    partial_state_str = bytes_to_str(NULL, partial_state, p_id_length);
+    /* TODO Implement a state create counter before actually freeing states
+     * Hmm is it a good idea to free the buffer at all?
+     */
+    g_warning("State-free on  %s ",partial_state_str);
+    dummy_buff = g_hash_table_lookup(state_buffer_table, partial_state_str);
+    if ( dummy_buff == NULL ) {
+        g_warning("State-free, state not found  %s",partial_state_str);
+    } else {
+        g_hash_table_remove (state_buffer_table, partial_state_str);
+        g_free(dummy_buff);
+    }
+    wmem_free(NULL, partial_state_str);
 }
 #endif
 
@@ -1171,7 +1171,7 @@ void udvm_state_free(guint8 buff[],guint16 p_id_start,guint16 p_id_length){
  *                       SIGCOMP DECOMPRESSION
  *
  **********************************************************************************************/
-#define	SIGCOMP_INSTR_DECOMPRESSION_FAILURE     0
+#define SIGCOMP_INSTR_DECOMPRESSION_FAILURE     0
 #define SIGCOMP_INSTR_AND                       1
 #define SIGCOMP_INSTR_OR                        2
 #define SIGCOMP_INSTR_NOT                       3
@@ -1216,26 +1216,26 @@ static gint show_instr_detail_level;
 
 /* Internal result code values of decompression failures */
 static const value_string result_code_vals[] = {
-	{ 0,	"No decompression failure" },
-	{ 1,	"Partial state length less than 6 or greater than 20 bytes long" },
-	{ 2,	"No state match" },
-	{ 3,	"state_begin + state_length > size of state" },
-	{ 4,	"Operand_2 is Zero" },
-	{ 5,	"Switch statement failed j >= n" },
-	{ 6,	"Attempt to jump outside of UDVM memory" },
-	{ 7,	"L in input-bits > 16" },
-	{ 8,	"input_bit_order > 7" },
-	{ 9,	"Instruction Decompression failure encountered" },
-	{10,	"Input huffman failed j > n" },
-	{11,	"Input bits requested beyond end of message" },
-	{12,	"more than four state creation requests are made before the END-MESSAGE instruction" },
-	{13,	"state_retention_priority is 65535" },
-	{14,	"Input bytes requested beyond end of message" },
-	{15,	"Maximum number of UDVM cycles reached" },
-	{16,	"UDVM stack underflow" },
-	{17,	"state_length is 0, but state_begin is non-zero" },
-	{ 255,	"This branch isn't coded yet" },
-	{ 0,    NULL }
+    {  0, "No decompression failure" },
+    {  1, "Partial state length less than 6 or greater than 20 bytes long" },
+    {  2, "No state match" },
+    {  3, "state_begin + state_length > size of state" },
+    {  4, "Operand_2 is Zero" },
+    {  5, "Switch statement failed j >= n" },
+    {  6, "Attempt to jump outside of UDVM memory" },
+    {  7, "L in input-bits > 16" },
+    {  8, "input_bit_order > 7" },
+    {  9, "Instruction Decompression failure encountered" },
+    { 10, "Input huffman failed j > n" },
+    { 11, "Input bits requested beyond end of message" },
+    { 12, "more than four state creation requests are made before the END-MESSAGE instruction" },
+    { 13, "state_retention_priority is 65535" },
+    { 14, "Input bytes requested beyond end of message" },
+    { 15, "Maximum number of UDVM cycles reached" },
+    { 16, "UDVM stack underflow" },
+    { 17, "state_length is 0, but state_begin is non-zero" },
+    {255, "This branch isn't coded yet" },
+    { 0,    NULL }
 };
 
  /*  The simplest operand type is the literal (#), which encodes a
@@ -1252,50 +1252,50 @@ static const value_string result_code_vals[] = {
 static int
 decode_udvm_literal_operand(guint8 *buff,guint operand_address, guint16 *value)
 {
-	guint	bytecode;
-	guint16 operand;
-	guint	test_bits;
-	guint	offset = operand_address;
-	guint8	temp_data;
-
-	bytecode = buff[operand_address];
-	test_bits = bytecode >> 7;
-	if (test_bits == 1){
-		test_bits = bytecode >> 6;
-		if (test_bits == 2){
-			/*
-			 * 10nnnnnn nnnnnnnn               N                   0 - 16383
-			 */
-			temp_data = buff[operand_address] & 0x1f;
-			operand = temp_data << 8;
-			temp_data = buff[(operand_address + 1) & 0xffff];
-			operand = operand | temp_data;
-			*value = operand;
-			offset = offset + 2;
-
-		}else{
-			/*
-			 * 111000000 nnnnnnnn nnnnnnnn      N                   0 - 65535
-			 */
-			offset ++;
-			temp_data = buff[operand_address] & 0x1f;
-			operand = temp_data << 8;
-			temp_data = buff[(operand_address + 1) & 0xffff];
-			operand = operand | temp_data;
-			*value = operand;
-			offset = offset + 2;
-
-		}
-	}else{
-		/*
-		 * 0nnnnnnn                        N                   0 - 127
-		 */
-		operand = ( bytecode & 0x7f);
-		*value = operand;
-		offset ++;
-	}
-
-	return offset;
+    guint   bytecode;
+    guint16 operand;
+    guint   test_bits;
+    guint   offset = operand_address;
+    guint8  temp_data;
+
+    bytecode = buff[operand_address];
+    test_bits = bytecode >> 7;
+    if (test_bits == 1) {
+        test_bits = bytecode >> 6;
+        if (test_bits == 2) {
+            /*
+             * 10nnnnnn nnnnnnnn               N                   0 - 16383
+             */
+            temp_data = buff[operand_address] & 0x1f;
+            operand = temp_data << 8;
+            temp_data = buff[(operand_address + 1) & 0xffff];
+            operand = operand | temp_data;
+            *value = operand;
+            offset = offset + 2;
+
+        } else {
+            /*
+             * 111000000 nnnnnnnn nnnnnnnn      N                   0 - 65535
+             */
+            offset ++;
+            temp_data = buff[operand_address] & 0x1f;
+            operand = temp_data << 8;
+            temp_data = buff[(operand_address + 1) & 0xffff];
+            operand = operand | temp_data;
+            *value = operand;
+            offset = offset + 2;
+
+        }
+    } else {
+        /*
+         * 0nnnnnnn                        N                   0 - 127
+         */
+        operand = ( bytecode & 0x7f);
+        *value = operand;
+        offset ++;
+    }
+
+    return offset;
 
 }
 
@@ -1316,248 +1316,248 @@ decode_udvm_literal_operand(guint8 *buff,guint operand_address, guint16 *value)
 static int
 dissect_udvm_reference_operand_memory(guint8 *buff,guint operand_address, guint16 *value,guint *result_dest)
 {
-	guint bytecode;
-	guint16 operand;
-	guint	offset = operand_address;
-	guint test_bits;
-	guint8	temp_data;
-	guint16 temp_data16;
-
-	bytecode = buff[operand_address];
-	test_bits = bytecode >> 7;
-	if (test_bits == 1){
-		test_bits = bytecode >> 6;
-		if (test_bits == 2){
-			/*
-			 * 10nnnnnn nnnnnnnn               memory[2 * N]       0 - 65535
-			 */
-			temp_data = buff[operand_address] & 0x3f;
-			operand = temp_data << 8;
-			temp_data = buff[(operand_address + 1) & 0xffff];
-			operand = operand | temp_data;
-			operand = (operand * 2);
-			*result_dest = operand;
-			temp_data16 = buff[operand] << 8;
-			temp_data16 = temp_data16 | buff[(operand+1) & 0xffff];
-			*value = temp_data16;
-			offset = offset + 2;
-
-		}else{
-			/*
-			 * 11000000 nnnnnnnn nnnnnnnn      memory[N]           0 - 65535
-			 */
-			operand_address++;
-			operand = buff[operand_address] << 8;
-			operand = operand | buff[(operand_address + 1) & 0xffff];
-			*result_dest = operand;
-			temp_data16 = buff[operand] << 8;
-			temp_data16 = temp_data16 | buff[(operand+1) & 0xffff];
-			*value = temp_data16;
-			offset = offset + 3;
-
-		}
-	}else{
-		/*
-		 * 0nnnnnnn                        memory[2 * N]       0 - 65535
-		 */
-		operand = ( bytecode & 0x7f);
-		operand = (operand * 2);
-		*result_dest = operand;
-		temp_data16 = buff[operand] << 8;
-		temp_data16 = temp_data16 | buff[(operand+1) & 0xffff];
-		*value = temp_data16;
-		offset ++;
-	}
-
-	if (offset >= UDVM_MEMORY_SIZE || *result_dest >= UDVM_MEMORY_SIZE - 1 )
-		THROW(ReportedBoundsError);
-
-	return offset;
+    guint   bytecode;
+    guint16 operand;
+    guint   offset = operand_address;
+    guint   test_bits;
+    guint8  temp_data;
+    guint16 temp_data16;
+
+    bytecode = buff[operand_address];
+    test_bits = bytecode >> 7;
+    if (test_bits == 1) {
+        test_bits = bytecode >> 6;
+        if (test_bits == 2) {
+            /*
+             * 10nnnnnn nnnnnnnn               memory[2 * N]       0 - 65535
+             */
+            temp_data = buff[operand_address] & 0x3f;
+            operand = temp_data << 8;
+            temp_data = buff[(operand_address + 1) & 0xffff];
+            operand = operand | temp_data;
+            operand = (operand * 2);
+            *result_dest = operand;
+            temp_data16 = buff[operand] << 8;
+            temp_data16 = temp_data16 | buff[(operand+1) & 0xffff];
+            *value = temp_data16;
+            offset = offset + 2;
+
+        } else {
+            /*
+             * 11000000 nnnnnnnn nnnnnnnn      memory[N]           0 - 65535
+             */
+            operand_address++;
+            operand = buff[operand_address] << 8;
+            operand = operand | buff[(operand_address + 1) & 0xffff];
+            *result_dest = operand;
+            temp_data16 = buff[operand] << 8;
+            temp_data16 = temp_data16 | buff[(operand+1) & 0xffff];
+            *value = temp_data16;
+            offset = offset + 3;
+
+        }
+    } else {
+        /*
+         * 0nnnnnnn                        memory[2 * N]       0 - 65535
+         */
+        operand = ( bytecode & 0x7f);
+        operand = (operand * 2);
+        *result_dest = operand;
+        temp_data16 = buff[operand] << 8;
+        temp_data16 = temp_data16 | buff[(operand+1) & 0xffff];
+        *value = temp_data16;
+        offset ++;
+    }
+
+    if (offset >= UDVM_MEMORY_SIZE || *result_dest >= UDVM_MEMORY_SIZE - 1 )
+        THROW(ReportedBoundsError);
+
+    return offset;
 }
 
-	/* RFC3320
-	 * Figure 10: Bytecode for a multitype (%) operand
-	 * Bytecode:                       Operand value:      Range:               HEX val
-	 * 00nnnnnn                        N                   0 - 63				0x00
-	 * 01nnnnnn                        memory[2 * N]       0 - 65535			0x40
-	 * 1000011n                        2 ^ (N + 6)        64 , 128				0x86
-	 * 10001nnn                        2 ^ (N + 8)    256 , ... , 32768			0x88
-	 * 111nnnnn                        N + 65504       65504 - 65535			0xe0
-	 * 1001nnnn nnnnnnnn               N + 61440       61440 - 65535			0x90
-	 * 101nnnnn nnnnnnnn               N                   0 - 8191				0xa0
-	 * 110nnnnn nnnnnnnn               memory[N]           0 - 65535			0xc0
-	 * 10000000 nnnnnnnn nnnnnnnn      N                   0 - 65535			0x80
-	 * 10000001 nnnnnnnn nnnnnnnn      memory[N]           0 - 65535			0x81
-	 */
+/* RFC3320
+ * Figure 10: Bytecode for a multitype (%) operand
+ * Bytecode:                       Operand value:      Range:           HEX val
+ * 00nnnnnn                        N                   0 - 63           0x00
+ * 01nnnnnn                        memory[2 * N]       0 - 65535        0x40
+ * 1000011n                        2 ^ (N + 6)        64 , 128          0x86
+ * 10001nnn                        2 ^ (N + 8)    256 , ... , 32768     0x88
+ * 111nnnnn                        N + 65504       65504 - 65535        0xe0
+ * 1001nnnn nnnnnnnn               N + 61440       61440 - 65535        0x90
+ * 101nnnnn nnnnnnnn               N                   0 - 8191         0xa0
+ * 110nnnnn nnnnnnnn               memory[N]           0 - 65535        0xc0
+ * 10000000 nnnnnnnn nnnnnnnn      N                   0 - 65535        0x80
+ * 10000001 nnnnnnnn nnnnnnnn      memory[N]           0 - 65535        0x81
+ */
 static int
 decode_udvm_multitype_operand(guint8 *buff,guint operand_address, guint16 *value)
 {
-	guint test_bits;
-	guint bytecode;
-	guint offset = operand_address;
-	guint16 operand;
-	guint32 result;
-	guint8 temp_data;
-	guint16 temp_data16;
-	guint16 memmory_addr = 0;
-
-	*value = 0;
-
-	bytecode = buff[operand_address];
-	test_bits = ( bytecode & 0xc0 ) >> 6;
-	switch (test_bits ){
-	case 0:
-		/*
-		 * 00nnnnnn                        N                   0 - 63
-		 */
-		operand =  buff[operand_address];
-		/* debug
-		 *g_warning("Reading 0x%x From address %u",operand,offset);
-		 */
-		*value = operand;
-		offset ++;
-		break;
-	case 1:
-		/*
-		 * 01nnnnnn                        memory[2 * N]       0 - 65535
-		 */
-		memmory_addr = ( bytecode & 0x3f) * 2;
-		temp_data16 = buff[memmory_addr] << 8;
-		temp_data16 = temp_data16 | buff[(memmory_addr+1) & 0xffff];
-		*value = temp_data16;
-		offset ++;
-		break;
-	case 2:
-		/* Check tree most significant bits */
-		test_bits = ( bytecode & 0xe0 ) >> 5;
-		if ( test_bits == 5 ){
-		/*
-		 * 101nnnnn nnnnnnnn               N                   0 - 8191
-		 */
-			temp_data = buff[operand_address] & 0x1f;
-			operand = temp_data << 8;
-			temp_data = buff[(operand_address + 1) & 0xffff];
-			operand = operand | temp_data;
-			*value = operand;
-			offset = offset + 2;
-		}else{
-			test_bits = ( bytecode & 0xf0 ) >> 4;
-			if ( test_bits == 9 ){
-		/*
-		 * 1001nnnn nnnnnnnn               N + 61440       61440 - 65535
-		 */
-				temp_data = buff[operand_address] & 0x0f;
-				operand = temp_data << 8;
-				temp_data = buff[(operand_address + 1) & 0xffff];
-				operand = operand | temp_data;
-				operand = operand + 61440;
-				*value = operand;
-				offset = offset + 2;
-			}else{
-				test_bits = ( bytecode & 0x08 ) >> 3;
-				if ( test_bits == 1){
-		/*
-		 * 10001nnn                        2 ^ (N + 8)    256 , ... , 32768
-		 */
-
-					result = 1 << ((buff[operand_address] & 0x07) + 8);
-					operand = result & 0xffff;
-					*value = operand;
-					offset ++;
-				}else{
-					test_bits = ( bytecode & 0x0e ) >> 1;
-					if ( test_bits == 3 ){
-						/*
-						 * 1000 011n                        2 ^ (N + 6)        64 , 128
-						 */
-						result = 1 << ((buff[operand_address] & 0x01) + 6);
-						operand = result & 0xffff;
-						*value = operand;
-						offset ++;
-					}else{
-					/*
-					 * 1000 0000 nnnnnnnn nnnnnnnn      N                   0 - 65535
-					 * 1000 0001 nnnnnnnn nnnnnnnn      memory[N]           0 - 65535
-					 */
-						offset ++;
-						temp_data16 = buff[(operand_address + 1) & 0xffff] << 8;
-						temp_data16 = temp_data16 | buff[(operand_address + 2) & 0xffff];
-						/*  debug
-						 * g_warning("Reading 0x%x From address %u",temp_data16,operand_address);
-						 */
-						if ( (bytecode & 0x01) == 1 ){
-							memmory_addr = temp_data16;
-							temp_data16 = buff[memmory_addr] << 8;
-							temp_data16 = temp_data16 | buff[(memmory_addr+1) & 0xffff];
-						}
-						*value = temp_data16;
-						offset = offset +2;
-					}
-
-
-				}
-			}
-		}
-		break;
-
-	case 3:
-		test_bits = ( bytecode & 0x20 ) >> 5;
-		if ( test_bits == 1 ){
-		/*
-		 * 111nnnnn                        N + 65504       65504 - 65535
-		 */
-			operand = ( buff[operand_address] & 0x1f) + 65504;
-			*value = operand;
-			offset ++;
-		}else{
-		/*
-		 * 110nnnnn nnnnnnnn               memory[N]           0 - 65535
-		 */
-			memmory_addr = buff[operand_address] & 0x1f;
-			memmory_addr = memmory_addr << 8;
-			memmory_addr = memmory_addr | buff[(operand_address + 1) & 0xffff];
-			temp_data16 = buff[memmory_addr] << 8;
-			temp_data16 = temp_data16 | buff[(memmory_addr+1) & 0xffff];
-			*value = temp_data16;
-			/*  debug
-			 * g_warning("Reading 0x%x From address %u",temp_data16,memmory_addr);
-			 */
-			offset = offset +2;
-		}
-
-	default :
-		break;
-	}
-	return offset;
+    guint   test_bits;
+    guint   bytecode;
+    guint   offset = operand_address;
+    guint16 operand;
+    guint32 result;
+    guint8  temp_data;
+    guint16 temp_data16;
+    guint16 memmory_addr = 0;
+
+    *value = 0;
+
+    bytecode = buff[operand_address];
+    test_bits = ( bytecode & 0xc0 ) >> 6;
+    switch (test_bits ) {
+    case 0:
+        /*
+         * 00nnnnnn                        N                   0 - 63
+         */
+        operand =  buff[operand_address];
+        /* debug
+         *g_warning("Reading 0x%x From address %u",operand,offset);
+         */
+        *value = operand;
+        offset ++;
+        break;
+    case 1:
+        /*
+         * 01nnnnnn                        memory[2 * N]       0 - 65535
+         */
+        memmory_addr = ( bytecode & 0x3f) * 2;
+        temp_data16 = buff[memmory_addr] << 8;
+        temp_data16 = temp_data16 | buff[(memmory_addr+1) & 0xffff];
+        *value = temp_data16;
+        offset ++;
+        break;
+    case 2:
+        /* Check tree most significant bits */
+        test_bits = ( bytecode & 0xe0 ) >> 5;
+        if ( test_bits == 5 ) {
+            /*
+             * 101nnnnn nnnnnnnn               N                   0 - 8191
+             */
+            temp_data = buff[operand_address] & 0x1f;
+            operand = temp_data << 8;
+            temp_data = buff[(operand_address + 1) & 0xffff];
+            operand = operand | temp_data;
+            *value = operand;
+            offset = offset + 2;
+        } else {
+            test_bits = ( bytecode & 0xf0 ) >> 4;
+            if ( test_bits == 9 ) {
+                /*
+                 * 1001nnnn nnnnnnnn               N + 61440       61440 - 65535
+                 */
+                temp_data = buff[operand_address] & 0x0f;
+                operand = temp_data << 8;
+                temp_data = buff[(operand_address + 1) & 0xffff];
+                operand = operand | temp_data;
+                operand = operand + 61440;
+                *value = operand;
+                offset = offset + 2;
+            } else {
+                test_bits = ( bytecode & 0x08 ) >> 3;
+                if ( test_bits == 1) {
+                    /*
+                     * 10001nnn                        2 ^ (N + 8)    256 , ... , 32768
+                     */
+
+                    result = 1 << ((buff[operand_address] & 0x07) + 8);
+                    operand = result & 0xffff;
+                    *value = operand;
+                    offset ++;
+                } else {
+                    test_bits = ( bytecode & 0x0e ) >> 1;
+                    if ( test_bits == 3 ) {
+                        /*
+                         * 1000 011n                        2 ^ (N + 6)        64 , 128
+                         */
+                        result = 1 << ((buff[operand_address] & 0x01) + 6);
+                        operand = result & 0xffff;
+                        *value = operand;
+                        offset ++;
+                    } else {
+                        /*
+                         * 1000 0000 nnnnnnnn nnnnnnnn      N                   0 - 65535
+                         * 1000 0001 nnnnnnnn nnnnnnnn      memory[N]           0 - 65535
+                         */
+                        offset ++;
+                        temp_data16 = buff[(operand_address + 1) & 0xffff] << 8;
+                        temp_data16 = temp_data16 | buff[(operand_address + 2) & 0xffff];
+                        /*  debug
+                         * g_warning("Reading 0x%x From address %u",temp_data16,operand_address);
+                         */
+                        if ( (bytecode & 0x01) == 1 ) {
+                            memmory_addr = temp_data16;
+                            temp_data16 = buff[memmory_addr] << 8;
+                            temp_data16 = temp_data16 | buff[(memmory_addr+1) & 0xffff];
+                        }
+                        *value = temp_data16;
+                        offset = offset +2;
+                    }
+
+
+                }
+            }
+        }
+        break;
+
+    case 3:
+        test_bits = ( bytecode & 0x20 ) >> 5;
+        if ( test_bits == 1 ) {
+            /*
+             * 111nnnnn                        N + 65504       65504 - 65535
+             */
+            operand = ( buff[operand_address] & 0x1f) + 65504;
+            *value = operand;
+            offset ++;
+        } else {
+            /*
+             * 110nnnnn nnnnnnnn               memory[N]           0 - 65535
+             */
+            memmory_addr = buff[operand_address] & 0x1f;
+            memmory_addr = memmory_addr << 8;
+            memmory_addr = memmory_addr | buff[(operand_address + 1) & 0xffff];
+            temp_data16 = buff[memmory_addr] << 8;
+            temp_data16 = temp_data16 | buff[(memmory_addr+1) & 0xffff];
+            *value = temp_data16;
+            /*  debug
+             * g_warning("Reading 0x%x From address %u",temp_data16,memmory_addr);
+             */
+            offset = offset +2;
+        }
+
+    default :
+        break;
+    }
+    return offset;
 }
-	/*
-	 *
-	 * The fourth operand type is the address (@).  This operand is decoded
-	 * as a multitype operand followed by a further step: the memory address
-	 * of the UDVM instruction containing the address operand is added to
-	 * obtain the correct operand value.  So if the operand value from
-	 * Figure 10 is D then the actual operand value of an address is
-	 * calculated as follows:
-	 *
-	 * operand_value = (memory_address_of_instruction + D) modulo 2^16
-	 *
-	 * Address operands are always used in instructions that control program
-	 * flow, because they ensure that the UDVM bytecode is position-
-	 * independent code (i.e., it will run independently of where it is
-	 * placed in the UDVM memory).
-	 */
+/*
+ *
+ * The fourth operand type is the address (@).  This operand is decoded
+ * as a multitype operand followed by a further step: the memory address
+ * of the UDVM instruction containing the address operand is added to
+ * obtain the correct operand value.  So if the operand value from
+ * Figure 10 is D then the actual operand value of an address is
+ * calculated as follows:
+ *
+ * operand_value = (memory_address_of_instruction + D) modulo 2^16
+ *
+ * Address operands are always used in instructions that control program
+ * flow, because they ensure that the UDVM bytecode is position-
+ * independent code (i.e., it will run independently of where it is
+ * placed in the UDVM memory).
+ */
 static int
 decode_udvm_address_operand(guint8 *buff,guint operand_address, guint16 *value,guint current_address)
 {
-	guint32 result;
-	guint16 value1;
-	guint next_opreand_address;
-
-	next_opreand_address = decode_udvm_multitype_operand(buff, operand_address, &value1);
-	result = value1 & 0xffff;
-	result = result + current_address;
-	*value = result & 0xffff;
-	return next_opreand_address;
+    guint32 result;
+    guint16 value1;
+    guint   next_opreand_address;
+
+    next_opreand_address = decode_udvm_multitype_operand(buff, operand_address, &value1);
+    result = value1 & 0xffff;
+    result = result + current_address;
+    *value = result & 0xffff;
+    return next_opreand_address;
 }
 
 
@@ -1602,2723 +1602,2723 @@ static guint8 reverse [] = {
 
 static int
 decomp_dispatch_get_bits(
-		tvbuff_t *message_tvb,
-		proto_tree *udvm_tree,
-		guint8 bit_order,
-		guint8 *buff,
-		guint16 *old_input_bit_order,
-		guint16 *remaining_bits,
-		guint16	*input_bits,
-		guint *input_address,
-		guint16 length,
-		guint16 *result_code,
-		guint msg_end)
+    tvbuff_t   *message_tvb,
+    proto_tree *udvm_tree,
+    guint8      bit_order,
+    guint8     *buff,
+    guint16    *old_input_bit_order,
+    guint16    *remaining_bits,
+    guint16    *input_bits,
+    guint      *input_address,
+    guint16     length,
+    guint16    *result_code,
+    guint       msg_end)
 {
-	guint16 input_bit_order;
-	guint16 bits_still_required = length;
-	guint16 value = 0;
-	guint8  octet;
-	gint    extra_bytes_available = msg_end - *input_address;
-	gint    p_bit;
-	gint    prev_p_bit = *old_input_bit_order & 0x0001;
-	gint    bits_to_use = 0;
-
-
-	input_bit_order = buff[68] << 8;
-	input_bit_order = input_bit_order | buff[69];
-	*result_code = 0;
-	p_bit = (input_bit_order & 0x0001) != 0;
-
-	/*
-	 * Discard any spare bits.
-	 * Note: We take care to avoid remaining_bits having the value of 8.
-	 */
-	if (prev_p_bit != p_bit)
-	{
-		*remaining_bits = 0;
-		*old_input_bit_order = input_bit_order;
-	}
-
-	/*
-	 * Check we can suppy the required number of bits now, before we alter
-	 * the input buffer's state.
-	 */
-	if (*remaining_bits + extra_bytes_available * 8 < length)
-	{
-		*result_code = 11;
-		return 0xfbad;
-	}
-
-	/* Note: This is never called with length > 16, so the following loop
-	*       never loops more than three time. */
-	while (bits_still_required > 0)
-	{
-		/*
-		 * We only put anything into input_bits if we know we will remove
-		 * at least one bit. That ensures we can simply discard the spare
-		 * bits if the P-bit changes.
-		 */
-		if (*remaining_bits == 0)
-		{
-			octet = tvb_get_guint8(message_tvb, *input_address);
-			if (print_level_1 ){
-				proto_tree_add_text(udvm_tree, message_tvb, *input_address , 1,
-						"               Getting value: %u (0x%x) From Addr: %u", octet, octet, *input_address);
-			}
-			*input_address = *input_address + 1;
-
-			if (p_bit != 0)
-			{
-				octet = reverse[octet];
-			}
-			*input_bits = octet;
-			*remaining_bits = 8;
-		}
-
-		/* Add some more bits to the accumulated value. */
-		bits_to_use = bits_still_required < *remaining_bits ? bits_still_required : *remaining_bits;
-		bits_still_required -= bits_to_use;
-
-		*input_bits <<= bits_to_use;           /* Shift bits into MSByte */
-		value = (value << bits_to_use)         /* Then add to the accumulated value */
-			| ((*input_bits >> 8) & 0xFF);
-		*remaining_bits -= bits_to_use;
-		*input_bits &= 0x00FF;                 /* Leave just the remaining bits */
-	}
-
-	if (bit_order != 0)
-	{
-		/* Bit reverse the entire word. */
-		guint16 lsb = reverse[(value >> 8) & 0xFF];
-		guint16 msb = reverse[value & 0xFF];
-
-		value = ((msb << 8) | lsb) >> (16 - length);
-	}
-
-	return value;
+    guint16     input_bit_order;
+    guint16     bits_still_required   = length;
+    guint16     value                 = 0;
+    guint8      octet;
+    gint        extra_bytes_available = msg_end - *input_address;
+    gint        p_bit;
+    gint        prev_p_bit            = *old_input_bit_order & 0x0001;
+    gint        bits_to_use           = 0;
+
+
+    input_bit_order = buff[68] << 8;
+    input_bit_order = input_bit_order | buff[69];
+    *result_code = 0;
+    p_bit = (input_bit_order & 0x0001) != 0;
+
+    /*
+     * Discard any spare bits.
+     * Note: We take care to avoid remaining_bits having the value of 8.
+     */
+    if (prev_p_bit != p_bit)
+    {
+        *remaining_bits = 0;
+        *old_input_bit_order = input_bit_order;
+    }
+
+    /*
+     * Check we can suppy the required number of bits now, before we alter
+     * the input buffer's state.
+     */
+    if (*remaining_bits + extra_bytes_available * 8 < length)
+    {
+        *result_code = 11;
+        return 0xfbad;
+    }
+
+    /* Note: This is never called with length > 16, so the following loop
+     *       never loops more than three time. */
+    while (bits_still_required > 0)
+    {
+        /*
+         * We only put anything into input_bits if we know we will remove
+         * at least one bit. That ensures we can simply discard the spare
+         * bits if the P-bit changes.
+         */
+        if (*remaining_bits == 0)
+        {
+            octet = tvb_get_guint8(message_tvb, *input_address);
+            if (print_level_1 ) {
+                proto_tree_add_text(udvm_tree, message_tvb, *input_address , 1,
+                                    "               Getting value: %u (0x%x) From Addr: %u", octet, octet, *input_address);
+            }
+            *input_address = *input_address + 1;
+
+            if (p_bit != 0)
+            {
+                octet = reverse[octet];
+            }
+            *input_bits = octet;
+            *remaining_bits = 8;
+        }
+
+        /* Add some more bits to the accumulated value. */
+        bits_to_use = bits_still_required < *remaining_bits ? bits_still_required : *remaining_bits;
+        bits_still_required -= bits_to_use;
+
+        *input_bits <<= bits_to_use;           /* Shift bits into MSByte */
+        value = (value << bits_to_use)         /* Then add to the accumulated value */
+            | ((*input_bits >> 8) & 0xFF);
+        *remaining_bits -= bits_to_use;
+        *input_bits &= 0x00FF;                 /* Leave just the remaining bits */
+    }
+
+    if (bit_order != 0)
+    {
+        /* Bit reverse the entire word. */
+        guint16 lsb = reverse[(value >> 8) & 0xFF];
+        guint16 msb = reverse[value & 0xFF];
+
+        value = ((msb << 8) | lsb) >> (16 - length);
+    }
+
+    return value;
 }
 
 static tvbuff_t*
 decompress_sigcomp_message(tvbuff_t *bytecode_tvb, tvbuff_t *message_tvb, packet_info *pinfo,
-						   proto_tree *udvm_tree, gint udvm_mem_dest,
-						   gint print_flags, gint hf_id,
-						   gint header_len,
-						   gint byte_code_state_len, gint byte_code_id_len,
-						   gint udvm_start_ip)
+                           proto_tree *udvm_tree, gint udvm_mem_dest,
+                           gint print_flags, gint hf_id,
+                           gint header_len,
+                           gint byte_code_state_len, gint byte_code_id_len,
+                           gint udvm_start_ip)
 {
-	tvbuff_t	*decomp_tvb;
-	/* UDVM memory must be initialised to zero */
-	guint8		*buff = (guint8 *)wmem_alloc0(wmem_packet_scope(), UDVM_MEMORY_SIZE);
-	char		string[2];
-	guint8		*out_buff;		/* Largest allowed size for a message is UDVM_MEMORY_SIZE = 65536 */
-	guint32		i = 0;
-	guint16		n = 0;
-	guint16		m = 0;
-	guint16		x;
-	guint		k = 0;
-	guint16		H;
-	guint16		oldH;
-	guint		offset = 0;
-	guint		result_dest;
-	guint		code_length =0;
-	guint8		current_instruction;
-	guint		current_address;
-	guint		operand_address;
-	guint		input_address;
-	guint16		output_address = 0;
-	guint		next_operand_address;
-	guint8		octet;
-	guint8		msb;
-	guint8		lsb;
-	guint16		byte_copy_right;
-	guint16		byte_copy_left;
-	guint16		input_bit_order;
-	guint16		stack_location;
-	guint16		stack_fill;
-	guint16		result;
-	guint 		msg_end = tvb_reported_length_remaining(message_tvb, 0);
-	guint16		result_code = 0;
-	guint16		old_input_bit_order = 0;
-	guint16		remaining_bits = 0;
-	guint16		input_bits = 0;
-	guint8		bit_order = 0;
-	gboolean	outside_huffman_boundaries = TRUE;
-	gboolean	print_in_loop = FALSE;
-	guint16		instruction_address;
-	guint8		no_of_state_create = 0;
-	guint16		state_length_buff[5];
-	guint16		state_address_buff[5];
-	guint16		state_instruction_buff[5];
-	guint16		state_minimum_access_length_buff[5];
-	/* guint16		state_state_retention_priority_buff[5]; */
-	guint32		used_udvm_cycles = 0;
-	guint		cycles_per_bit;
-	guint		maximum_UDVM_cycles;
-	guint8		*sha1buff;
-	unsigned char sha1_digest_buf[STATE_BUFFER_SIZE];
-	sha1_context ctx;
-
-
-	/* UDVM operand variables */
-	guint16 length;
-	guint16 at_address;
-	guint16 destination;
-	guint16 addr;
-	guint16 value;
-	guint16 p_id_start;
-	guint16 p_id_length;
-	guint16 state_begin;
-	guint16 state_length;
-	guint16 state_address;
-	guint16 state_instruction;
-	guint16 operand_1;
-	guint16 operand_2;
-	guint16 value_1;
-	guint16 value_2;
-	guint16 at_address_1;
-	guint16 at_address_2;
-	guint16 at_address_3;
-	guint16 j;
-	guint16 bits_n;
-	guint16 lower_bound_n;
-	guint16 upper_bound_n;
-	guint16 uncompressed_n;
-	guint16 position;
-	guint16 ref_destination; /* could I have used $destination ? */
-	guint16 multy_offset;
-	guint16 output_start;
-	guint16 output_length;
-	guint16 minimum_access_length;
-	guint16 state_retention_priority;
-	guint16 requested_feedback_location;
-	guint16 returned_parameters_location;
-	guint16 start_value;
-
-
-	/* Set print parameters */
-	print_level_1 = FALSE;
-	print_level_2 = FALSE;
-	print_level_3 = FALSE;
-	show_instr_detail_level = 0;
-
-
-
-	switch( print_flags ) {
-		case 0:
-			break;
-
-		case 1:
-			print_level_1 = TRUE;
-			show_instr_detail_level = 1;
-			break;
-		case 2:
-			print_level_1 = TRUE;
-			print_level_2 = TRUE;
-			show_instr_detail_level = 1;
-			break;
-		case 3:
-			print_level_1 = TRUE;
-			print_level_2 = TRUE;
-			print_level_3 = TRUE;
-			show_instr_detail_level = 2;
-			break;
-		default:
-			print_level_1 = TRUE;
-			show_instr_detail_level = 1;
-			break;
-	}
-
-	/* Set initial UDVM data
-	 *  The first 32 bytes of UDVM memory are then initialized to special
-	 *  values as illustrated in Figure 5.
-	 *
-	 *                      0             7 8            15
-	 *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-	 *                     |       UDVM_memory_size        |  0 - 1
-	 *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-	 *                     |        cycles_per_bit         |  2 - 3
-	 *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-	 *                     |        SigComp_version        |  4 - 5
-	 *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-	 *                     |    partial_state_ID_length    |  6 - 7
-	 *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-	 *                     |         state_length          |  8 - 9
-	 *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-	 *                     |                               |
-	 *                     :           reserved            :  10 - 31
-	 *                     |                               |
-	 *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-	 *
-	 *            Figure 5: Initializing Useful Values in UDVM memory
-	 */
-	/* UDVM_memory_size  */
-	buff[0] = (UDVM_MEMORY_SIZE >> 8) & 0x00FF;
-	buff[1] = UDVM_MEMORY_SIZE & 0x00FF;
-	/* cycles_per_bit */
-	buff[2] = 0;
-	buff[3] = 16;
-	/* SigComp_version */
-	buff[4] = 0;
-	buff[5] = 1;
-	/* partial_state_ID_length */
-	buff[6] = (byte_code_id_len >> 8) & 0x00FF;
-	buff[7] = byte_code_id_len & 0x00FF;
-	/* state_length  */
-	buff[8] = (byte_code_state_len >> 8) & 0x00FF;
-	buff[9] = byte_code_state_len & 0x00FF;
-
-	code_length = tvb_reported_length_remaining(bytecode_tvb, 0);
-
-	cycles_per_bit = buff[2] << 8;
-	cycles_per_bit = cycles_per_bit | buff[3];
-	/*
-	 * maximum_UDVM_cycles = (8 * n + 1000) * cycles_per_bit
-	 */
-	maximum_UDVM_cycles = (( 8 * (header_len + msg_end) ) + 1000) * cycles_per_bit;
-
-	proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,"maximum_UDVM_cycles(%u) = (( 8 * msg_end(%u) ) + 1000) * cycles_per_bit(%u)",maximum_UDVM_cycles,msg_end,cycles_per_bit);
-	proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,"Message Length: %u,Byte code length: %u, Maximum UDVM cycles: %u",msg_end,code_length,maximum_UDVM_cycles);
-
-	/* Load bytecode into UDVM starting at "udvm_mem_dest" */
-	i = udvm_mem_dest;
-	if ( print_level_3 )
-		proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,"Load bytecode into UDVM starting at %u",i);
-	while ( code_length > offset && i < UDVM_MEMORY_SIZE ) {
-		buff[i] = tvb_get_guint8(bytecode_tvb, offset);
-		if ( print_level_3 )
-			proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,
-						"              Addr: %u Instruction code(0x%0x) ", i, buff[i]);
-
-		i++;
-		offset++;
-
-	}
-	/* Start executing code */
-	current_address = udvm_start_ip;
-	input_address = 0;
-
-	proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,"UDVM EXECUTION STARTED at Address: %u Message size %u",
-		current_address, msg_end);
-
-	/* Largest allowed size for a message is UDVM_MEMORY_SIZE = 65536  */
-	out_buff = (guint8 *)g_malloc(UDVM_MEMORY_SIZE);
+    tvbuff_t      *decomp_tvb;
+    /* UDVM memory must be initialised to zero */
+    guint8        *buff                       = (guint8 *)wmem_alloc0(wmem_packet_scope(), UDVM_MEMORY_SIZE);
+    char           string[2];
+    guint8        *out_buff;    /* Largest allowed size for a message is UDVM_MEMORY_SIZE = 65536 */
+    guint32        i                          = 0;
+    guint16        n                          = 0;
+    guint16        m                          = 0;
+    guint16        x;
+    guint          k                          = 0;
+    guint16        H;
+    guint16        oldH;
+    guint          offset                     = 0;
+    guint          result_dest;
+    guint          code_length                = 0;
+    guint8         current_instruction;
+    guint          current_address;
+    guint          operand_address;
+    guint          input_address;
+    guint16        output_address             = 0;
+    guint          next_operand_address;
+    guint8         octet;
+    guint8         msb;
+    guint8         lsb;
+    guint16        byte_copy_right;
+    guint16        byte_copy_left;
+    guint16        input_bit_order;
+    guint16        stack_location;
+    guint16        stack_fill;
+    guint16        result;
+    guint          msg_end                    = tvb_reported_length_remaining(message_tvb, 0);
+    guint16        result_code                = 0;
+    guint16        old_input_bit_order        = 0;
+    guint16        remaining_bits             = 0;
+    guint16        input_bits                 = 0;
+    guint8         bit_order                  = 0;
+    gboolean       outside_huffman_boundaries = TRUE;
+    gboolean       print_in_loop              = FALSE;
+    guint16        instruction_address;
+    guint8         no_of_state_create         = 0;
+    guint16        state_length_buff[5];
+    guint16        state_address_buff[5];
+    guint16        state_instruction_buff[5];
+    guint16        state_minimum_access_length_buff[5];
+    /* guint16        state_state_retention_priority_buff[5]; */
+    guint32        used_udvm_cycles           = 0;
+    guint          cycles_per_bit;
+    guint          maximum_UDVM_cycles;
+    guint8        *sha1buff;
+    unsigned char  sha1_digest_buf[STATE_BUFFER_SIZE];
+    sha1_context   ctx;
+
+
+    /* UDVM operand variables */
+    guint16 length;
+    guint16 at_address;
+    guint16 destination;
+    guint16 addr;
+    guint16 value;
+    guint16 p_id_start;
+    guint16 p_id_length;
+    guint16 state_begin;
+    guint16 state_length;
+    guint16 state_address;
+    guint16 state_instruction;
+    guint16 operand_1;
+    guint16 operand_2;
+    guint16 value_1;
+    guint16 value_2;
+    guint16 at_address_1;
+    guint16 at_address_2;
+    guint16 at_address_3;
+    guint16 j;
+    guint16 bits_n;
+    guint16 lower_bound_n;
+    guint16 upper_bound_n;
+    guint16 uncompressed_n;
+    guint16 position;
+    guint16 ref_destination; /* could I have used $destination ? */
+    guint16 multy_offset;
+    guint16 output_start;
+    guint16 output_length;
+    guint16 minimum_access_length;
+    guint16 state_retention_priority;
+    guint16 requested_feedback_location;
+    guint16 returned_parameters_location;
+    guint16 start_value;
+
+
+    /* Set print parameters */
+    print_level_1 = FALSE;
+    print_level_2 = FALSE;
+    print_level_3 = FALSE;
+    show_instr_detail_level = 0;
+
+
+
+    switch ( print_flags ) {
+    case 0:
+        break;
+
+    case 1:
+        print_level_1 = TRUE;
+        show_instr_detail_level = 1;
+        break;
+    case 2:
+        print_level_1 = TRUE;
+        print_level_2 = TRUE;
+        show_instr_detail_level = 1;
+        break;
+    case 3:
+        print_level_1 = TRUE;
+        print_level_2 = TRUE;
+        print_level_3 = TRUE;
+        show_instr_detail_level = 2;
+        break;
+    default:
+        print_level_1 = TRUE;
+        show_instr_detail_level = 1;
+        break;
+    }
+
+    /* Set initial UDVM data
+     *  The first 32 bytes of UDVM memory are then initialized to special
+     *  values as illustrated in Figure 5.
+     *
+     *                      0             7 8            15
+     *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+     *                     |       UDVM_memory_size        |  0 - 1
+     *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+     *                     |        cycles_per_bit         |  2 - 3
+     *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+     *                     |        SigComp_version        |  4 - 5
+     *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+     *                     |    partial_state_ID_length    |  6 - 7
+     *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+     *                     |         state_length          |  8 - 9
+     *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+     *                     |                               |
+     *                     :           reserved            :  10 - 31
+     *                     |                               |
+     *                     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+     *
+     *            Figure 5: Initializing Useful Values in UDVM memory
+     */
+    /* UDVM_memory_size  */
+    buff[0] = (UDVM_MEMORY_SIZE >> 8) & 0x00FF;
+    buff[1] = UDVM_MEMORY_SIZE & 0x00FF;
+    /* cycles_per_bit */
+    buff[2] = 0;
+    buff[3] = 16;
+    /* SigComp_version */
+    buff[4] = 0;
+    buff[5] = 1;
+    /* partial_state_ID_length */
+    buff[6] = (byte_code_id_len >> 8) & 0x00FF;
+    buff[7] = byte_code_id_len & 0x00FF;
+    /* state_length  */
+    buff[8] = (byte_code_state_len >> 8) & 0x00FF;
+    buff[9] = byte_code_state_len & 0x00FF;
+
+    code_length = tvb_reported_length_remaining(bytecode_tvb, 0);
+
+    cycles_per_bit = buff[2] << 8;
+    cycles_per_bit = cycles_per_bit | buff[3];
+    /*
+     * maximum_UDVM_cycles = (8 * n + 1000) * cycles_per_bit
+     */
+    maximum_UDVM_cycles = (( 8 * (header_len + msg_end) ) + 1000) * cycles_per_bit;
+
+    proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,"maximum_UDVM_cycles(%u) = (( 8 * msg_end(%u) ) + 1000) * cycles_per_bit(%u)",maximum_UDVM_cycles,msg_end,cycles_per_bit);
+    proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,"Message Length: %u,Byte code length: %u, Maximum UDVM cycles: %u",msg_end,code_length,maximum_UDVM_cycles);
+
+    /* Load bytecode into UDVM starting at "udvm_mem_dest" */
+    i = udvm_mem_dest;
+    if ( print_level_3 )
+        proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,"Load bytecode into UDVM starting at %u",i);
+    while ( code_length > offset && i < UDVM_MEMORY_SIZE ) {
+        buff[i] = tvb_get_guint8(bytecode_tvb, offset);
+        if ( print_level_3 )
+            proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,
+                                "              Addr: %u Instruction code(0x%0x) ", i, buff[i]);
+
+        i++;
+        offset++;
+
+    }
+    /* Start executing code */
+    current_address = udvm_start_ip;
+    input_address = 0;
+
+    proto_tree_add_text(udvm_tree, bytecode_tvb, offset, 1,"UDVM EXECUTION STARTED at Address: %u Message size %u",
+                        current_address, msg_end);
+
+    /* Largest allowed size for a message is UDVM_MEMORY_SIZE = 65536  */
+    out_buff = (guint8 *)g_malloc(UDVM_MEMORY_SIZE);
 
 execute_next_instruction:
 
-	if ( used_udvm_cycles > maximum_UDVM_cycles ){
-		result_code = 15;
-		goto decompression_failure;
-	}
-	used_udvm_cycles++;
-	current_instruction = buff[current_address & 0xffff];
-
-	switch ( current_instruction ) {
-	case SIGCOMP_INSTR_DECOMPRESSION_FAILURE:
-		if ( result_code == 0 )
-			result_code = 9;
-		proto_tree_add_text(udvm_tree, NULL, 0, 0,
-			"Addr: %u ## DECOMPRESSION-FAILURE(0)",
-			current_address);
-		proto_tree_add_text(udvm_tree, NULL, 0, 0,"Wireshark UDVM diagnostic: %s.",
-				    val_to_str(result_code, result_code_vals,"Unknown (%u)"));
-		if ( output_address > 0 ){
-			/* At least something got decompressed, show it */
-			decomp_tvb = tvb_new_child_real_data(message_tvb, out_buff,output_address,output_address);
-			/* Arrange that the allocated packet data copy be freed when the
-			 * tvbuff is freed.
-			 */
-			tvb_set_free_cb( decomp_tvb, g_free );
-			/* Add the tvbuff to the list of tvbuffs to which the tvbuff we
-			 * were handed refers, so it'll get cleaned up when that tvbuff
-			 * is cleaned up.
-			 */
-			add_new_data_source(pinfo, decomp_tvb, "Decompressed SigComp message(Incomplete)");
-			proto_tree_add_text(udvm_tree, decomp_tvb, 0, -1,"SigComp message Decompression failure");
-		return decomp_tvb;
-		}
-		g_free(out_buff);
-		return NULL;
-		break;
-
-	case SIGCOMP_INSTR_AND: /* 1 AND ($operand_1, %operand_2) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## AND(1) (operand_1, operand_2)",
-				current_address);
-		}
-		/* $operand_1*/
-		operand_address = current_address + 1;
-		next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
-				operand_address, operand_1);
-		}
-		operand_address = next_operand_address;
-		/* %operand_2*/
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
-				operand_address, operand_2);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## AND (operand_1=%u, operand_2=%u)",
-				current_address, operand_1, operand_2);
-		}
-		/* execute the instruction */
-		result = operand_1 & operand_2;
-		lsb = result & 0xff;
-		msb = result >> 8;
-		buff[result_dest] = msb;
-		buff[(result_dest+1) & 0xffff] = lsb;
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
-				result, result_dest);
-		}
-		current_address = next_operand_address;
-		goto execute_next_instruction;
-
-		break;
-
-	case SIGCOMP_INSTR_OR: /* 2 OR ($operand_1, %operand_2) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## OR(2) (operand_1, operand_2)",
-				current_address);
-		}
-		/* $operand_1*/
-		operand_address = current_address + 1;
-		next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
-				operand_address, operand_1);
-		}
-		operand_address = next_operand_address;
-		/* %operand_2*/
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
-				operand_address, operand_2);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## OR (operand_1=%u, operand_2=%u)",
-				current_address, operand_1, operand_2);
-		}
-		/* execute the instruction */
-		result = operand_1 | operand_2;
-		lsb = result & 0xff;
-		msb = result >> 8;
-		buff[result_dest] = msb;
-		buff[(result_dest+1) & 0xffff] = lsb;
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
-				result, result_dest);
-		}
-		current_address = next_operand_address;
-		goto execute_next_instruction;
-
-		break;
-
-	case SIGCOMP_INSTR_NOT: /* 3 NOT ($operand_1) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## NOT(3) ($operand_1)",
-				current_address);
-		}
-		/* $operand_1*/
-		operand_address = current_address + 1;
-		next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
-				operand_address, operand_1);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## NOT (operand_1=%u)",
-				current_address, operand_1);
-		}
-		/* execute the instruction */
-		result = operand_1 ^ 0xffff;
-		lsb = result & 0xff;
-		msb = result >> 8;
-		buff[result_dest] = msb;
-		buff[(result_dest+1) & 0xffff] = lsb;
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
-				result, result_dest);
-		}
-		current_address = next_operand_address;
-		goto execute_next_instruction;
-		break;
-
-	case SIGCOMP_INSTR_LSHIFT: /* 4 LSHIFT ($operand_1, %operand_2) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## LSHIFT(4) ($operand_1, operand_2)",
-				current_address);
-		}
-		/* $operand_1*/
-		operand_address = current_address + 1;
-		next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
-				operand_address, operand_1);
-		}
-		operand_address = next_operand_address;
-		/* %operand_2*/
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
-				operand_address, operand_2);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## LSHIFT (operand_1=%u, operand_2=%u)",
-				current_address, operand_1, operand_2);
-		}
-		/* execute the instruction */
-		result = operand_1 << operand_2;
-		lsb = result & 0xff;
-		msb = result >> 8;
-		buff[result_dest] = msb;
-		buff[(result_dest+1) & 0xffff] = lsb;
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
-				result, result_dest);
-		}
-		current_address = next_operand_address;
-		goto execute_next_instruction;
-
-		break;
-	case SIGCOMP_INSTR_RSHIFT: /* 5 RSHIFT ($operand_1, %operand_2) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## RSHIFT(5) (operand_1, operand_2)",
-				current_address);
-		}
-		/* $operand_1*/
-		operand_address = current_address + 1;
-		next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
-				operand_address, operand_1);
-		}
-		operand_address = next_operand_address;
-		/* %operand_2*/
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
-				operand_address, operand_2);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## RSHIFT (operand_1=%u, operand_2=%u)",
-				current_address, operand_1, operand_2);
-		}
-		/* execute the instruction */
-		result = operand_1 >> operand_2;
-		lsb = result & 0xff;
-		msb = result >> 8;
-		buff[result_dest] = msb;
-		buff[(result_dest+1) & 0xffff] = lsb;
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
-				result, result_dest);
-		}
-		current_address = next_operand_address;
-		goto execute_next_instruction;
-		break;
-	case SIGCOMP_INSTR_ADD: /* 6 ADD ($operand_1, %operand_2) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## ADD(6) (operand_1, operand_2)",
-				current_address);
-		}
-		/* $operand_1*/
-		operand_address = current_address + 1;
-		next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
-				operand_address, operand_1);
-		}
-		operand_address = next_operand_address;
-		/* %operand_2*/
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
-				operand_address, operand_2);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## ADD (operand_1=%u, operand_2=%u)",
-				current_address, operand_1, operand_2);
-		}
-		/* execute the instruction */
-		result = operand_1 + operand_2;
-		lsb = result & 0xff;
-		msb = result >> 8;
-		buff[result_dest] = msb;
-		buff[(result_dest+1) & 0xffff] = lsb;
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"               Loading result %u at %u",
-				result, result_dest);
-		}
-		current_address = next_operand_address;
-		goto execute_next_instruction;
-
-	case SIGCOMP_INSTR_SUBTRACT: /* 7 SUBTRACT ($operand_1, %operand_2) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## SUBTRACT(7) (operand_1, operand_2)",
-				current_address);
-		}
-		/* $operand_1*/
-		operand_address = current_address + 1;
-		next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
-				operand_address, operand_1);
-		}
-		operand_address = next_operand_address;
-		/* %operand_2*/
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
-				operand_address, operand_2);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## SUBTRACT (operand_1=%u, operand_2=%u)",
-				current_address, operand_1, operand_2);
-		}
-		/* execute the instruction */
-		result = operand_1 - operand_2;
-		lsb = result & 0xff;
-		msb = result >> 8;
-		buff[result_dest] = msb;
-		buff[(result_dest+1) & 0xffff] = lsb;
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"               Loading result %u at %u",
-				result, result_dest);
-		}
-		current_address = next_operand_address;
-		goto execute_next_instruction;
-		break;
-
-	case SIGCOMP_INSTR_MULTIPLY: /* 8 MULTIPLY ($operand_1, %operand_2) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ##MULTIPLY(8) (operand_1, operand_2)",
-				current_address);
-		}
-		/* $operand_1*/
-		operand_address = current_address + 1;
-		next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
-				operand_address, operand_1);
-		}
-		operand_address = next_operand_address;
-		/* %operand_2*/
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
-				operand_address, operand_2);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## MULTIPLY (operand_1=%u, operand_2=%u)",
-				current_address, operand_1, operand_2);
-		}
-		/*
-		 * execute the instruction
-		 * MULTIPLY (m, n)  := m * n (modulo 2^16)
-		 */
-		if ( operand_2 == 0){
-			result_code = 4;
-			goto decompression_failure;
-		}
-		result = operand_1 * operand_2;
-		lsb = result & 0xff;
-		msb = result >> 8;
-		buff[result_dest] = msb;
-		buff[(result_dest+1) & 0xffff] = lsb;
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
-				result, result_dest);
-		}
-		current_address = next_operand_address;
-		goto execute_next_instruction;
-		break;
-
-	case SIGCOMP_INSTR_DIVIDE: /* 9 DIVIDE ($operand_1, %operand_2) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## DIVIDE(9) (operand_1, operand_2)",
-				current_address);
-		}
-		/* $operand_1*/
-		operand_address = current_address + 1;
-		next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
-				operand_address, operand_1);
-		}
-		operand_address = next_operand_address;
-		/* %operand_2*/
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
-				operand_address, operand_2);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## DIVIDE (operand_1=%u, operand_2=%u)",
-				current_address, operand_1, operand_2);
-		}
-		/*
-		 * execute the instruction
-		 * DIVIDE (m, n)    := floor(m / n)
-		 * Decompression failure occurs if a DIVIDE or REMAINDER instruction
-		 * encounters an operand_2 that is zero.
-		 */
-		if ( operand_2 == 0){
-			result_code = 4;
-			goto decompression_failure;
-		}
-		result = operand_1 / operand_2;
-		lsb = result & 0xff;
-		msb = result >> 8;
-		buff[result_dest] = msb;
-		buff[(result_dest+1) & 0xffff] = lsb;
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
-				result, result_dest);
-		}
-		current_address = next_operand_address;
-		goto execute_next_instruction;
-		break;
-
-	case SIGCOMP_INSTR_REMAINDER: /* 10 REMAINDER ($operand_1, %operand_2) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## REMAINDER(10) (operand_1, operand_2)",
-				current_address);
-		}
-		/* $operand_1*/
-		operand_address = current_address + 1;
-		next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
-				operand_address, operand_1);
-		}
-		operand_address = next_operand_address;
-		/* %operand_2*/
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
-				operand_address, operand_2);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## REMAINDER (operand_1=%u, operand_2=%u)",
-				current_address, operand_1, operand_2);
-		}
-		/*
-		 * execute the instruction
-		 * REMAINDER (m, n) := m - n * floor(m / n)
-		 * Decompression failure occurs if a DIVIDE or REMAINDER instruction
-		 * encounters an operand_2 that is zero.
-		 */
-		if ( operand_2 == 0){
-			result_code = 4;
-			goto decompression_failure;
-		}
-		result = operand_1 - operand_2 * (operand_1 / operand_2);
-		lsb = result & 0xff;
-		msb = result >> 8;
-		buff[result_dest] = msb;
-		buff[(result_dest+1) & 0xffff] = lsb;
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
-				result, result_dest);
-		}
-		current_address = next_operand_address;
-		goto execute_next_instruction;
-		break;
-	case SIGCOMP_INSTR_SORT_ASCENDING: /* 11 SORT-ASCENDING (%start, %n, %k) */
-		/*
-		 * 	used_udvm_cycles =  1 + k * (ceiling(log2(k)) + n)
-		 */
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## SORT-ASCENDING(11) (start, n, k))",
-				current_address);
-		}
-		proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Execution of this instruction is NOT implemented");
-		/*
-		 * 	used_udvm_cycles =  1 + k * (ceiling(log2(k)) + n)
-		 */
-		break;
-
-	case SIGCOMP_INSTR_SORT_DESCENDING: /* 12 SORT-DESCENDING (%start, %n, %k) */
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## SORT-DESCENDING(12) (start, n, k))",
-				current_address);
-		}
-		proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Execution of this instruction is NOT implemented");
-		/*
-		 * 	used_udvm_cycles =  1 + k * (ceiling(log2(k)) + n)
-		 */
-		break;
-	case SIGCOMP_INSTR_SHA_1: /* 13 SHA-1 (%position, %length, %destination) */
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## SHA-1(13) (position, length, destination)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-		/* %position */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &position);
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      position %u",
-				operand_address, position);
-		}
-		operand_address = next_operand_address;
-
-		/* %length */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
-				operand_address, length);
-		}
-		operand_address = next_operand_address;
-
-		/* $destination */
-		next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &ref_destination, &result_dest);
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      $destination %u",
-				operand_address, ref_destination);
-		}
-		used_udvm_cycles = used_udvm_cycles + length;
-
-		n = 0;
-		k = position;
-		byte_copy_right = buff[66] << 8;
-		byte_copy_right = byte_copy_right | buff[67];
-		byte_copy_left = buff[64] << 8;
-		byte_copy_left = byte_copy_left | buff[65];
-
-		if (print_level_2 ){
-			proto_tree_add_text(udvm_tree, message_tvb, 0, -1,
-					"byte_copy_right = %u", byte_copy_right);
-		}
-
-		sha1_starts( &ctx );
-
-		while (n<length) {
-			guint16 handle_now = length;
-
-			if ( k < byte_copy_right && byte_copy_right <= k + (length-n) ){
-				handle_now = byte_copy_right - position;
-			}
-
-			if (k + handle_now >= UDVM_MEMORY_SIZE)
-				goto decompression_failure;
-			sha1_update( &ctx, &buff[k], handle_now );
-
-			k = ( k + handle_now ) & 0xffff;
-			n = ( n + handle_now ) & 0xffff;
-
-			if ( k >= byte_copy_right ) {
-				k = byte_copy_left;
-			}
-		}
-
-		sha1_finish( &ctx, sha1_digest_buf );
-
-		k = ref_destination;
-
-		for ( n=0; n< STATE_BUFFER_SIZE; n++ ) {
-
-			buff[k] = sha1_digest_buf[n];
-
-			k = ( k + 1 ) & 0xffff;
-			n++;
-
-			if ( k == byte_copy_right ){
-				k = byte_copy_left;
-			}
-		}
-
-		if (print_level_2 ){
-			proto_tree_add_text(udvm_tree, message_tvb, 0, -1,
-					"Calculated SHA-1: %s",
-					bytes_to_str(wmem_packet_scope(), sha1_digest_buf, STATE_BUFFER_SIZE));
-		}
-
-		current_address = next_operand_address;
-		goto execute_next_instruction;
-		break;
-
-	case SIGCOMP_INSTR_LOAD: /* 14 LOAD (%address, %value) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## LOAD(14) (%%address, %%value)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-		/* %address */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &addr);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Address %u",
-				operand_address, addr);
-		}
-		operand_address = next_operand_address;
-		/* %value */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value);
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## LOAD (%%address=%u, %%value=%u)",
-				current_address, addr, value);
-		}
-		lsb = value & 0xff;
-		msb = value >> 8;
-
-		buff[addr] = msb;
-		buff[(addr + 1) & 0xffff] = lsb;
-
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
-				operand_address, value);
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading bytes at %u Value %u 0x%x",
-					addr, value, value);
-		}
-		current_address = next_operand_address;
-		goto execute_next_instruction;
-		break;
-
-	case SIGCOMP_INSTR_MULTILOAD: /* 15 MULTILOAD (%address, #n, %value_0, ..., %value_n-1) */
-		/* RFC 3320:
-		 * The MULTILOAD instruction sets a contiguous block of 2-byte words in
-		 * the UDVM memory to specified values.
-		 * Hmm what if the value to load only takes one byte ? Chose to always load two bytes.
-		 */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## MULTILOAD(15) (%%address, #n, value_0, ..., value_n-1)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-		/* %address */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &addr);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Address %u",
-				operand_address, addr);
-		}
-		operand_address = next_operand_address;
-
-		/* #n */
-		next_operand_address = decode_udvm_literal_operand(buff,operand_address, &n);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      n %u",
-				operand_address, n);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## MULTILOAD (%%address=%u, #n=%u, value_0, ..., value_%d)",
-				current_address, addr, n, n-1);
-		}
-		operand_address = next_operand_address;
-		used_udvm_cycles = used_udvm_cycles + n;
-		while ( n > 0) {
-			n = n - 1;
-			/* %value */
-			next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value);
-			lsb = value & 0xff;
-			msb = value >> 8;
-
-			if (addr >= UDVM_MEMORY_SIZE - 1)
-				goto decompression_failure;
-
-			buff[addr] = msb;
-			buff[(addr + 1) & 0xffff] = lsb;
-			/* debug
-			*/
-			length = next_operand_address - operand_address;
-
-			if (print_level_1 ){
-				proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1, "Addr: %u      Value %5u      - Loading bytes at %5u Value %5u 0x%x",
-				operand_address, value, addr, value, value);
-			}
-			addr = addr + 2;
-			operand_address = next_operand_address;
-		}
-		current_address = next_operand_address;
-		goto execute_next_instruction;
-
-		break;
-
-	case SIGCOMP_INSTR_PUSH: /* 16 PUSH (%value) */
-		if (show_instr_detail_level == 2){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## PUSH(16) (value)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-		/* %value */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value);
-		if (show_instr_detail_level == 2){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
-				operand_address, value);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## PUSH (value=%u)",
-				current_address, value);
-		}
-		current_address = next_operand_address;
-
-		/* Push the value address onto the stack */
-		stack_location = (buff[70] << 8) | buff[71];
-		stack_fill = (buff[stack_location] << 8)
-			   | buff[(stack_location+1) & 0xFFFF];
-		addr = (stack_location + stack_fill * 2 + 2) & 0xFFFF;
-
-		if (addr >= UDVM_MEMORY_SIZE - 1)
-			goto decompression_failure;
-
-		buff[addr] = (value >> 8) & 0x00FF;
-		buff[(addr+1) & 0xFFFF] = value & 0x00FF;
-
-		if (stack_location >= UDVM_MEMORY_SIZE - 1)
-			goto decompression_failure;
-
-		stack_fill = (stack_fill + 1) & 0xFFFF;
-		buff[stack_location] = (stack_fill >> 8) & 0x00FF;
-		buff[(stack_location+1) & 0xFFFF] = stack_fill & 0x00FF;
-
-		goto execute_next_instruction;
-
-		break;
-
-	case SIGCOMP_INSTR_POP: /* 17 POP (%address) */
-		if (show_instr_detail_level == 2){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## POP(16) (value)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-		/* %value */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &destination);
-		if (show_instr_detail_level == 2){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
-				operand_address, destination);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## POP (address=%u)",
-				current_address, destination);
-		}
-		current_address = next_operand_address;
-
-		/* Pop value from the top of the stack */
-		stack_location = (buff[70] << 8) | buff[71];
-		stack_fill = (buff[stack_location] << 8)
-			   | buff[(stack_location+1) & 0xFFFF];
-		if (stack_fill == 0)
-		{
-		    result_code = 16;
-		    goto decompression_failure;
-		}
-
-		if (stack_location >= UDVM_MEMORY_SIZE - 1)
-			goto decompression_failure;
-
-		stack_fill = (stack_fill - 1) & 0xFFFF;
-		buff[stack_location] = (stack_fill >> 8) & 0x00FF;
-		buff[(stack_location+1) & 0xFFFF] = stack_fill & 0x00FF;
-
-		addr = (stack_location + stack_fill * 2 + 2) & 0xFFFF;
-
-		if (addr >= UDVM_MEMORY_SIZE - 1)
-			goto decompression_failure;
-
-		value = (buff[addr] << 8)
-			   | buff[(addr+1) & 0xFFFF];
-
-		/* ... and store the popped value. */
-		if (destination >= UDVM_MEMORY_SIZE - 1)
-			goto decompression_failure;
-		buff[destination] = (value >> 8) & 0x00FF;
-		buff[(destination+1) & 0xFFFF] = value & 0x00FF;
-
-		goto execute_next_instruction;
-
-		break;
-
-	case SIGCOMP_INSTR_COPY: /* 18 COPY (%position, %length, %destination) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## COPY(18) (position, length, destination)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-		/* %position */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &position);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      position %u",
-				operand_address, position);
-		}
-		operand_address = next_operand_address;
-
-		/* %length */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
-				operand_address, length);
-		}
-		operand_address = next_operand_address;
-
-		/* %destination */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &destination);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Destination %u",
-				operand_address, destination);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## COPY (position=%u, length=%u, destination=%u)",
-				current_address, position, length, destination);
-		}
-		current_address = next_operand_address;
-		/*
-		 * 8.4.  Byte copying
-		 * :
-		 * The string of bytes is copied in ascending order of memory address,
-		 * respecting the bounds set by byte_copy_left and byte_copy_right.
-		 * More precisely, if a byte is copied from/to Address m then the next
-		 * byte is copied from/to Address n where n is calculated as follows:
-		 *
-		 * Set k := m + 1 (modulo 2^16)
-		 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
-		 *
-		 */
-
-		n = 0;
-		k = destination;
-		byte_copy_right = buff[66] << 8;
-		byte_copy_right = byte_copy_right | buff[67];
-		byte_copy_left = buff[64] << 8;
-		byte_copy_left = byte_copy_left | buff[65];
-		if (print_level_2 ){
-			proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
-						"               byte_copy_right = %u", byte_copy_right);
-		}
-
-		while ( n < length ){
-			buff[k] = buff[position];
-			if (print_level_2 ){
-				proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
-					"               Copying value: %u (0x%x) to Addr: %u",
-					buff[position], buff[position], k);
-			}
-			position = ( position + 1 ) & 0xffff;
-			k = ( k + 1 ) & 0xffff;
-			n++;
-
-			/*
-			 * Check for circular buffer wrapping after the positions are
-			 * incremented. If either started at BCR then they should continue
-			 * to increment beyond BCR.
-			 */
-			if ( k == byte_copy_right ){
-				k = byte_copy_left;
-			}
-			if ( position == byte_copy_right ){
-				position = byte_copy_left;
-			}
-		}
-		used_udvm_cycles = used_udvm_cycles + length;
-		goto execute_next_instruction;
-		break;
-
-	case SIGCOMP_INSTR_COPY_LITERAL: /* 19 COPY-LITERAL (%position, %length, $destination) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## COPY-LITERAL(19) (position, length, $destination)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-		/* %position */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &position);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      position %u",
-				operand_address, position);
-		}
-		operand_address = next_operand_address;
-
-		/* %length */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
-				operand_address, length);
-		}
-		operand_address = next_operand_address;
-
-
-		/* $destination */
-		next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &ref_destination, &result_dest);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      destination %u",
-				operand_address, ref_destination);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## COPY-LITERAL (position=%u, length=%u, $destination=%u)",
-				current_address, position, length, ref_destination);
-		}
-		current_address = next_operand_address;
-
-
-		/*
-		 * 8.4.  Byte copying
-		 * :
-		 * The string of bytes is copied in ascending order of memory address,
-		 * respecting the bounds set by byte_copy_left and byte_copy_right.
-		 * More precisely, if a byte is copied from/to Address m then the next
-		 * byte is copied from/to Address n where n is calculated as follows:
-		 *
-		 * Set k := m + 1 (modulo 2^16)
-		 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
-		 *
-		 */
-
-		n = 0;
-		k = ref_destination;
-		byte_copy_right = buff[66] << 8;
-		byte_copy_right = byte_copy_right | buff[67];
-		byte_copy_left = buff[64] << 8;
-		byte_copy_left = byte_copy_left | buff[65];
-		if (print_level_2 ){
-			proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
-					"               byte_copy_right = %u", byte_copy_right);
-		}
-		while ( n < length ){
-
-			buff[k] = buff[position];
-			if (print_level_2 ){
-				proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
-					"               Copying value: %u (0x%x) to Addr: %u",
-					buff[position], buff[position], k);
-			}
-			position = ( position + 1 ) & 0xffff;
-			k = ( k + 1 ) & 0xffff;
-			n++;
-
-			/*
-			 * Check for circular buffer wrapping after the positions are
-			 * incremented. It is important that k cannot be left set
-			 * to BCR. Also, if either started at BCR then they should continue
-			 * to increment beyond BCR.
-			 */
-			if ( k == byte_copy_right ){
-				k = byte_copy_left;
-			}
-			if ( position == byte_copy_right ){
-				position = byte_copy_left;
-			}
-		}
-		buff[result_dest] = k >> 8;
-		buff[(result_dest + 1) & 0xffff] = k & 0x00ff;
-
-		used_udvm_cycles = used_udvm_cycles + length;
-		goto execute_next_instruction;
-		break;
-
-	case SIGCOMP_INSTR_COPY_OFFSET: /* 20 COPY-OFFSET (%offset, %length, $destination) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## COPY-OFFSET(20) (offset, length, $destination)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-		/* %offset */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &multy_offset);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      offset %u",
-				operand_address, multy_offset);
-		}
-		operand_address = next_operand_address;
-
-		/* %length */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
-				operand_address, length);
-		}
-		operand_address = next_operand_address;
-
-
-		/* $destination */
-		next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &ref_destination, &result_dest);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      $destination %u",
-				operand_address, ref_destination);
-		}
-
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## COPY-OFFSET (offset=%u, length=%u, $destination=%u)",
-				current_address, multy_offset, length, result_dest);
-		}
-		current_address = next_operand_address;
-
-		/* Execute the instruction:
-		 * To derive the value of the position operand, starting at the memory
-		 * address specified by destination, the UDVM counts backwards a total
-		 * of offset memory addresses.
-		 *
-		 * If the memory address specified in byte_copy_left is reached, the
-		 * next memory address is taken to be (byte_copy_right - 1) modulo 2^16.
-		 */
-		byte_copy_left = buff[64] << 8;
-		byte_copy_left = byte_copy_left | buff[65];
-		byte_copy_right = buff[66] << 8;
-		byte_copy_right = byte_copy_right | buff[67];
-
-		/*
-		 * In order to work out the position, simple arithmetic is tricky
-		 * to apply because there some nasty corner cases. A simple loop
-		 * is inefficient but the logic is simple.
-		 *
-		 * FUTURE: This could be optimised.
-		 */
-		for (position = ref_destination, i = 0; i < multy_offset; i++)
-		{
-			if ( position == byte_copy_left )
-			{
-				position = (byte_copy_right - 1) & 0xffff;
-			}
-			else
-			{
-				position = (position - 1) & 0xffff;
-			}
-		}
-
-		if (print_level_2 ){
-			proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
-					"               byte_copy_left = %u byte_copy_right = %u position= %u",
-					byte_copy_left, byte_copy_right, position);
-			}
-		/* The COPY-OFFSET instruction then behaves as a COPY-LITERAL
-		 * instruction, taking the value of the position operand to be the last
-		 * memory address reached in the above step.
-		 */
-
-		/*
-		 * 8.4.  Byte copying
-		 * :
-		 * The string of bytes is copied in ascending order of memory address,
-		 * respecting the bounds set by byte_copy_left and byte_copy_right.
-		 * More precisely, if a byte is copied from/to Address m then the next
-		 * byte is copied from/to Address n where n is calculated as follows:
-		 *
-		 * Set k := m + 1 (modulo 2^16)
-		 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
-		 *
-		 */
-
-		n = 0;
-		k = ref_destination;
-		if (print_level_2 ){
-			proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
-					"               byte_copy_left = %u byte_copy_right = %u", byte_copy_left, byte_copy_right);
-		}
-		while ( n < length ){
-			buff[k] = buff[position];
-			if (print_level_2 ){
-				proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
-					"               Copying value: %5u (0x%x) from Addr: %u to Addr: %u",
-					buff[position], buff[position],(position), k);
-			}
-			n++;
-			k = ( k + 1 ) & 0xffff;
-			position = ( position + 1 ) & 0xffff;
-
-			/*
-			 * Check for circular buffer wrapping after the positions are
-			 * incremented. It is important that k cannot be left set
-			 * to BCR. Also, if either started at BCR then they should continue
-			 * to increment beyond BCR.
-			 */
-			if ( k == byte_copy_right ){
-				k = byte_copy_left;
-			}
-			if ( position == byte_copy_right ){
-				position = byte_copy_left;
-			}
-		}
-		buff[result_dest] = k >> 8;
-		buff[result_dest + 1] = k & 0x00ff;
-		used_udvm_cycles = used_udvm_cycles + length;
-		goto execute_next_instruction;
-
-		break;
-	case SIGCOMP_INSTR_MEMSET: /* 21 MEMSET (%address, %length, %start_value, %offset) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## MEMSET(21) (address, length, start_value, offset)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-
-		/* %address */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &addr);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Address %u",
-				operand_address, addr);
-		}
-		operand_address = next_operand_address;
-
-		/*  %length, */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
-				operand_address, length);
-		}
-		operand_address = next_operand_address;
-		/* %start_value */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &start_value);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      start_value %u",
-				operand_address, start_value);
-		}
-		operand_address = next_operand_address;
-
-		/* %offset */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &multy_offset);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      offset %u",
-				operand_address, multy_offset);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## MEMSET (address=%u, length=%u, start_value=%u, offset=%u)",
-				current_address, addr, length, start_value, multy_offset);
-		}
-		current_address = next_operand_address;
-		/* exetute the instruction
-		 * The sequence of values used by the MEMSET instruction is specified by
-		 * the following formula:
-		 *
-		 * Seq[n] := (start_value + n * offset) modulo 256
-		 */
-		n = 0;
-		k = addr;
-		byte_copy_right = buff[66] << 8;
-		byte_copy_right = byte_copy_right | buff[67];
-		byte_copy_left = buff[64] << 8;
-		byte_copy_left = byte_copy_left | buff[65];
-		if (print_level_2 ){
-			proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
-					"               byte_copy_left = %u byte_copy_right = %u", byte_copy_left, byte_copy_right);
-		}
-		while ( n < length ){
-			if ( k == byte_copy_right ){
-				k = byte_copy_left;
-			}
-			buff[k] = (start_value + ( n * multy_offset)) & 0xff;
-			if (print_level_2 ){
-				proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
-					"     Storing value: %u (0x%x) at Addr: %u",
-					buff[k], buff[k], k);
-			}
-			k = ( k + 1 ) & 0xffff;
-			n++;
-		}/* end while */
-		used_udvm_cycles = used_udvm_cycles + length;
-		goto execute_next_instruction;
-		break;
-
-
-	case SIGCOMP_INSTR_JUMP: /* 22 JUMP (@address) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## JUMP(22) (@address)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-		/* @address */
-		 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
-		/*next_operand_address = */decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
-				operand_address, at_address);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## JUMP (@address=%u)",
-				current_address, at_address);
-		}
-		current_address = at_address;
-		goto execute_next_instruction;
-		break;
-
-	case SIGCOMP_INSTR_COMPARE: /* 23 */
-		/* COMPARE (%value_1, %value_2, @address_1, @address_2, @address_3)
-		 */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## COMPARE(23) (value_1, value_2, @address_1, @address_2, @address_3)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-
-		/* %value_1 */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value_1);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
-					operand_address, value_1);
-		}
-		operand_address = next_operand_address;
-
-		/* %value_2 */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value_2);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
-					operand_address, value_2);
-		}
-		operand_address = next_operand_address;
-
-		/* @address_1 */
-		 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address_1);
-		at_address_1 = ( current_address + at_address_1) & 0xffff;
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
-				operand_address, at_address_1);
-		}
-		operand_address = next_operand_address;
-
-
-		/* @address_2 */
-		 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address_2);
-		at_address_2 = ( current_address + at_address_2) & 0xffff;
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
-				operand_address, at_address_2);
-		}
-		operand_address = next_operand_address;
-
-		/* @address_3 */
-		 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
-		/*next_operand_address = */decode_udvm_multitype_operand(buff, operand_address, &at_address_3);
-		at_address_3 = ( current_address + at_address_3) & 0xffff;
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
-				operand_address, at_address_3);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## COMPARE (value_1=%u, value_2=%u, @address_1=%u, @address_2=%u, @address_3=%u)",
-				current_address, value_1, value_2, at_address_1, at_address_2, at_address_3);
-		}
-		/* execute the instruction
-		 * If value_1 < value_2 then the UDVM continues instruction execution at
-		 * the memory address specified by address 1. If value_1 = value_2 then
-		 * it jumps to the address specified by address_2. If value_1 > value_2
-		 * then it jumps to the address specified by address_3.
-		 */
-		if ( value_1 < value_2 )
-			current_address = at_address_1;
-		if ( value_1 == value_2 )
-			current_address = at_address_2;
-		if ( value_1 > value_2 )
-			current_address = at_address_3;
-		goto execute_next_instruction;
-		break;
-
-	case SIGCOMP_INSTR_CALL: /* 24 CALL (@address) (PUSH addr )*/
-		if (show_instr_detail_level == 2){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## CALL(24) (@address) (PUSH addr )",
-				current_address);
-		}
-		operand_address = current_address + 1;
-		/* @address */
-		next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
-				operand_address, at_address);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## CALL (@address=%u)",
-				current_address, at_address);
-		}
-		current_address = next_operand_address;
-
-		/* Push the current address onto the stack */
-		stack_location = (buff[70] << 8) | buff[71];
-		stack_fill = (buff[stack_location] << 8)
-			   | buff[(stack_location+1) & 0xFFFF];
-		addr = (stack_location + stack_fill * 2 + 2) & 0xFFFF;
-		if (addr >= UDVM_MEMORY_SIZE - 1)
-			goto decompression_failure;
-		buff[addr] = (current_address >> 8) & 0x00FF;
-		buff[(addr+1) & 0xFFFF] = current_address & 0x00FF;
-
-		stack_fill = (stack_fill + 1) & 0xFFFF;
-		if (stack_location >= UDVM_MEMORY_SIZE - 1)
-			goto decompression_failure;
-		buff[stack_location] = (stack_fill >> 8) & 0x00FF;
-		buff[(stack_location+1) & 0xFFFF] = stack_fill & 0x00FF;
-
-		/* ... and jump to the destination address */
-		current_address = at_address;
-
-		goto execute_next_instruction;
-
-		break;
-
-	case SIGCOMP_INSTR_RETURN: /* 25 POP and return */
-		if (print_level_1 || show_instr_detail_level == 1){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## POP(25) and return",
-				current_address);
-		}
-
-		/* Pop value from the top of the stack */
-		stack_location = (buff[70] << 8) | buff[71];
-		stack_fill = (buff[stack_location] << 8)
-			   | buff[(stack_location+1) & 0xFFFF];
-		if (stack_fill == 0)
-		{
-		    result_code = 16;
-		    goto decompression_failure;
-		}
-
-		stack_fill = (stack_fill - 1) & 0xFFFF;
-		if (stack_location >= UDVM_MEMORY_SIZE - 1)
-			goto decompression_failure;
-		buff[stack_location] = (stack_fill >> 8) & 0x00FF;
-		buff[(stack_location+1) & 0xFFFF] = stack_fill & 0x00FF;
-
-		addr = (stack_location + stack_fill * 2 + 2) & 0xFFFF;
-		at_address = (buff[addr] << 8)
-			   | buff[(addr+1) & 0xFFFF];
-
-		/* ... and set the PC to the popped value */
-		current_address = at_address;
-
-		goto execute_next_instruction;
-
-		break;
-
-	case SIGCOMP_INSTR_SWITCH: /* 26 SWITCH (#n, %j, @address_0, @address_1, ... , @address_n-1) */
-		/*
-		 * When a SWITCH instruction is encountered the UDVM reads the value of
-		 * j. It then continues instruction execution at the address specified
-		 * by address j.
-		 *
-		 * Decompression failure occurs if j specifies a value of n or more, or
-		 * if the address lies beyond the overall UDVM memory size.
-		 */
-		instruction_address = current_address;
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## SWITCH (#n, j, @address_0, @address_1, ... , @address_n-1))",
-				current_address);
-		}
-		operand_address = current_address + 1;
-		/* #n
-		 * Number of addresses in the instruction
-		 */
-		next_operand_address = decode_udvm_literal_operand(buff,operand_address, &n);
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      n %u",
-				operand_address, n);
-		}
-		operand_address = next_operand_address;
-		/* %j */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &j);
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      j %u",
-					operand_address, j);
-		}
-		operand_address = next_operand_address;
-		m = 0;
-		while ( m < n ){
-			/* @address_n-1 */
-			/* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
-			next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address_1);
-			at_address_1 = ( instruction_address + at_address_1) & 0xffff;
-			if (print_level_1 ){
-				proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
-					operand_address, at_address_1);
-			}
-			if ( j == m ){
-				current_address = at_address_1;
-			}
-			operand_address = next_operand_address;
-			m++;
-		}
-		/* Check decompression failure */
-		if ( ( j == n ) || ( j > n )){
-			result_code = 5;
-			goto decompression_failure;
-		}
-		if ( current_address > UDVM_MEMORY_SIZE ){
-			result_code = 6;
-			goto decompression_failure;
-		}
-		used_udvm_cycles = used_udvm_cycles + n;
-
-		goto execute_next_instruction;
-
-		break;
-	case SIGCOMP_INSTR_CRC: /* 27 CRC (%value, %position, %length, @address) */
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## CRC (value, position, length, @address)",
-				current_address);
-		}
-
-		operand_address = current_address + 1;
-
-		/* %value */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value);
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
-				operand_address, value);
-		}
-		operand_address = next_operand_address;
-
-		/* %position */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &position);
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      position %u",
-				operand_address, position);
-		}
-		operand_address = next_operand_address;
-
-		/* %length */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
-				operand_address, length);
-		}
-		operand_address = next_operand_address;
-
-		/* @address */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address);
-		at_address = ( current_address + at_address) & 0xffff;
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
-				operand_address, at_address);
-		}
-		 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
-		used_udvm_cycles = used_udvm_cycles + length;
-
-		n = 0;
-		k = position;
-		byte_copy_right = buff[66] << 8;
-		byte_copy_right = byte_copy_right | buff[67];
-		byte_copy_left = buff[64] << 8;
-		byte_copy_left = byte_copy_left | buff[65];
-		result = 0;
-
-		if (print_level_2 ){
-			proto_tree_add_text(udvm_tree, message_tvb, 0, -1,
-					"byte_copy_right = %u", byte_copy_right);
-		}
-
-		while (n<length) {
-
-			guint16 handle_now = length - n;
-
-			if ( k < byte_copy_right && byte_copy_right <= k + (length-n) ){
-				handle_now = byte_copy_right - k;
-			}
-
-			if (k + handle_now >= UDVM_MEMORY_SIZE)
-				goto decompression_failure;
-			result = crc16_ccitt_seed(&buff[k], handle_now, (guint16) (result ^ 0xffff));
-
-			k = ( k + handle_now ) & 0xffff;
-			n = ( n + handle_now ) & 0xffff;
-
-			if ( k >= byte_copy_right ) {
-				k = byte_copy_left;
-			}
-		}
-
-		result = result ^ 0xffff;
-
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1, "Calculated CRC %u", result);
-		}
-		if (result != value){
-			current_address = at_address;
-		}
-		else {
-			current_address = next_operand_address;
-		}
-		goto execute_next_instruction;
-		break;
-
-
-	case SIGCOMP_INSTR_INPUT_BYTES: /* 28 INPUT-BYTES (%length, %destination, @address) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## INPUT-BYTES(28) length, destination, @address)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-		/* %length */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
-				operand_address, length);
-		}
-		operand_address = next_operand_address;
-
-		/* %destination */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &destination);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Destination %u",
-				operand_address, destination);
-		}
-		operand_address = next_operand_address;
-
-		/* @address */
-		 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address);
-		at_address = ( current_address + at_address) & 0xffff;
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
-				operand_address, at_address);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## INPUT-BYTES length=%u, destination=%u, @address=%u)",
-				current_address, length, destination, at_address);
-		}
-		/* execute the instruction TODO insert checks
-		 * RFC 3320 :
-		 *
-		 *    0             7 8            15
-		 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-		 *   |        byte_copy_left         |  64 - 65
-		 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-		 *   |        byte_copy_right        |  66 - 67
-		 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-		 *   |        input_bit_order        |  68 - 69
-		 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-		 *   |        stack_location         |  70 - 71
-		 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-		 *
-		 * Figure 7: Memory addresses of the UDVM registers
-		 * :
-		 * 8.4.  Byte copying
-		 * :
-		 * The string of bytes is copied in ascending order of memory address,
-		 * respecting the bounds set by byte_copy_left and byte_copy_right.
-		 * More precisely, if a byte is copied from/to Address m then the next
-		 * byte is copied from/to Address n where n is calculated as follows:
-		 *
-		 * Set k := m + 1 (modulo 2^16)
-		 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
-		 *
-		 */
-
-		n = 0;
-		k = destination;
-		byte_copy_right = buff[66] << 8;
-		byte_copy_right = byte_copy_right | buff[67];
-		byte_copy_left = buff[64] << 8;
-		byte_copy_left = byte_copy_left | buff[65];
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
-					"               byte_copy_right = %u", byte_copy_right);
-		}
-		/* clear out remaining bits if any */
-		remaining_bits = 0;
-		input_bits=0;
-		/* operand_address used as dummy */
-		while ( n < length ){
-			if (input_address > ( msg_end - 1)){
-				current_address = at_address;
-				result_code = 14;
-				goto execute_next_instruction;
-			}
-
-			if ( k == byte_copy_right ){
-				k = byte_copy_left;
-			}
-			octet = tvb_get_guint8(message_tvb, input_address);
-			buff[k] = octet;
-			if (print_level_1 ){
-				proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
-					"               Loading value: %u (0x%x) at Addr: %u", octet, octet, k);
-			}
-			input_address++;
-			/*
-			 * If the instruction requests data that lies beyond the end of the
-			 * SigComp message, no data is returned.  Instead the UDVM moves program
-			 * execution to the address specified by the address operand.
-			 */
-
-
-			k = ( k + 1 ) & 0xffff;
-			n++;
-		}
-		used_udvm_cycles = used_udvm_cycles + length;
-		current_address = next_operand_address;
-		goto execute_next_instruction;
-		break;
-	case SIGCOMP_INSTR_INPUT_BITS:/* 29   INPUT-BITS (%length, %destination, @address) */
-		/*
-		 * The length operand indicates the requested number of bits.
-		 * Decompression failure occurs if this operand does not lie between 0
-		 * and 16 inclusive.
-		 *
-		 * The destination operand specifies the memory address to which the
-		 * compressed data should be copied.  Note that the requested bits are
-		 * interpreted as a 2-byte integer ranging from 0 to 2^length - 1, as
-		 * explained in Section 8.2.
-		 *
-		 * If the instruction requests data that lies beyond the end of the
-		 * SigComp message, no data is returned.  Instead the UDVM moves program
-		 * execution to the address specified by the address operand.
-		 */
-
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## INPUT-BITS(29) (length, destination, @address)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-
-		/* %length */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      length %u",
-				operand_address, length);
-		}
-		operand_address = next_operand_address;
-		/* %destination */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &destination);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Destination %u",
-				operand_address, destination);
-		}
-		operand_address = next_operand_address;
-
-		/* @address */
-		 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
-		next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
-				operand_address, at_address);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## INPUT-BITS length=%u, destination=%u, @address=%u)",
-				current_address, length, destination, at_address);
-		}
-		current_address = next_operand_address;
-
-		/*
-		 * Execute actual instr.
-		 * The input_bit_order register contains the following three flags:
-		 *
-		 *            0             7 8            15
-		 *           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-		 *           |         reserved        |F|H|P|  68 - 69
-		 *           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-		 */
-		input_bit_order = buff[68] << 8;
-		input_bit_order = input_bit_order | buff[69];
-		/*
-		 * If the instruction requests data that lies beyond the end of the
-		 * SigComp message, no data is returned.  Instead the UDVM moves program
-		 * execution to the address specified by the address operand.
-		 */
-
-		if ( length > 16 ){
-			result_code = 7;
-			goto decompression_failure;
-		}
-		if ( input_bit_order > 7 ){
-			result_code = 8;
-			goto decompression_failure;
-		}
-
-		/*
-		 * Transfer F bit to bit_order to tell decomp dispatcher which bit order to use
-		 */
-		bit_order = ( input_bit_order & 0x0004 ) >> 2;
-		value = decomp_dispatch_get_bits( message_tvb, udvm_tree, bit_order,
-				buff, &old_input_bit_order, &remaining_bits,
-				&input_bits, &input_address, length, &result_code, msg_end);
-		if ( result_code == 11 ){
-			current_address = at_address;
-			goto execute_next_instruction;
-		}
-		msb = value >> 8;
-		lsb = value & 0x00ff;
-		if (destination >= UDVM_MEMORY_SIZE - 1)
-			goto decompression_failure;
-		buff[destination] = msb;
-		buff[(destination + 1) & 0xffff]=lsb;
-		if (print_level_1 ){
-			proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
-			"               Loading value: %u (0x%x) at Addr: %u, remaining_bits: %u", value, value, destination, remaining_bits);
-		}
-
-		goto execute_next_instruction;
-		break;
-	case SIGCOMP_INSTR_INPUT_HUFFMAN: /* 30 */
-		/*
-		 * INPUT-HUFFMAN (%destination, @address, #n, %bits_1, %lower_bound_1,
-		 *  %upper_bound_1, %uncompressed_1, ... , %bits_n, %lower_bound_n,
-		 *  %upper_bound_n, %uncompressed_n)
-		 */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## INPUT-HUFFMAN (destination, @address, #n, bits_1, lower_bound_1,upper_bound_1, uncompressed_1, ... , bits_n, lower_bound_n,upper_bound_n, uncompressed_n)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-
-		/* %destination */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &destination);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Destination %u",
-				operand_address, destination);
-		}
-		operand_address = next_operand_address;
-
-		/* @address */
-		 /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
-		next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
-				operand_address, at_address);
-		}
-		operand_address = next_operand_address;
-
-		/* #n */
-		next_operand_address = decode_udvm_literal_operand(buff,operand_address, &n);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      n %u",
-				operand_address, n);
-		}
-		operand_address = next_operand_address;
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## INPUT-HUFFMAN (destination=%u, @address=%u, #n=%u, bits_1, lower_1,upper_1, unc_1, ... , bits_%d, lower_%d,upper_%d, unc_%d)",
-				current_address, destination, at_address, n, n, n, n, n);
-		}
-
-		used_udvm_cycles = used_udvm_cycles + n;
-
-		/*
-		 * Note that if n = 0 then the INPUT-HUFFMAN instruction is ignored and
-		 * program execution resumes at the following instruction.
-		 * Decompression failure occurs if (bits_1 + ... + bits_n) > 16.
-		 *
-		 * In all other cases, the behavior of the INPUT-HUFFMAN instruction is
-		 * defined below:
-		 *
-		 * 1. Set j := 1 and set H := 0.
-		 *
-		 * 2. Request bits_j compressed bits.  Interpret the returned bits as an
-		 * integer k from 0 to 2^bits_j - 1, as explained in Section 8.2.
-		 *
-		 * 3. Set H := H * 2^bits_j + k.
-		 *
-		 * 4. If data is requested that lies beyond the end of the SigComp
-		 * message, terminate the INPUT-HUFFMAN instruction and move program
-		 * execution to the memory address specified by the address operand.
-		 *
-		 * 5. If (H < lower_bound_j) or (H > upper_bound_j) then set j := j + 1.
-		 * Then go back to Step 2, unless j > n in which case decompression
-		 * failure occurs.
-		 *
-		 * 6. Copy (H + uncompressed_j - lower_bound_j) modulo 2^16 to the
-		 * memory address specified by the destination operand.
-		 *
-		 */
-		/*
-		 * The input_bit_order register contains the following three flags:
-		 *
-		 *            0             7 8            15
-		 *           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-		 *           |         reserved        |F|H|P|  68 - 69
-		 *           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-		 *
-		 * Transfer H bit to bit_order to tell decomp dispatcher which bit order to use
-		 */
-		input_bit_order = buff[68] << 8;
-		input_bit_order = input_bit_order | buff[69];
-		bit_order = ( input_bit_order & 0x0002 ) >> 1;
-
-		j = 1;
-		H = 0;
-		m = n;
-		outside_huffman_boundaries = TRUE;
-		print_in_loop = print_level_3;
-		while ( m > 0 ){
-			/* %bits_n */
-			next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &bits_n);
-			if (print_in_loop ){
-				proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      bits_n %u",
-					operand_address, bits_n);
-			}
-			operand_address = next_operand_address;
-
-			/* %lower_bound_n */
-			next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &lower_bound_n);
-			if (print_in_loop ){
-				proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      lower_bound_n %u",
-					operand_address, lower_bound_n);
-			}
-			operand_address = next_operand_address;
-			/* %upper_bound_n */
-			next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &upper_bound_n);
-			if (print_in_loop ){
-				proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      upper_bound_n %u",
-					operand_address, upper_bound_n);
-			}
-			operand_address = next_operand_address;
-			/* %uncompressed_n */
-			next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &uncompressed_n);
-			if (print_in_loop ){
-				proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      uncompressed_n %u",
-					operand_address, uncompressed_n);
-			}
-			operand_address = next_operand_address;
-			/* execute instruction */
-			if ( outside_huffman_boundaries ) {
-				/*
-				 * 2. Request bits_j compressed bits.  Interpret the returned bits as an
-				 *    integer k from 0 to 2^bits_j - 1, as explained in Section 8.2.
-				 */
-				k = decomp_dispatch_get_bits( message_tvb, udvm_tree, bit_order,
-						buff, &old_input_bit_order, &remaining_bits,
-						&input_bits, &input_address, bits_n, &result_code, msg_end);
-				if ( result_code == 11 ){
-					/*
-					* 4. If data is requested that lies beyond the end of the SigComp
-					* message, terminate the INPUT-HUFFMAN instruction and move program
-					* execution to the memory address specified by the address operand.
-					*/
-					current_address = at_address;
-					goto execute_next_instruction;
-				}
-
-				/*
-				 * 3. Set H := H * 2^bits_j + k.
-				 * [In practice is a shift+OR operation.]
-				 */
-				oldH = H;
-				H = (H << bits_n) | k;
-				if (print_level_3 ){
-					proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"               Set H(%u) := H(%u) * 2^bits_j(%u) + k(%u)",
-						 H ,oldH, 1<<bits_n,k);
-				}
-
-				/*
-				 * 5. If (H < lower_bound_j) or (H > upper_bound_j) then set j := j + 1.
-				 * Then go back to Step 2, unless j > n in which case decompression
-				 * failure occurs.
-				 */
-				if ((H < lower_bound_n) || (H > upper_bound_n)){
-					outside_huffman_boundaries = TRUE;
-				}else{
-					outside_huffman_boundaries = FALSE;
-					print_in_loop = FALSE;
-					/*
-					 * 6. Copy (H + uncompressed_j - lower_bound_j) modulo 2^16 to the
-					 * memory address specified by the destination operand.
-					 */
-					if (print_level_2 ){
-						proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-							"               H(%u) = H(%u) + uncompressed_n(%u) - lower_bound_n(%u)",
-						(H + uncompressed_n - lower_bound_n ),H, uncompressed_n, lower_bound_n);
-					}
-					H = H + uncompressed_n - lower_bound_n;
-					msb = H >> 8;
-					lsb = H & 0x00ff;
-					if (destination >= UDVM_MEMORY_SIZE - 1)
-						goto decompression_failure;
-					buff[destination] = msb;
-					buff[(destination + 1) & 0xffff]=lsb;
-					if (print_level_1 ){
-						proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
-					"               Loading H: %u (0x%x) at Addr: %u,j = %u remaining_bits: %u",
-						H, H, destination,( n - m + 1 ), remaining_bits);
-					}
-
-				}
-
-
-			}
-			m = m - 1;
-		}
-		if ( outside_huffman_boundaries ) {
-			result_code = 10;
-			goto decompression_failure;
-		}
-
-		current_address = next_operand_address;
-		goto execute_next_instruction;
-		break;
-
-	case SIGCOMP_INSTR_STATE_ACCESS: /* 31 */
-		/*   STATE-ACCESS (%partial_identifier_start, %partial_identifier_length,
-		 * %state_begin, %state_length, %state_address, %state_instruction)
-		 */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## STATE-ACCESS(31) (partial_identifier_start, partial_identifier_length,state_begin, state_length, state_address, state_instruction)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-
-		/*
-		 * %partial_identifier_start
-		 */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &p_id_start);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       partial_identifier_start %u",
-				operand_address, p_id_start);
-		}
-
-		/*
-		 * %partial_identifier_length
-		 */
-		operand_address = next_operand_address;
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &p_id_length);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       partial_identifier_length %u",
-				operand_address, p_id_length);
-		}
-		/*
-		 * %state_begin
-		 */
-		operand_address = next_operand_address;
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_begin);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_begin %u",
-				operand_address, state_begin);
-		}
-		/*
-		 * %state_length
-		 */
-		operand_address = next_operand_address;
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_length);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_length %u",
-				operand_address, state_length);
-		}
-		/*
-		 * %state_address
-		 */
-		operand_address = next_operand_address;
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_address);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_address %u",
-				operand_address, state_address);
-		}
-		/*
-		 * %state_instruction
-		 */
-		operand_address = next_operand_address;
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_instruction);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_instruction %u",
-				operand_address, state_instruction);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## STATE-ACCESS(31) (partial_identifier_start=%u, partial_identifier_length=%u,state_begin=%u, state_length=%u, state_address=%u, state_instruction=%u)",
-				current_address, p_id_start, p_id_length, state_begin, state_length, state_address, state_instruction);
-		}
-		current_address = next_operand_address;
-		byte_copy_right = buff[66] << 8;
-		byte_copy_right = byte_copy_right | buff[67];
-		byte_copy_left = buff[64] << 8;
-		byte_copy_left = byte_copy_left | buff[65];
-		if (print_level_2 ){
-			proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
-					"               byte_copy_right = %u, byte_copy_left = %u", byte_copy_right,byte_copy_left);
-		}
-
-		result_code = udvm_state_access(message_tvb, udvm_tree, buff, p_id_start, p_id_length, state_begin, &state_length,
-			&state_address, &state_instruction, hf_id);
-		if ( result_code != 0 ){
-			goto decompression_failure;
-		}
-		used_udvm_cycles = used_udvm_cycles + state_length;
-		goto execute_next_instruction;
-		break;
-	case SIGCOMP_INSTR_STATE_CREATE: /* 32 */
-		/*
-		 * STATE-CREATE (%state_length, %state_address, %state_instruction,
-		 * %minimum_access_length, %state_retention_priority)
-		 */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## STATE-CREATE(32) (state_length, state_address, state_instruction,minimum_access_length, state_retention_priority)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-
-		/*
-		 * %state_length
-		 */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_length);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_length %u",
-				operand_address, state_length);
-		}
-		/*
-		 * %state_address
-		 */
-		operand_address = next_operand_address;
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_address);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_address %u",
-				operand_address, state_address);
-		}
-		/*
-		 * %state_instruction
-		 */
-		operand_address = next_operand_address;
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_instruction);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_instruction %u",
-				operand_address, state_instruction);
-		}
-		/*
-		 * %minimum_access_length
-		 */
-		operand_address = next_operand_address;
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &minimum_access_length);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       minimum_access_length %u",
-				operand_address, minimum_access_length);
-		}
-		/*
-		 * %state_retention_priority
-		 */
-		operand_address = next_operand_address;
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_retention_priority);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_retention_priority %u",
-				operand_address, state_retention_priority);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## STATE-CREATE(32) (state_length=%u, state_address=%u, state_instruction=%u,minimum_access_length=%u, state_retention_priority=%u)",
-				current_address, state_length, state_address, state_instruction,minimum_access_length, state_retention_priority);
-		}
-		current_address = next_operand_address;
-		/* Execute the instruction
-		 * TODO Implement the instruction
-		 * RFC3320:
-		 *    Note that the new state item cannot be created until a valid
-		 *    compartment identifier has been returned by the application.
-		 *    Consequently, when a STATE-CREATE instruction is encountered the UDVM
-		 *    simply buffers the five supplied operands until the END-MESSAGE
-		 *    instruction is reached.  The steps taken at this point are described
-		 *    in Section 9.4.9.
-		 *
-		 *   Decompression failure MUST occur if more than four state creation
-		 *   requests are made before the END-MESSAGE instruction is encountered.
-		 *   Decompression failure also occurs if the minimum_access_length does
-		 *   not lie between 6 and 20 inclusive, or if the
-		 *   state_retention_priority is 65535.
-		 */
-		no_of_state_create++;
-		if ( no_of_state_create > 4 ){
-			result_code = 12;
-			goto decompression_failure;
-		}
-		if (( minimum_access_length < 6 ) || ( minimum_access_length > STATE_BUFFER_SIZE )){
-			result_code = 1;
-			goto decompression_failure;
-		}
-		if ( state_retention_priority == 65535 ){
-			result_code = 13;
-			goto decompression_failure;
-		}
-		state_length_buff[no_of_state_create] = state_length;
-		state_address_buff[no_of_state_create] = state_address;
-		state_instruction_buff[no_of_state_create] = state_instruction;
-		state_minimum_access_length_buff[no_of_state_create] = minimum_access_length;
-		/* state_state_retention_priority_buff[no_of_state_create] = state_retention_priority; */
-		used_udvm_cycles = used_udvm_cycles + state_length;
-		/* Debug */
-		byte_copy_right = buff[66] << 8;
-		byte_copy_right = byte_copy_right | buff[67];
-		byte_copy_left = buff[64] << 8;
-		byte_copy_left = byte_copy_left | buff[65];
-		n = 0;
-		k = state_address;
-		while ( n < state_length ){
-			if ( k == byte_copy_right ){
-				k = byte_copy_left;
-			}
-			string[0]= buff[k];
-			string[1]= '\0';
-			if (print_level_3 ){
-				proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-					"               Addr: %5u State value: %u (0x%x) ASCII(%s)",
-					k,buff[k],buff[k],format_text(string, 1));
-			}
-			k = ( k + 1 ) & 0xffff;
-			n++;
-		}
-		/* End debug */
-
-		goto execute_next_instruction;
-		break;
-	case SIGCOMP_INSTR_STATE_FREE: /* 33 */
-		/*
-		 * STATE-FREE (%partial_identifier_start, %partial_identifier_length)
-		 */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## STATE-FREE (partial_identifier_start, partial_identifier_length)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-		/*
-		 * %partial_identifier_start
-		 */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &p_id_start);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       partial_identifier_start %u",
-				operand_address, p_id_start);
-		}
-		operand_address = next_operand_address;
-
-		/*
-		 * %partial_identifier_length
-		 */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &p_id_length);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       partial_identifier_length %u",
-				operand_address, p_id_length);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## STATE-FREE (partial_identifier_start=%u, partial_identifier_length=%u)",
-				current_address, p_id_start, p_id_length);
-		}
-		current_address = next_operand_address;
-
-		/* Execute the instruction:
-		 * TODO implement it
-		 */
-		udvm_state_free(buff,p_id_start,p_id_length);
-
-		goto execute_next_instruction;
-		break;
-	case SIGCOMP_INSTR_OUTPUT: /* 34 OUTPUT (%output_start, %output_length) */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## OUTPUT(34) (output_start, output_length)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-		/*
-		 * %output_start
-		 */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &output_start);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      output_start %u",
-				operand_address, output_start);
-		}
-		operand_address = next_operand_address;
-		/*
-		 * %output_length
-		 */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &output_length);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      output_length %u",
-				operand_address, output_length);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## OUTPUT (output_start=%u, output_length=%u)",
-				current_address, output_start, output_length);
-		}
-		current_address = next_operand_address;
-
-		/*
-		 * Execute instruction
-		 * 8.4.  Byte copying
-		 * :
-		 * The string of bytes is copied in ascending order of memory address,
-		 * respecting the bounds set by byte_copy_left and byte_copy_right.
-		 * More precisely, if a byte is copied from/to Address m then the next
-		 * byte is copied from/to Address n where n is calculated as follows:
-		 *
-		 * Set k := m + 1 (modulo 2^16)
-		 * If k = byte_copy_right then set n := byte_copy_left, else set n := k
-		 *
-		 */
-
-		n = 0;
-		k = output_start;
-		byte_copy_right = buff[66] << 8;
-		byte_copy_right = byte_copy_right | buff[67];
-		byte_copy_left = buff[64] << 8;
-		byte_copy_left = byte_copy_left | buff[65];
-		if (print_level_3 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-					"               byte_copy_right = %u", byte_copy_right);
-		}
-		while ( n < output_length ){
-
-			if ( k == byte_copy_right ){
-				k = byte_copy_left;
-			}
-			out_buff[output_address] = buff[k];
-			string[0]= buff[k];
-			string[1]= '\0';
-			if (print_level_3 ){
-				proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-					"               Output value: %u (0x%x) ASCII(%s) from Addr: %u ,output to dispatcher position %u",
-					buff[k],buff[k],format_text(string,1), k,output_address);
-			}
-			k = ( k + 1 ) & 0xffff;
-			output_address ++;
-			n++;
-		}
-		used_udvm_cycles = used_udvm_cycles + output_length;
-		goto execute_next_instruction;
-		break;
-	case SIGCOMP_INSTR_END_MESSAGE: /* 35 */
-		/*
-		 * END-MESSAGE (%requested_feedback_location,
-		 * %returned_parameters_location, %state_length, %state_address,
-		 * %state_instruction, %minimum_access_length,
-		 * %state_retention_priority)
-		 */
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## END-MESSAGE (requested_feedback_location,state_instruction, minimum_access_length,state_retention_priority)",
-				current_address);
-		}
-		operand_address = current_address + 1;
-
-		/* %requested_feedback_location */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &requested_feedback_location);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      requested_feedback_location %u",
-				operand_address, requested_feedback_location);
-		}
-		operand_address = next_operand_address;
-		/* returned_parameters_location */
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &returned_parameters_location);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      returned_parameters_location %u",
-				operand_address, returned_parameters_location);
-		}
-		/*
-		 * %state_length
-		 */
-		operand_address = next_operand_address;
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_length);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      state_length %u",
-				operand_address, state_length);
-		}
-		/*
-		 * %state_address
-		 */
-		operand_address = next_operand_address;
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_address);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      state_address %u",
-				operand_address, state_address);
-		}
-		/*
-		 * %state_instruction
-		 */
-		operand_address = next_operand_address;
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_instruction);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      state_instruction %u",
-				operand_address, state_instruction);
-		}
-
-		/*
-		 * %minimum_access_length
-		 */
-		operand_address = next_operand_address;
-		next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &minimum_access_length);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      minimum_access_length %u",
-				operand_address, minimum_access_length);
-		}
-
-		/*
-		 * %state_retention_priority
-		 */
-		operand_address = next_operand_address;
-		/*next_operand_address =*/ decode_udvm_multitype_operand(buff, operand_address, &state_retention_priority);
-		if (show_instr_detail_level == 2 ){
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      state_retention_priority %u",
-				operand_address, state_retention_priority);
-		}
-		if (show_instr_detail_level == 1)
-		{
-			proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
-				"Addr: %u ## END-MESSAGE (requested_feedback_location=%u, returned_parameters_location=%u, state_length=%u, state_address=%u, state_instruction=%u, minimum_access_length=%u, state_retention_priority=%u)",
-				current_address, requested_feedback_location, returned_parameters_location, state_length, state_address, state_instruction, minimum_access_length,state_retention_priority);
-		}
-		/* TODO: This isn't currently totaly correct as END_INSTRUCTION might not create state */
-		no_of_state_create++;
-		if ( no_of_state_create > 4 ){
-			result_code = 12;
-			goto decompression_failure;
-		}
-		state_length_buff[no_of_state_create] = state_length;
-		state_address_buff[no_of_state_create] = state_address;
-		state_instruction_buff[no_of_state_create] = state_instruction;
-		/* Not used ? */
-		state_minimum_access_length_buff[no_of_state_create] = minimum_access_length;
-		/* state_state_retention_priority_buff[no_of_state_create] = state_retention_priority; */
-
-		/* Execute the instruction
-		 */
-		proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"no_of_state_create %u",no_of_state_create);
-		if ( no_of_state_create != 0 ){
-			memset(sha1_digest_buf, 0, STATE_BUFFER_SIZE);
-			n = 1;
-			byte_copy_right = buff[66] << 8;
-			byte_copy_right = byte_copy_right | buff[67];
-			byte_copy_left = buff[64] << 8;
-			byte_copy_left = byte_copy_left | buff[65];
-			while ( n < no_of_state_create + 1 ){
-				sha1buff = (guint8 *)g_malloc(state_length_buff[n]+8);
-				sha1buff[0] = state_length_buff[n] >> 8;
-				sha1buff[1] = state_length_buff[n] & 0xff;
-				sha1buff[2] = state_address_buff[n] >> 8;
-				sha1buff[3] = state_address_buff[n] & 0xff;
-				sha1buff[4] = state_instruction_buff[n] >> 8;
-				sha1buff[5] = state_instruction_buff[n] & 0xff;
-				sha1buff[6] = state_minimum_access_length_buff[n] >> 8;
-				sha1buff[7] = state_minimum_access_length_buff[n] & 0xff;
-				if (print_level_3 ){
-					for( x=0; x < 8; x++){
-						proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"sha1buff %u 0x%x",
-							x,sha1buff[x]);
-					}
-				}
-				k = state_address_buff[n];
-				for( x=0; x < state_length_buff[n]; x++)
-					{
-					if ( k == byte_copy_right ){
-						k = byte_copy_left;
-					}
-					sha1buff[8+x] = buff[k];
-					k = ( k + 1 ) & 0xffff;
-					}
-
-				sha1_starts( &ctx );
-				sha1_update( &ctx, (guint8 *) sha1buff, state_length_buff[n] + 8);
-				sha1_finish( &ctx, sha1_digest_buf );
-				if (print_level_3 ){
-					proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"SHA1 digest %s", bytes_to_str(wmem_packet_scope(), sha1_digest_buf, STATE_BUFFER_SIZE));
-
-				}
+    if ( used_udvm_cycles > maximum_UDVM_cycles ) {
+        result_code = 15;
+        goto decompression_failure;
+    }
+    used_udvm_cycles++;
+    current_instruction = buff[current_address & 0xffff];
+
+    switch ( current_instruction ) {
+    case SIGCOMP_INSTR_DECOMPRESSION_FAILURE:
+        if ( result_code == 0 )
+            result_code = 9;
+        proto_tree_add_text(udvm_tree, NULL, 0, 0,
+                            "Addr: %u ## DECOMPRESSION-FAILURE(0)",
+                            current_address);
+        proto_tree_add_text(udvm_tree, NULL, 0, 0,"Wireshark UDVM diagnostic: %s.",
+                            val_to_str(result_code, result_code_vals,"Unknown (%u)"));
+        if ( output_address > 0 ) {
+            /* At least something got decompressed, show it */
+            decomp_tvb = tvb_new_child_real_data(message_tvb, out_buff,output_address,output_address);
+            /* Arrange that the allocated packet data copy be freed when the
+             * tvbuff is freed.
+             */
+            tvb_set_free_cb( decomp_tvb, g_free );
+            /* Add the tvbuff to the list of tvbuffs to which the tvbuff we
+             * were handed refers, so it'll get cleaned up when that tvbuff
+             * is cleaned up.
+             */
+            add_new_data_source(pinfo, decomp_tvb, "Decompressed SigComp message(Incomplete)");
+            proto_tree_add_text(udvm_tree, decomp_tvb, 0, -1,"SigComp message Decompression failure");
+            return decomp_tvb;
+        }
+        g_free(out_buff);
+        return NULL;
+        break;
+
+    case SIGCOMP_INSTR_AND: /* 1 AND ($operand_1, %operand_2) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## AND(1) (operand_1, operand_2)",
+                                current_address);
+        }
+        /* $operand_1*/
+        operand_address = current_address + 1;
+        next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
+                                operand_address, operand_1);
+        }
+        operand_address = next_operand_address;
+        /* %operand_2*/
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
+                                operand_address, operand_2);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## AND (operand_1=%u, operand_2=%u)",
+                                current_address, operand_1, operand_2);
+        }
+        /* execute the instruction */
+        result = operand_1 & operand_2;
+        lsb = result & 0xff;
+        msb = result >> 8;
+        buff[result_dest] = msb;
+        buff[(result_dest+1) & 0xffff] = lsb;
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
+                                result, result_dest);
+        }
+        current_address = next_operand_address;
+        goto execute_next_instruction;
+
+        break;
+
+    case SIGCOMP_INSTR_OR: /* 2 OR ($operand_1, %operand_2) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## OR(2) (operand_1, operand_2)",
+                                current_address);
+        }
+        /* $operand_1*/
+        operand_address = current_address + 1;
+        next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
+                                operand_address, operand_1);
+        }
+        operand_address = next_operand_address;
+        /* %operand_2*/
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
+                                operand_address, operand_2);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## OR (operand_1=%u, operand_2=%u)",
+                                current_address, operand_1, operand_2);
+        }
+        /* execute the instruction */
+        result = operand_1 | operand_2;
+        lsb = result & 0xff;
+        msb = result >> 8;
+        buff[result_dest] = msb;
+        buff[(result_dest+1) & 0xffff] = lsb;
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
+                                result, result_dest);
+        }
+        current_address = next_operand_address;
+        goto execute_next_instruction;
+
+        break;
+
+    case SIGCOMP_INSTR_NOT: /* 3 NOT ($operand_1) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## NOT(3) ($operand_1)",
+                                current_address);
+        }
+        /* $operand_1*/
+        operand_address = current_address + 1;
+        next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
+                                operand_address, operand_1);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## NOT (operand_1=%u)",
+                                current_address, operand_1);
+        }
+        /* execute the instruction */
+        result = operand_1 ^ 0xffff;
+        lsb = result & 0xff;
+        msb = result >> 8;
+        buff[result_dest] = msb;
+        buff[(result_dest+1) & 0xffff] = lsb;
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
+                                result, result_dest);
+        }
+        current_address = next_operand_address;
+        goto execute_next_instruction;
+        break;
+
+    case SIGCOMP_INSTR_LSHIFT: /* 4 LSHIFT ($operand_1, %operand_2) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## LSHIFT(4) ($operand_1, operand_2)",
+                                current_address);
+        }
+        /* $operand_1*/
+        operand_address = current_address + 1;
+        next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
+                                operand_address, operand_1);
+        }
+        operand_address = next_operand_address;
+        /* %operand_2*/
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
+                                operand_address, operand_2);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## LSHIFT (operand_1=%u, operand_2=%u)",
+                                current_address, operand_1, operand_2);
+        }
+        /* execute the instruction */
+        result = operand_1 << operand_2;
+        lsb = result & 0xff;
+        msb = result >> 8;
+        buff[result_dest] = msb;
+        buff[(result_dest+1) & 0xffff] = lsb;
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
+                                result, result_dest);
+        }
+        current_address = next_operand_address;
+        goto execute_next_instruction;
+
+        break;
+    case SIGCOMP_INSTR_RSHIFT: /* 5 RSHIFT ($operand_1, %operand_2) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## RSHIFT(5) (operand_1, operand_2)",
+                                current_address);
+        }
+        /* $operand_1*/
+        operand_address = current_address + 1;
+        next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
+                                operand_address, operand_1);
+        }
+        operand_address = next_operand_address;
+        /* %operand_2*/
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
+                                operand_address, operand_2);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## RSHIFT (operand_1=%u, operand_2=%u)",
+                                current_address, operand_1, operand_2);
+        }
+        /* execute the instruction */
+        result = operand_1 >> operand_2;
+        lsb = result & 0xff;
+        msb = result >> 8;
+        buff[result_dest] = msb;
+        buff[(result_dest+1) & 0xffff] = lsb;
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
+                                result, result_dest);
+        }
+        current_address = next_operand_address;
+        goto execute_next_instruction;
+        break;
+    case SIGCOMP_INSTR_ADD: /* 6 ADD ($operand_1, %operand_2) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## ADD(6) (operand_1, operand_2)",
+                                current_address);
+        }
+        /* $operand_1*/
+        operand_address = current_address + 1;
+        next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
+                                operand_address, operand_1);
+        }
+        operand_address = next_operand_address;
+        /* %operand_2*/
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
+                                operand_address, operand_2);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## ADD (operand_1=%u, operand_2=%u)",
+                                current_address, operand_1, operand_2);
+        }
+        /* execute the instruction */
+        result = operand_1 + operand_2;
+        lsb = result & 0xff;
+        msb = result >> 8;
+        buff[result_dest] = msb;
+        buff[(result_dest+1) & 0xffff] = lsb;
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"               Loading result %u at %u",
+                                result, result_dest);
+        }
+        current_address = next_operand_address;
+        goto execute_next_instruction;
+
+    case SIGCOMP_INSTR_SUBTRACT: /* 7 SUBTRACT ($operand_1, %operand_2) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## SUBTRACT(7) (operand_1, operand_2)",
+                                current_address);
+        }
+        /* $operand_1*/
+        operand_address = current_address + 1;
+        next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
+                                operand_address, operand_1);
+        }
+        operand_address = next_operand_address;
+        /* %operand_2*/
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
+                                operand_address, operand_2);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## SUBTRACT (operand_1=%u, operand_2=%u)",
+                                current_address, operand_1, operand_2);
+        }
+        /* execute the instruction */
+        result = operand_1 - operand_2;
+        lsb = result & 0xff;
+        msb = result >> 8;
+        buff[result_dest] = msb;
+        buff[(result_dest+1) & 0xffff] = lsb;
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"               Loading result %u at %u",
+                                result, result_dest);
+        }
+        current_address = next_operand_address;
+        goto execute_next_instruction;
+        break;
+
+    case SIGCOMP_INSTR_MULTIPLY: /* 8 MULTIPLY ($operand_1, %operand_2) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ##MULTIPLY(8) (operand_1, operand_2)",
+                                current_address);
+        }
+        /* $operand_1*/
+        operand_address = current_address + 1;
+        next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
+                                operand_address, operand_1);
+        }
+        operand_address = next_operand_address;
+        /* %operand_2*/
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
+                                operand_address, operand_2);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## MULTIPLY (operand_1=%u, operand_2=%u)",
+                                current_address, operand_1, operand_2);
+        }
+        /*
+         * execute the instruction
+         * MULTIPLY (m, n)  := m * n (modulo 2^16)
+         */
+        if ( operand_2 == 0) {
+            result_code = 4;
+            goto decompression_failure;
+        }
+        result = operand_1 * operand_2;
+        lsb = result & 0xff;
+        msb = result >> 8;
+        buff[result_dest] = msb;
+        buff[(result_dest+1) & 0xffff] = lsb;
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
+                                result, result_dest);
+        }
+        current_address = next_operand_address;
+        goto execute_next_instruction;
+        break;
+
+    case SIGCOMP_INSTR_DIVIDE: /* 9 DIVIDE ($operand_1, %operand_2) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## DIVIDE(9) (operand_1, operand_2)",
+                                current_address);
+        }
+        /* $operand_1*/
+        operand_address = current_address + 1;
+        next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
+                                operand_address, operand_1);
+        }
+        operand_address = next_operand_address;
+        /* %operand_2*/
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
+                                operand_address, operand_2);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## DIVIDE (operand_1=%u, operand_2=%u)",
+                                current_address, operand_1, operand_2);
+        }
+        /*
+         * execute the instruction
+         * DIVIDE (m, n)    := floor(m / n)
+         * Decompression failure occurs if a DIVIDE or REMAINDER instruction
+         * encounters an operand_2 that is zero.
+         */
+        if ( operand_2 == 0) {
+            result_code = 4;
+            goto decompression_failure;
+        }
+        result = operand_1 / operand_2;
+        lsb = result & 0xff;
+        msb = result >> 8;
+        buff[result_dest] = msb;
+        buff[(result_dest+1) & 0xffff] = lsb;
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
+                                result, result_dest);
+        }
+        current_address = next_operand_address;
+        goto execute_next_instruction;
+        break;
+
+    case SIGCOMP_INSTR_REMAINDER: /* 10 REMAINDER ($operand_1, %operand_2) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## REMAINDER(10) (operand_1, operand_2)",
+                                current_address);
+        }
+        /* $operand_1*/
+        operand_address = current_address + 1;
+        next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &operand_1, &result_dest);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_1 %u",
+                                operand_address, operand_1);
+        }
+        operand_address = next_operand_address;
+        /* %operand_2*/
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &operand_2);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      operand_2 %u",
+                                operand_address, operand_2);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## REMAINDER (operand_1=%u, operand_2=%u)",
+                                current_address, operand_1, operand_2);
+        }
+        /*
+         * execute the instruction
+         * REMAINDER (m, n) := m - n * floor(m / n)
+         * Decompression failure occurs if a DIVIDE or REMAINDER instruction
+         * encounters an operand_2 that is zero.
+         */
+        if ( operand_2 == 0) {
+            result_code = 4;
+            goto decompression_failure;
+        }
+        result = operand_1 - operand_2 * (operand_1 / operand_2);
+        lsb = result & 0xff;
+        msb = result >> 8;
+        buff[result_dest] = msb;
+        buff[(result_dest+1) & 0xffff] = lsb;
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading result %u at %u",
+                                result, result_dest);
+        }
+        current_address = next_operand_address;
+        goto execute_next_instruction;
+        break;
+    case SIGCOMP_INSTR_SORT_ASCENDING: /* 11 SORT-ASCENDING (%start, %n, %k) */
+        /*
+         *      used_udvm_cycles =  1 + k * (ceiling(log2(k)) + n)
+         */
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## SORT-ASCENDING(11) (start, n, k))",
+                                current_address);
+        }
+        proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Execution of this instruction is NOT implemented");
+        /*
+         *      used_udvm_cycles =  1 + k * (ceiling(log2(k)) + n)
+         */
+        break;
+
+    case SIGCOMP_INSTR_SORT_DESCENDING: /* 12 SORT-DESCENDING (%start, %n, %k) */
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## SORT-DESCENDING(12) (start, n, k))",
+                                current_address);
+        }
+        proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Execution of this instruction is NOT implemented");
+        /*
+         *      used_udvm_cycles =  1 + k * (ceiling(log2(k)) + n)
+         */
+        break;
+    case SIGCOMP_INSTR_SHA_1: /* 13 SHA-1 (%position, %length, %destination) */
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## SHA-1(13) (position, length, destination)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+        /* %position */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &position);
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      position %u",
+                                operand_address, position);
+        }
+        operand_address = next_operand_address;
+
+        /* %length */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
+                                operand_address, length);
+        }
+        operand_address = next_operand_address;
+
+        /* $destination */
+        next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &ref_destination, &result_dest);
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      $destination %u",
+                                operand_address, ref_destination);
+        }
+        used_udvm_cycles = used_udvm_cycles + length;
+
+        n = 0;
+        k = position;
+        byte_copy_right = buff[66] << 8;
+        byte_copy_right = byte_copy_right | buff[67];
+        byte_copy_left = buff[64] << 8;
+        byte_copy_left = byte_copy_left | buff[65];
+
+        if (print_level_2 ) {
+            proto_tree_add_text(udvm_tree, message_tvb, 0, -1,
+                                "byte_copy_right = %u", byte_copy_right);
+        }
+
+        sha1_starts( &ctx );
+
+        while (n<length) {
+            guint16 handle_now = length;
+
+            if ( k < byte_copy_right && byte_copy_right <= k + (length-n) ) {
+                handle_now = byte_copy_right - position;
+            }
+
+            if (k + handle_now >= UDVM_MEMORY_SIZE)
+                goto decompression_failure;
+            sha1_update( &ctx, &buff[k], handle_now );
+
+            k = ( k + handle_now ) & 0xffff;
+            n = ( n + handle_now ) & 0xffff;
+
+            if ( k >= byte_copy_right ) {
+                k = byte_copy_left;
+            }
+        }
+
+        sha1_finish( &ctx, sha1_digest_buf );
+
+        k = ref_destination;
+
+        for ( n=0; n< STATE_BUFFER_SIZE; n++ ) {
+
+            buff[k] = sha1_digest_buf[n];
+
+            k = ( k + 1 ) & 0xffff;
+            n++;
+
+            if ( k == byte_copy_right ) {
+                k = byte_copy_left;
+            }
+        }
+
+        if (print_level_2 ) {
+            proto_tree_add_text(udvm_tree, message_tvb, 0, -1,
+                                "Calculated SHA-1: %s",
+                                bytes_to_str(wmem_packet_scope(), sha1_digest_buf, STATE_BUFFER_SIZE));
+        }
+
+        current_address = next_operand_address;
+        goto execute_next_instruction;
+        break;
+
+    case SIGCOMP_INSTR_LOAD: /* 14 LOAD (%address, %value) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## LOAD(14) (%%address, %%value)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+        /* %address */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &addr);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Address %u",
+                                operand_address, addr);
+        }
+        operand_address = next_operand_address;
+        /* %value */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value);
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## LOAD (%%address=%u, %%value=%u)",
+                                current_address, addr, value);
+        }
+        lsb = value & 0xff;
+        msb = value >> 8;
+
+        buff[addr] = msb;
+        buff[(addr + 1) & 0xffff] = lsb;
+
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
+                                operand_address, value);
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"     Loading bytes at %u Value %u 0x%x",
+                                addr, value, value);
+        }
+        current_address = next_operand_address;
+        goto execute_next_instruction;
+        break;
+
+    case SIGCOMP_INSTR_MULTILOAD: /* 15 MULTILOAD (%address, #n, %value_0, ..., %value_n-1) */
+        /* RFC 3320:
+         * The MULTILOAD instruction sets a contiguous block of 2-byte words in
+         * the UDVM memory to specified values.
+         * Hmm what if the value to load only takes one byte ? Chose to always load two bytes.
+         */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## MULTILOAD(15) (%%address, #n, value_0, ..., value_n-1)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+        /* %address */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &addr);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Address %u",
+                                operand_address, addr);
+        }
+        operand_address = next_operand_address;
+
+        /* #n */
+        next_operand_address = decode_udvm_literal_operand(buff,operand_address, &n);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      n %u",
+                                operand_address, n);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## MULTILOAD (%%address=%u, #n=%u, value_0, ..., value_%d)",
+                                current_address, addr, n, n-1);
+        }
+        operand_address = next_operand_address;
+        used_udvm_cycles = used_udvm_cycles + n;
+        while ( n > 0) {
+            n = n - 1;
+            /* %value */
+            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value);
+            lsb = value & 0xff;
+            msb = value >> 8;
+
+            if (addr >= UDVM_MEMORY_SIZE - 1)
+                goto decompression_failure;
+
+            buff[addr] = msb;
+            buff[(addr + 1) & 0xffff] = lsb;
+            /* debug
+             */
+            length = next_operand_address - operand_address;
+
+            if (print_level_1 ) {
+                proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1, "Addr: %u      Value %5u      - Loading bytes at %5u Value %5u 0x%x",
+                                    operand_address, value, addr, value, value);
+            }
+            addr = addr + 2;
+            operand_address = next_operand_address;
+        }
+        current_address = next_operand_address;
+        goto execute_next_instruction;
+
+        break;
+
+    case SIGCOMP_INSTR_PUSH: /* 16 PUSH (%value) */
+        if (show_instr_detail_level == 2) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## PUSH(16) (value)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+        /* %value */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value);
+        if (show_instr_detail_level == 2) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
+                                operand_address, value);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## PUSH (value=%u)",
+                                current_address, value);
+        }
+        current_address = next_operand_address;
+
+        /* Push the value address onto the stack */
+        stack_location = (buff[70] << 8) | buff[71];
+        stack_fill = (buff[stack_location] << 8)
+            | buff[(stack_location+1) & 0xFFFF];
+        addr = (stack_location + stack_fill * 2 + 2) & 0xFFFF;
+
+        if (addr >= UDVM_MEMORY_SIZE - 1)
+            goto decompression_failure;
+
+        buff[addr] = (value >> 8) & 0x00FF;
+        buff[(addr+1) & 0xFFFF] = value & 0x00FF;
+
+        if (stack_location >= UDVM_MEMORY_SIZE - 1)
+            goto decompression_failure;
+
+        stack_fill = (stack_fill + 1) & 0xFFFF;
+        buff[stack_location] = (stack_fill >> 8) & 0x00FF;
+        buff[(stack_location+1) & 0xFFFF] = stack_fill & 0x00FF;
+
+        goto execute_next_instruction;
+
+        break;
+
+    case SIGCOMP_INSTR_POP: /* 17 POP (%address) */
+        if (show_instr_detail_level == 2) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## POP(16) (value)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+        /* %value */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &destination);
+        if (show_instr_detail_level == 2) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
+                                operand_address, destination);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## POP (address=%u)",
+                                current_address, destination);
+        }
+        current_address = next_operand_address;
+
+        /* Pop value from the top of the stack */
+        stack_location = (buff[70] << 8) | buff[71];
+        stack_fill = (buff[stack_location] << 8)
+            | buff[(stack_location+1) & 0xFFFF];
+        if (stack_fill == 0)
+        {
+            result_code = 16;
+            goto decompression_failure;
+        }
+
+        if (stack_location >= UDVM_MEMORY_SIZE - 1)
+            goto decompression_failure;
+
+        stack_fill = (stack_fill - 1) & 0xFFFF;
+        buff[stack_location] = (stack_fill >> 8) & 0x00FF;
+        buff[(stack_location+1) & 0xFFFF] = stack_fill & 0x00FF;
+
+        addr = (stack_location + stack_fill * 2 + 2) & 0xFFFF;
+
+        if (addr >= UDVM_MEMORY_SIZE - 1)
+            goto decompression_failure;
+
+        value = (buff[addr] << 8)
+            | buff[(addr+1) & 0xFFFF];
+
+        /* ... and store the popped value. */
+        if (destination >= UDVM_MEMORY_SIZE - 1)
+            goto decompression_failure;
+        buff[destination] = (value >> 8) & 0x00FF;
+        buff[(destination+1) & 0xFFFF] = value & 0x00FF;
+
+        goto execute_next_instruction;
+
+        break;
+
+    case SIGCOMP_INSTR_COPY: /* 18 COPY (%position, %length, %destination) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## COPY(18) (position, length, destination)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+        /* %position */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &position);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      position %u",
+                                operand_address, position);
+        }
+        operand_address = next_operand_address;
+
+        /* %length */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
+                                operand_address, length);
+        }
+        operand_address = next_operand_address;
+
+        /* %destination */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &destination);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Destination %u",
+                                operand_address, destination);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## COPY (position=%u, length=%u, destination=%u)",
+                                current_address, position, length, destination);
+        }
+        current_address = next_operand_address;
+        /*
+         * 8.4.  Byte copying
+         * :
+         * The string of bytes is copied in ascending order of memory address,
+         * respecting the bounds set by byte_copy_left and byte_copy_right.
+         * More precisely, if a byte is copied from/to Address m then the next
+         * byte is copied from/to Address n where n is calculated as follows:
+         *
+         * Set k := m + 1 (modulo 2^16)
+         * If k = byte_copy_right then set n := byte_copy_left, else set n := k
+         *
+         */
+
+        n = 0;
+        k = destination;
+        byte_copy_right = buff[66] << 8;
+        byte_copy_right = byte_copy_right | buff[67];
+        byte_copy_left = buff[64] << 8;
+        byte_copy_left = byte_copy_left | buff[65];
+        if (print_level_2 ) {
+            proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
+                                "               byte_copy_right = %u", byte_copy_right);
+        }
+
+        while ( n < length ) {
+            buff[k] = buff[position];
+            if (print_level_2 ) {
+                proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
+                                    "               Copying value: %u (0x%x) to Addr: %u",
+                                    buff[position], buff[position], k);
+            }
+            position = ( position + 1 ) & 0xffff;
+            k = ( k + 1 ) & 0xffff;
+            n++;
+
+            /*
+             * Check for circular buffer wrapping after the positions are
+             * incremented. If either started at BCR then they should continue
+             * to increment beyond BCR.
+             */
+            if ( k == byte_copy_right ) {
+                k = byte_copy_left;
+            }
+            if ( position == byte_copy_right ) {
+                position = byte_copy_left;
+            }
+        }
+        used_udvm_cycles = used_udvm_cycles + length;
+        goto execute_next_instruction;
+        break;
+
+    case SIGCOMP_INSTR_COPY_LITERAL: /* 19 COPY-LITERAL (%position, %length, $destination) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## COPY-LITERAL(19) (position, length, $destination)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+        /* %position */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &position);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      position %u",
+                                operand_address, position);
+        }
+        operand_address = next_operand_address;
+
+        /* %length */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
+                                operand_address, length);
+        }
+        operand_address = next_operand_address;
+
+
+        /* $destination */
+        next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &ref_destination, &result_dest);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      destination %u",
+                                operand_address, ref_destination);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## COPY-LITERAL (position=%u, length=%u, $destination=%u)",
+                                current_address, position, length, ref_destination);
+        }
+        current_address = next_operand_address;
+
+
+        /*
+         * 8.4.  Byte copying
+         * :
+         * The string of bytes is copied in ascending order of memory address,
+         * respecting the bounds set by byte_copy_left and byte_copy_right.
+         * More precisely, if a byte is copied from/to Address m then the next
+         * byte is copied from/to Address n where n is calculated as follows:
+         *
+         * Set k := m + 1 (modulo 2^16)
+         * If k = byte_copy_right then set n := byte_copy_left, else set n := k
+         *
+         */
+
+        n = 0;
+        k = ref_destination;
+        byte_copy_right = buff[66] << 8;
+        byte_copy_right = byte_copy_right | buff[67];
+        byte_copy_left = buff[64] << 8;
+        byte_copy_left = byte_copy_left | buff[65];
+        if (print_level_2 ) {
+            proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
+                                "               byte_copy_right = %u", byte_copy_right);
+        }
+        while ( n < length ) {
+
+            buff[k] = buff[position];
+            if (print_level_2 ) {
+                proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
+                                    "               Copying value: %u (0x%x) to Addr: %u",
+                                    buff[position], buff[position], k);
+            }
+            position = ( position + 1 ) & 0xffff;
+            k = ( k + 1 ) & 0xffff;
+            n++;
+
+            /*
+             * Check for circular buffer wrapping after the positions are
+             * incremented. It is important that k cannot be left set
+             * to BCR. Also, if either started at BCR then they should continue
+             * to increment beyond BCR.
+             */
+            if ( k == byte_copy_right ) {
+                k = byte_copy_left;
+            }
+            if ( position == byte_copy_right ) {
+                position = byte_copy_left;
+            }
+        }
+        buff[result_dest] = k >> 8;
+        buff[(result_dest + 1) & 0xffff] = k & 0x00ff;
+
+        used_udvm_cycles = used_udvm_cycles + length;
+        goto execute_next_instruction;
+        break;
+
+    case SIGCOMP_INSTR_COPY_OFFSET: /* 20 COPY-OFFSET (%offset, %length, $destination) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## COPY-OFFSET(20) (offset, length, $destination)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+        /* %offset */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &multy_offset);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      offset %u",
+                                operand_address, multy_offset);
+        }
+        operand_address = next_operand_address;
+
+        /* %length */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
+                                operand_address, length);
+        }
+        operand_address = next_operand_address;
+
+
+        /* $destination */
+        next_operand_address = dissect_udvm_reference_operand_memory(buff, operand_address, &ref_destination, &result_dest);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      $destination %u",
+                                operand_address, ref_destination);
+        }
+
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## COPY-OFFSET (offset=%u, length=%u, $destination=%u)",
+                                current_address, multy_offset, length, result_dest);
+        }
+        current_address = next_operand_address;
+
+        /* Execute the instruction:
+         * To derive the value of the position operand, starting at the memory
+         * address specified by destination, the UDVM counts backwards a total
+         * of offset memory addresses.
+         *
+         * If the memory address specified in byte_copy_left is reached, the
+         * next memory address is taken to be (byte_copy_right - 1) modulo 2^16.
+         */
+        byte_copy_left = buff[64] << 8;
+        byte_copy_left = byte_copy_left | buff[65];
+        byte_copy_right = buff[66] << 8;
+        byte_copy_right = byte_copy_right | buff[67];
+
+        /*
+         * In order to work out the position, simple arithmetic is tricky
+         * to apply because there some nasty corner cases. A simple loop
+         * is inefficient but the logic is simple.
+         *
+         * FUTURE: This could be optimised.
+         */
+        for (position = ref_destination, i = 0; i < multy_offset; i++)
+        {
+            if ( position == byte_copy_left )
+            {
+                position = (byte_copy_right - 1) & 0xffff;
+            }
+            else
+            {
+                position = (position - 1) & 0xffff;
+            }
+        }
+
+        if (print_level_2 ) {
+            proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
+                                "               byte_copy_left = %u byte_copy_right = %u position= %u",
+                                byte_copy_left, byte_copy_right, position);
+        }
+        /* The COPY-OFFSET instruction then behaves as a COPY-LITERAL
+         * instruction, taking the value of the position operand to be the last
+         * memory address reached in the above step.
+         */
+
+        /*
+         * 8.4.  Byte copying
+         * :
+         * The string of bytes is copied in ascending order of memory address,
+         * respecting the bounds set by byte_copy_left and byte_copy_right.
+         * More precisely, if a byte is copied from/to Address m then the next
+         * byte is copied from/to Address n where n is calculated as follows:
+         *
+         * Set k := m + 1 (modulo 2^16)
+         * If k = byte_copy_right then set n := byte_copy_left, else set n := k
+         *
+         */
+
+        n = 0;
+        k = ref_destination;
+        if (print_level_2 ) {
+            proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
+                                "               byte_copy_left = %u byte_copy_right = %u", byte_copy_left, byte_copy_right);
+        }
+        while ( n < length ) {
+            buff[k] = buff[position];
+            if (print_level_2 ) {
+                proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
+                                    "               Copying value: %5u (0x%x) from Addr: %u to Addr: %u",
+                                    buff[position], buff[position],(position), k);
+            }
+            n++;
+            k = ( k + 1 ) & 0xffff;
+            position = ( position + 1 ) & 0xffff;
+
+            /*
+             * Check for circular buffer wrapping after the positions are
+             * incremented. It is important that k cannot be left set
+             * to BCR. Also, if either started at BCR then they should continue
+             * to increment beyond BCR.
+             */
+            if ( k == byte_copy_right ) {
+                k = byte_copy_left;
+            }
+            if ( position == byte_copy_right ) {
+                position = byte_copy_left;
+            }
+        }
+        buff[result_dest] = k >> 8;
+        buff[result_dest + 1] = k & 0x00ff;
+        used_udvm_cycles = used_udvm_cycles + length;
+        goto execute_next_instruction;
+
+        break;
+    case SIGCOMP_INSTR_MEMSET: /* 21 MEMSET (%address, %length, %start_value, %offset) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## MEMSET(21) (address, length, start_value, offset)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+
+        /* %address */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &addr);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Address %u",
+                                operand_address, addr);
+        }
+        operand_address = next_operand_address;
+
+        /*  %length, */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
+                                operand_address, length);
+        }
+        operand_address = next_operand_address;
+        /* %start_value */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &start_value);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      start_value %u",
+                                operand_address, start_value);
+        }
+        operand_address = next_operand_address;
+
+        /* %offset */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &multy_offset);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      offset %u",
+                                operand_address, multy_offset);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## MEMSET (address=%u, length=%u, start_value=%u, offset=%u)",
+                                current_address, addr, length, start_value, multy_offset);
+        }
+        current_address = next_operand_address;
+        /* exetute the instruction
+         * The sequence of values used by the MEMSET instruction is specified by
+         * the following formula:
+         *
+         * Seq[n] := (start_value + n * offset) modulo 256
+         */
+        n = 0;
+        k = addr;
+        byte_copy_right = buff[66] << 8;
+        byte_copy_right = byte_copy_right | buff[67];
+        byte_copy_left = buff[64] << 8;
+        byte_copy_left = byte_copy_left | buff[65];
+        if (print_level_2 ) {
+            proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
+                                "               byte_copy_left = %u byte_copy_right = %u", byte_copy_left, byte_copy_right);
+        }
+        while ( n < length ) {
+            if ( k == byte_copy_right ) {
+                k = byte_copy_left;
+            }
+            buff[k] = (start_value + ( n * multy_offset)) & 0xff;
+            if (print_level_2 ) {
+                proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
+                                    "     Storing value: %u (0x%x) at Addr: %u",
+                                    buff[k], buff[k], k);
+            }
+            k = ( k + 1 ) & 0xffff;
+            n++;
+        }/* end while */
+        used_udvm_cycles = used_udvm_cycles + length;
+        goto execute_next_instruction;
+        break;
+
+
+    case SIGCOMP_INSTR_JUMP: /* 22 JUMP (@address) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## JUMP(22) (@address)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+        /* @address */
+        /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
+        /*next_operand_address = */decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
+                                operand_address, at_address);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## JUMP (@address=%u)",
+                                current_address, at_address);
+        }
+        current_address = at_address;
+        goto execute_next_instruction;
+        break;
+
+    case SIGCOMP_INSTR_COMPARE: /* 23 */
+        /* COMPARE (%value_1, %value_2, @address_1, @address_2, @address_3)
+         */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## COMPARE(23) (value_1, value_2, @address_1, @address_2, @address_3)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+
+        /* %value_1 */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value_1);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
+                                operand_address, value_1);
+        }
+        operand_address = next_operand_address;
+
+        /* %value_2 */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value_2);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
+                                operand_address, value_2);
+        }
+        operand_address = next_operand_address;
+
+        /* @address_1 */
+        /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address_1);
+        at_address_1 = ( current_address + at_address_1) & 0xffff;
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
+                                operand_address, at_address_1);
+        }
+        operand_address = next_operand_address;
+
+
+        /* @address_2 */
+        /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address_2);
+        at_address_2 = ( current_address + at_address_2) & 0xffff;
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
+                                operand_address, at_address_2);
+        }
+        operand_address = next_operand_address;
+
+        /* @address_3 */
+        /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
+        /*next_operand_address = */decode_udvm_multitype_operand(buff, operand_address, &at_address_3);
+        at_address_3 = ( current_address + at_address_3) & 0xffff;
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
+                                operand_address, at_address_3);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## COMPARE (value_1=%u, value_2=%u, @address_1=%u, @address_2=%u, @address_3=%u)",
+                                current_address, value_1, value_2, at_address_1, at_address_2, at_address_3);
+        }
+        /* execute the instruction
+         * If value_1 < value_2 then the UDVM continues instruction execution at
+         * the memory address specified by address 1. If value_1 = value_2 then
+         * it jumps to the address specified by address_2. If value_1 > value_2
+         * then it jumps to the address specified by address_3.
+         */
+        if ( value_1 < value_2 )
+            current_address = at_address_1;
+        if ( value_1 == value_2 )
+            current_address = at_address_2;
+        if ( value_1 > value_2 )
+            current_address = at_address_3;
+        goto execute_next_instruction;
+        break;
+
+    case SIGCOMP_INSTR_CALL: /* 24 CALL (@address) (PUSH addr )*/
+        if (show_instr_detail_level == 2) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## CALL(24) (@address) (PUSH addr )",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+        /* @address */
+        next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
+                                operand_address, at_address);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## CALL (@address=%u)",
+                                current_address, at_address);
+        }
+        current_address = next_operand_address;
+
+        /* Push the current address onto the stack */
+        stack_location = (buff[70] << 8) | buff[71];
+        stack_fill = (buff[stack_location] << 8)
+            | buff[(stack_location+1) & 0xFFFF];
+        addr = (stack_location + stack_fill * 2 + 2) & 0xFFFF;
+        if (addr >= UDVM_MEMORY_SIZE - 1)
+            goto decompression_failure;
+        buff[addr] = (current_address >> 8) & 0x00FF;
+        buff[(addr+1) & 0xFFFF] = current_address & 0x00FF;
+
+        stack_fill = (stack_fill + 1) & 0xFFFF;
+        if (stack_location >= UDVM_MEMORY_SIZE - 1)
+            goto decompression_failure;
+        buff[stack_location] = (stack_fill >> 8) & 0x00FF;
+        buff[(stack_location+1) & 0xFFFF] = stack_fill & 0x00FF;
+
+        /* ... and jump to the destination address */
+        current_address = at_address;
+
+        goto execute_next_instruction;
+
+        break;
+
+    case SIGCOMP_INSTR_RETURN: /* 25 POP and return */
+        if (print_level_1 || show_instr_detail_level == 1) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## POP(25) and return",
+                                current_address);
+        }
+
+        /* Pop value from the top of the stack */
+        stack_location = (buff[70] << 8) | buff[71];
+        stack_fill = (buff[stack_location] << 8)
+            | buff[(stack_location+1) & 0xFFFF];
+        if (stack_fill == 0)
+        {
+            result_code = 16;
+            goto decompression_failure;
+        }
+
+        stack_fill = (stack_fill - 1) & 0xFFFF;
+        if (stack_location >= UDVM_MEMORY_SIZE - 1)
+            goto decompression_failure;
+        buff[stack_location] = (stack_fill >> 8) & 0x00FF;
+        buff[(stack_location+1) & 0xFFFF] = stack_fill & 0x00FF;
+
+        addr = (stack_location + stack_fill * 2 + 2) & 0xFFFF;
+        at_address = (buff[addr] << 8)
+            | buff[(addr+1) & 0xFFFF];
+
+        /* ... and set the PC to the popped value */
+        current_address = at_address;
+
+        goto execute_next_instruction;
+
+        break;
+
+    case SIGCOMP_INSTR_SWITCH: /* 26 SWITCH (#n, %j, @address_0, @address_1, ... , @address_n-1) */
+        /*
+         * When a SWITCH instruction is encountered the UDVM reads the value of
+         * j. It then continues instruction execution at the address specified
+         * by address j.
+         *
+         * Decompression failure occurs if j specifies a value of n or more, or
+         * if the address lies beyond the overall UDVM memory size.
+         */
+        instruction_address = current_address;
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## SWITCH (#n, j, @address_0, @address_1, ... , @address_n-1))",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+        /* #n
+         * Number of addresses in the instruction
+         */
+        next_operand_address = decode_udvm_literal_operand(buff,operand_address, &n);
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      n %u",
+                                operand_address, n);
+        }
+        operand_address = next_operand_address;
+        /* %j */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &j);
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      j %u",
+                                operand_address, j);
+        }
+        operand_address = next_operand_address;
+        m = 0;
+        while ( m < n ) {
+            /* @address_n-1 */
+            /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
+            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address_1);
+            at_address_1 = ( instruction_address + at_address_1) & 0xffff;
+            if (print_level_1 ) {
+                proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
+                                    operand_address, at_address_1);
+            }
+            if ( j == m ) {
+                current_address = at_address_1;
+            }
+            operand_address = next_operand_address;
+            m++;
+        }
+        /* Check decompression failure */
+        if ( ( j == n ) || ( j > n )) {
+            result_code = 5;
+            goto decompression_failure;
+        }
+        if ( current_address > UDVM_MEMORY_SIZE ) {
+            result_code = 6;
+            goto decompression_failure;
+        }
+        used_udvm_cycles = used_udvm_cycles + n;
+
+        goto execute_next_instruction;
+
+        break;
+    case SIGCOMP_INSTR_CRC: /* 27 CRC (%value, %position, %length, @address) */
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## CRC (value, position, length, @address)",
+                                current_address);
+        }
+
+        operand_address = current_address + 1;
+
+        /* %value */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &value);
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Value %u",
+                                operand_address, value);
+        }
+        operand_address = next_operand_address;
+
+        /* %position */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &position);
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      position %u",
+                                operand_address, position);
+        }
+        operand_address = next_operand_address;
+
+        /* %length */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
+                                operand_address, length);
+        }
+        operand_address = next_operand_address;
+
+        /* @address */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address);
+        at_address = ( current_address + at_address) & 0xffff;
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
+                                operand_address, at_address);
+        }
+        /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
+        used_udvm_cycles = used_udvm_cycles + length;
+
+        n = 0;
+        k = position;
+        byte_copy_right = buff[66] << 8;
+        byte_copy_right = byte_copy_right | buff[67];
+        byte_copy_left = buff[64] << 8;
+        byte_copy_left = byte_copy_left | buff[65];
+        result = 0;
+
+        if (print_level_2 ) {
+            proto_tree_add_text(udvm_tree, message_tvb, 0, -1,
+                                "byte_copy_right = %u", byte_copy_right);
+        }
+
+        while (n<length) {
+
+            guint16 handle_now = length - n;
+
+            if ( k < byte_copy_right && byte_copy_right <= k + (length-n) ) {
+                handle_now = byte_copy_right - k;
+            }
+
+            if (k + handle_now >= UDVM_MEMORY_SIZE)
+                goto decompression_failure;
+            result = crc16_ccitt_seed(&buff[k], handle_now, (guint16) (result ^ 0xffff));
+
+            k = ( k + handle_now ) & 0xffff;
+            n = ( n + handle_now ) & 0xffff;
+
+            if ( k >= byte_copy_right ) {
+                k = byte_copy_left;
+            }
+        }
+
+        result = result ^ 0xffff;
+
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1, "Calculated CRC %u", result);
+        }
+        if (result != value) {
+            current_address = at_address;
+        }
+        else {
+            current_address = next_operand_address;
+        }
+        goto execute_next_instruction;
+        break;
+
+
+    case SIGCOMP_INSTR_INPUT_BYTES: /* 28 INPUT-BYTES (%length, %destination, @address) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## INPUT-BYTES(28) length, destination, @address)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+        /* %length */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Length %u",
+                                operand_address, length);
+        }
+        operand_address = next_operand_address;
+
+        /* %destination */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &destination);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Destination %u",
+                                operand_address, destination);
+        }
+        operand_address = next_operand_address;
+
+        /* @address */
+        /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &at_address);
+        at_address = ( current_address + at_address) & 0xffff;
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
+                                operand_address, at_address);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## INPUT-BYTES length=%u, destination=%u, @address=%u)",
+                                current_address, length, destination, at_address);
+        }
+        /* execute the instruction TODO insert checks
+         * RFC 3320 :
+         *
+         *    0             7 8            15
+         *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         *   |        byte_copy_left         |  64 - 65
+         *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         *   |        byte_copy_right        |  66 - 67
+         *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         *   |        input_bit_order        |  68 - 69
+         *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         *   |        stack_location         |  70 - 71
+         *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         *
+         * Figure 7: Memory addresses of the UDVM registers
+         * :
+         * 8.4.  Byte copying
+         * :
+         * The string of bytes is copied in ascending order of memory address,
+         * respecting the bounds set by byte_copy_left and byte_copy_right.
+         * More precisely, if a byte is copied from/to Address m then the next
+         * byte is copied from/to Address n where n is calculated as follows:
+         *
+         * Set k := m + 1 (modulo 2^16)
+         * If k = byte_copy_right then set n := byte_copy_left, else set n := k
+         *
+         */
+
+        n = 0;
+        k = destination;
+        byte_copy_right = buff[66] << 8;
+        byte_copy_right = byte_copy_right | buff[67];
+        byte_copy_left = buff[64] << 8;
+        byte_copy_left = byte_copy_left | buff[65];
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
+                                "               byte_copy_right = %u", byte_copy_right);
+        }
+        /* clear out remaining bits if any */
+        remaining_bits = 0;
+        input_bits=0;
+        /* operand_address used as dummy */
+        while ( n < length ) {
+            if (input_address > ( msg_end - 1)) {
+                current_address = at_address;
+                result_code = 14;
+                goto execute_next_instruction;
+            }
+
+            if ( k == byte_copy_right ) {
+                k = byte_copy_left;
+            }
+            octet = tvb_get_guint8(message_tvb, input_address);
+            buff[k] = octet;
+            if (print_level_1 ) {
+                proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
+                                    "               Loading value: %u (0x%x) at Addr: %u", octet, octet, k);
+            }
+            input_address++;
+            /*
+             * If the instruction requests data that lies beyond the end of the
+             * SigComp message, no data is returned.  Instead the UDVM moves program
+             * execution to the address specified by the address operand.
+             */
+
+
+            k = ( k + 1 ) & 0xffff;
+            n++;
+        }
+        used_udvm_cycles = used_udvm_cycles + length;
+        current_address = next_operand_address;
+        goto execute_next_instruction;
+        break;
+    case SIGCOMP_INSTR_INPUT_BITS:/* 29   INPUT-BITS (%length, %destination, @address) */
+        /*
+         * The length operand indicates the requested number of bits.
+         * Decompression failure occurs if this operand does not lie between 0
+         * and 16 inclusive.
+         *
+         * The destination operand specifies the memory address to which the
+         * compressed data should be copied.  Note that the requested bits are
+         * interpreted as a 2-byte integer ranging from 0 to 2^length - 1, as
+         * explained in Section 8.2.
+         *
+         * If the instruction requests data that lies beyond the end of the
+         * SigComp message, no data is returned.  Instead the UDVM moves program
+         * execution to the address specified by the address operand.
+         */
+
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## INPUT-BITS(29) (length, destination, @address)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+
+        /* %length */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &length);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      length %u",
+                                operand_address, length);
+        }
+        operand_address = next_operand_address;
+        /* %destination */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &destination);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Destination %u",
+                                operand_address, destination);
+        }
+        operand_address = next_operand_address;
+
+        /* @address */
+        /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
+        next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
+                                operand_address, at_address);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## INPUT-BITS length=%u, destination=%u, @address=%u)",
+                                current_address, length, destination, at_address);
+        }
+        current_address = next_operand_address;
+
+        /*
+         * Execute actual instr.
+         * The input_bit_order register contains the following three flags:
+         *
+         *            0             7 8            15
+         *           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         *           |         reserved        |F|H|P|  68 - 69
+         *           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         */
+        input_bit_order = buff[68] << 8;
+        input_bit_order = input_bit_order | buff[69];
+        /*
+         * If the instruction requests data that lies beyond the end of the
+         * SigComp message, no data is returned.  Instead the UDVM moves program
+         * execution to the address specified by the address operand.
+         */
+
+        if ( length > 16 ) {
+            result_code = 7;
+            goto decompression_failure;
+        }
+        if ( input_bit_order > 7 ) {
+            result_code = 8;
+            goto decompression_failure;
+        }
+
+        /*
+         * Transfer F bit to bit_order to tell decomp dispatcher which bit order to use
+         */
+        bit_order = ( input_bit_order & 0x0004 ) >> 2;
+        value = decomp_dispatch_get_bits( message_tvb, udvm_tree, bit_order,
+                                          buff, &old_input_bit_order, &remaining_bits,
+                                          &input_bits, &input_address, length, &result_code, msg_end);
+        if ( result_code == 11 ) {
+            current_address = at_address;
+            goto execute_next_instruction;
+        }
+        msb = value >> 8;
+        lsb = value & 0x00ff;
+        if (destination >= UDVM_MEMORY_SIZE - 1)
+            goto decompression_failure;
+        buff[destination] = msb;
+        buff[(destination + 1) & 0xffff]=lsb;
+        if (print_level_1 ) {
+            proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
+                                "               Loading value: %u (0x%x) at Addr: %u, remaining_bits: %u", value, value, destination, remaining_bits);
+        }
+
+        goto execute_next_instruction;
+        break;
+    case SIGCOMP_INSTR_INPUT_HUFFMAN: /* 30 */
+        /*
+         * INPUT-HUFFMAN (%destination, @address, #n, %bits_1, %lower_bound_1,
+         *  %upper_bound_1, %uncompressed_1, ... , %bits_n, %lower_bound_n,
+         *  %upper_bound_n, %uncompressed_n)
+         */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## INPUT-HUFFMAN (destination, @address, #n, bits_1, lower_bound_1,upper_bound_1, uncompressed_1, ... , bits_n, lower_bound_n,upper_bound_n, uncompressed_n)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+
+        /* %destination */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &destination);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      Destination %u",
+                                operand_address, destination);
+        }
+        operand_address = next_operand_address;
+
+        /* @address */
+        /* operand_value = (memory_address_of_instruction + D) modulo 2^16 */
+        next_operand_address = decode_udvm_address_operand(buff,operand_address, &at_address, current_address);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      @Address %u",
+                                operand_address, at_address);
+        }
+        operand_address = next_operand_address;
+
+        /* #n */
+        next_operand_address = decode_udvm_literal_operand(buff,operand_address, &n);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      n %u",
+                                operand_address, n);
+        }
+        operand_address = next_operand_address;
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## INPUT-HUFFMAN (destination=%u, @address=%u, #n=%u, bits_1, lower_1,upper_1, unc_1, ... , bits_%d, lower_%d,upper_%d, unc_%d)",
+                                current_address, destination, at_address, n, n, n, n, n);
+        }
+
+        used_udvm_cycles = used_udvm_cycles + n;
+
+        /*
+         * Note that if n = 0 then the INPUT-HUFFMAN instruction is ignored and
+         * program execution resumes at the following instruction.
+         * Decompression failure occurs if (bits_1 + ... + bits_n) > 16.
+         *
+         * In all other cases, the behavior of the INPUT-HUFFMAN instruction is
+         * defined below:
+         *
+         * 1. Set j := 1 and set H := 0.
+         *
+         * 2. Request bits_j compressed bits.  Interpret the returned bits as an
+         * integer k from 0 to 2^bits_j - 1, as explained in Section 8.2.
+         *
+         * 3. Set H := H * 2^bits_j + k.
+         *
+         * 4. If data is requested that lies beyond the end of the SigComp
+         * message, terminate the INPUT-HUFFMAN instruction and move program
+         * execution to the memory address specified by the address operand.
+         *
+         * 5. If (H < lower_bound_j) or (H > upper_bound_j) then set j := j + 1.
+         * Then go back to Step 2, unless j > n in which case decompression
+         * failure occurs.
+         *
+         * 6. Copy (H + uncompressed_j - lower_bound_j) modulo 2^16 to the
+         * memory address specified by the destination operand.
+         *
+         */
+        /*
+         * The input_bit_order register contains the following three flags:
+         *
+         *            0             7 8            15
+         *           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         *           |         reserved        |F|H|P|  68 - 69
+         *           +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+         *
+         * Transfer H bit to bit_order to tell decomp dispatcher which bit order to use
+         */
+        input_bit_order = buff[68] << 8;
+        input_bit_order = input_bit_order | buff[69];
+        bit_order = ( input_bit_order & 0x0002 ) >> 1;
+
+        j = 1;
+        H = 0;
+        m = n;
+        outside_huffman_boundaries = TRUE;
+        print_in_loop = print_level_3;
+        while ( m > 0 ) {
+            /* %bits_n */
+            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &bits_n);
+            if (print_in_loop ) {
+                proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      bits_n %u",
+                                    operand_address, bits_n);
+            }
+            operand_address = next_operand_address;
+
+            /* %lower_bound_n */
+            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &lower_bound_n);
+            if (print_in_loop ) {
+                proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      lower_bound_n %u",
+                                    operand_address, lower_bound_n);
+            }
+            operand_address = next_operand_address;
+            /* %upper_bound_n */
+            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &upper_bound_n);
+            if (print_in_loop ) {
+                proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      upper_bound_n %u",
+                                    operand_address, upper_bound_n);
+            }
+            operand_address = next_operand_address;
+            /* %uncompressed_n */
+            next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &uncompressed_n);
+            if (print_in_loop ) {
+                proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      uncompressed_n %u",
+                                    operand_address, uncompressed_n);
+            }
+            operand_address = next_operand_address;
+            /* execute instruction */
+            if ( outside_huffman_boundaries ) {
+                /*
+                 * 2. Request bits_j compressed bits.  Interpret the returned bits as an
+                 *    integer k from 0 to 2^bits_j - 1, as explained in Section 8.2.
+                 */
+                k = decomp_dispatch_get_bits( message_tvb, udvm_tree, bit_order,
+                                              buff, &old_input_bit_order, &remaining_bits,
+                                              &input_bits, &input_address, bits_n, &result_code, msg_end);
+                if ( result_code == 11 ) {
+                    /*
+                     * 4. If data is requested that lies beyond the end of the SigComp
+                     * message, terminate the INPUT-HUFFMAN instruction and move program
+                     * execution to the memory address specified by the address operand.
+                     */
+                    current_address = at_address;
+                    goto execute_next_instruction;
+                }
+
+                /*
+                 * 3. Set H := H * 2^bits_j + k.
+                 * [In practice is a shift+OR operation.]
+                 */
+                oldH = H;
+                H = (H << bits_n) | k;
+                if (print_level_3 ) {
+                    proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"               Set H(%u) := H(%u) * 2^bits_j(%u) + k(%u)",
+                                        H ,oldH, 1<<bits_n,k);
+                }
+
+                /*
+                 * 5. If (H < lower_bound_j) or (H > upper_bound_j) then set j := j + 1.
+                 * Then go back to Step 2, unless j > n in which case decompression
+                 * failure occurs.
+                 */
+                if ((H < lower_bound_n) || (H > upper_bound_n)) {
+                    outside_huffman_boundaries = TRUE;
+                } else {
+                    outside_huffman_boundaries = FALSE;
+                    print_in_loop = FALSE;
+                    /*
+                     * 6. Copy (H + uncompressed_j - lower_bound_j) modulo 2^16 to the
+                     * memory address specified by the destination operand.
+                     */
+                    if (print_level_2 ) {
+                        proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                            "               H(%u) = H(%u) + uncompressed_n(%u) - lower_bound_n(%u)",
+                                            (H + uncompressed_n - lower_bound_n ),H, uncompressed_n, lower_bound_n);
+                    }
+                    H = H + uncompressed_n - lower_bound_n;
+                    msb = H >> 8;
+                    lsb = H & 0x00ff;
+                    if (destination >= UDVM_MEMORY_SIZE - 1)
+                        goto decompression_failure;
+                    buff[destination] = msb;
+                    buff[(destination + 1) & 0xffff]=lsb;
+                    if (print_level_1 ) {
+                        proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
+                                            "               Loading H: %u (0x%x) at Addr: %u,j = %u remaining_bits: %u",
+                                            H, H, destination,( n - m + 1 ), remaining_bits);
+                    }
+
+                }
+
+
+            }
+            m = m - 1;
+        }
+        if ( outside_huffman_boundaries ) {
+            result_code = 10;
+            goto decompression_failure;
+        }
+
+        current_address = next_operand_address;
+        goto execute_next_instruction;
+        break;
+
+    case SIGCOMP_INSTR_STATE_ACCESS: /* 31 */
+        /*   STATE-ACCESS (%partial_identifier_start, %partial_identifier_length,
+         * %state_begin, %state_length, %state_address, %state_instruction)
+         */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## STATE-ACCESS(31) (partial_identifier_start, partial_identifier_length,state_begin, state_length, state_address, state_instruction)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+
+        /*
+         * %partial_identifier_start
+         */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &p_id_start);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       partial_identifier_start %u",
+                                operand_address, p_id_start);
+        }
+
+        /*
+         * %partial_identifier_length
+         */
+        operand_address = next_operand_address;
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &p_id_length);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       partial_identifier_length %u",
+                                operand_address, p_id_length);
+        }
+        /*
+         * %state_begin
+         */
+        operand_address = next_operand_address;
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_begin);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_begin %u",
+                                operand_address, state_begin);
+        }
+        /*
+         * %state_length
+         */
+        operand_address = next_operand_address;
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_length);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_length %u",
+                                operand_address, state_length);
+        }
+        /*
+         * %state_address
+         */
+        operand_address = next_operand_address;
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_address);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_address %u",
+                                operand_address, state_address);
+        }
+        /*
+         * %state_instruction
+         */
+        operand_address = next_operand_address;
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_instruction);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_instruction %u",
+                                operand_address, state_instruction);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## STATE-ACCESS(31) (partial_identifier_start=%u, partial_identifier_length=%u,state_begin=%u, state_length=%u, state_address=%u, state_instruction=%u)",
+                                current_address, p_id_start, p_id_length, state_begin, state_length, state_address, state_instruction);
+        }
+        current_address = next_operand_address;
+        byte_copy_right = buff[66] << 8;
+        byte_copy_right = byte_copy_right | buff[67];
+        byte_copy_left = buff[64] << 8;
+        byte_copy_left = byte_copy_left | buff[65];
+        if (print_level_2 ) {
+            proto_tree_add_text(udvm_tree, message_tvb, input_address, 1,
+                                "               byte_copy_right = %u, byte_copy_left = %u", byte_copy_right,byte_copy_left);
+        }
+
+        result_code = udvm_state_access(message_tvb, udvm_tree, buff, p_id_start, p_id_length, state_begin, &state_length,
+                                        &state_address, &state_instruction, hf_id);
+        if ( result_code != 0 ) {
+            goto decompression_failure;
+        }
+        used_udvm_cycles = used_udvm_cycles + state_length;
+        goto execute_next_instruction;
+        break;
+    case SIGCOMP_INSTR_STATE_CREATE: /* 32 */
+        /*
+         * STATE-CREATE (%state_length, %state_address, %state_instruction,
+         * %minimum_access_length, %state_retention_priority)
+         */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## STATE-CREATE(32) (state_length, state_address, state_instruction,minimum_access_length, state_retention_priority)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+
+        /*
+         * %state_length
+         */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_length);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_length %u",
+                                operand_address, state_length);
+        }
+        /*
+         * %state_address
+         */
+        operand_address = next_operand_address;
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_address);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_address %u",
+                                operand_address, state_address);
+        }
+        /*
+         * %state_instruction
+         */
+        operand_address = next_operand_address;
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_instruction);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_instruction %u",
+                                operand_address, state_instruction);
+        }
+        /*
+         * %minimum_access_length
+         */
+        operand_address = next_operand_address;
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &minimum_access_length);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       minimum_access_length %u",
+                                operand_address, minimum_access_length);
+        }
+        /*
+         * %state_retention_priority
+         */
+        operand_address = next_operand_address;
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_retention_priority);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       state_retention_priority %u",
+                                operand_address, state_retention_priority);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## STATE-CREATE(32) (state_length=%u, state_address=%u, state_instruction=%u,minimum_access_length=%u, state_retention_priority=%u)",
+                                current_address, state_length, state_address, state_instruction,minimum_access_length, state_retention_priority);
+        }
+        current_address = next_operand_address;
+        /* Execute the instruction
+         * TODO Implement the instruction
+         * RFC3320:
+         *    Note that the new state item cannot be created until a valid
+         *    compartment identifier has been returned by the application.
+         *    Consequently, when a STATE-CREATE instruction is encountered the UDVM
+         *    simply buffers the five supplied operands until the END-MESSAGE
+         *    instruction is reached.  The steps taken at this point are described
+         *    in Section 9.4.9.
+         *
+         *   Decompression failure MUST occur if more than four state creation
+         *   requests are made before the END-MESSAGE instruction is encountered.
+         *   Decompression failure also occurs if the minimum_access_length does
+         *   not lie between 6 and 20 inclusive, or if the
+         *   state_retention_priority is 65535.
+         */
+        no_of_state_create++;
+        if ( no_of_state_create > 4 ) {
+            result_code = 12;
+            goto decompression_failure;
+        }
+        if (( minimum_access_length < 6 ) || ( minimum_access_length > STATE_BUFFER_SIZE )) {
+            result_code = 1;
+            goto decompression_failure;
+        }
+        if ( state_retention_priority == 65535 ) {
+            result_code = 13;
+            goto decompression_failure;
+        }
+        state_length_buff[no_of_state_create] = state_length;
+        state_address_buff[no_of_state_create] = state_address;
+        state_instruction_buff[no_of_state_create] = state_instruction;
+        state_minimum_access_length_buff[no_of_state_create] = minimum_access_length;
+        /* state_state_retention_priority_buff[no_of_state_create] = state_retention_priority; */
+        used_udvm_cycles = used_udvm_cycles + state_length;
+        /* Debug */
+        byte_copy_right = buff[66] << 8;
+        byte_copy_right = byte_copy_right | buff[67];
+        byte_copy_left = buff[64] << 8;
+        byte_copy_left = byte_copy_left | buff[65];
+        n = 0;
+        k = state_address;
+        while ( n < state_length ) {
+            if ( k == byte_copy_right ) {
+                k = byte_copy_left;
+            }
+            string[0]= buff[k];
+            string[1]= '\0';
+            if (print_level_3 ) {
+                proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                    "               Addr: %5u State value: %u (0x%x) ASCII(%s)",
+                                    k,buff[k],buff[k],format_text(string, 1));
+            }
+            k = ( k + 1 ) & 0xffff;
+            n++;
+        }
+        /* End debug */
+
+        goto execute_next_instruction;
+        break;
+    case SIGCOMP_INSTR_STATE_FREE: /* 33 */
+        /*
+         * STATE-FREE (%partial_identifier_start, %partial_identifier_length)
+         */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## STATE-FREE (partial_identifier_start, partial_identifier_length)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+        /*
+         * %partial_identifier_start
+         */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &p_id_start);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       partial_identifier_start %u",
+                                operand_address, p_id_start);
+        }
+        operand_address = next_operand_address;
+
+        /*
+         * %partial_identifier_length
+         */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &p_id_length);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u       partial_identifier_length %u",
+                                operand_address, p_id_length);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## STATE-FREE (partial_identifier_start=%u, partial_identifier_length=%u)",
+                                current_address, p_id_start, p_id_length);
+        }
+        current_address = next_operand_address;
+
+        /* Execute the instruction:
+         * TODO implement it
+         */
+        udvm_state_free(buff,p_id_start,p_id_length);
+
+        goto execute_next_instruction;
+        break;
+    case SIGCOMP_INSTR_OUTPUT: /* 34 OUTPUT (%output_start, %output_length) */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## OUTPUT(34) (output_start, output_length)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+        /*
+         * %output_start
+         */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &output_start);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      output_start %u",
+                                operand_address, output_start);
+        }
+        operand_address = next_operand_address;
+        /*
+         * %output_length
+         */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &output_length);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      output_length %u",
+                                operand_address, output_length);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## OUTPUT (output_start=%u, output_length=%u)",
+                                current_address, output_start, output_length);
+        }
+        current_address = next_operand_address;
+
+        /*
+         * Execute instruction
+         * 8.4.  Byte copying
+         * :
+         * The string of bytes is copied in ascending order of memory address,
+         * respecting the bounds set by byte_copy_left and byte_copy_right.
+         * More precisely, if a byte is copied from/to Address m then the next
+         * byte is copied from/to Address n where n is calculated as follows:
+         *
+         * Set k := m + 1 (modulo 2^16)
+         * If k = byte_copy_right then set n := byte_copy_left, else set n := k
+         *
+         */
+
+        n = 0;
+        k = output_start;
+        byte_copy_right = buff[66] << 8;
+        byte_copy_right = byte_copy_right | buff[67];
+        byte_copy_left = buff[64] << 8;
+        byte_copy_left = byte_copy_left | buff[65];
+        if (print_level_3 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "               byte_copy_right = %u", byte_copy_right);
+        }
+        while ( n < output_length ) {
+
+            if ( k == byte_copy_right ) {
+                k = byte_copy_left;
+            }
+            out_buff[output_address] = buff[k];
+            string[0]= buff[k];
+            string[1]= '\0';
+            if (print_level_3 ) {
+                proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                    "               Output value: %u (0x%x) ASCII(%s) from Addr: %u ,output to dispatcher position %u",
+                                    buff[k],buff[k],format_text(string,1), k,output_address);
+            }
+            k = ( k + 1 ) & 0xffff;
+            output_address ++;
+            n++;
+        }
+        used_udvm_cycles = used_udvm_cycles + output_length;
+        goto execute_next_instruction;
+        break;
+    case SIGCOMP_INSTR_END_MESSAGE: /* 35 */
+        /*
+         * END-MESSAGE (%requested_feedback_location,
+         * %returned_parameters_location, %state_length, %state_address,
+         * %state_instruction, %minimum_access_length,
+         * %state_retention_priority)
+         */
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## END-MESSAGE (requested_feedback_location,state_instruction, minimum_access_length,state_retention_priority)",
+                                current_address);
+        }
+        operand_address = current_address + 1;
+
+        /* %requested_feedback_location */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &requested_feedback_location);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      requested_feedback_location %u",
+                                operand_address, requested_feedback_location);
+        }
+        operand_address = next_operand_address;
+        /* returned_parameters_location */
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &returned_parameters_location);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      returned_parameters_location %u",
+                                operand_address, returned_parameters_location);
+        }
+        /*
+         * %state_length
+         */
+        operand_address = next_operand_address;
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_length);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      state_length %u",
+                                operand_address, state_length);
+        }
+        /*
+         * %state_address
+         */
+        operand_address = next_operand_address;
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_address);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      state_address %u",
+                                operand_address, state_address);
+        }
+        /*
+         * %state_instruction
+         */
+        operand_address = next_operand_address;
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &state_instruction);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      state_instruction %u",
+                                operand_address, state_instruction);
+        }
+
+        /*
+         * %minimum_access_length
+         */
+        operand_address = next_operand_address;
+        next_operand_address = decode_udvm_multitype_operand(buff, operand_address, &minimum_access_length);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      minimum_access_length %u",
+                                operand_address, minimum_access_length);
+        }
+
+        /*
+         * %state_retention_priority
+         */
+        operand_address = next_operand_address;
+        /*next_operand_address =*/ decode_udvm_multitype_operand(buff, operand_address, &state_retention_priority);
+        if (show_instr_detail_level == 2 ) {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"Addr: %u      state_retention_priority %u",
+                                operand_address, state_retention_priority);
+        }
+        if (show_instr_detail_level == 1)
+        {
+            proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,
+                                "Addr: %u ## END-MESSAGE (requested_feedback_location=%u, returned_parameters_location=%u, state_length=%u, state_address=%u, state_instruction=%u, minimum_access_length=%u, state_retention_priority=%u)",
+                                current_address, requested_feedback_location, returned_parameters_location, state_length, state_address, state_instruction, minimum_access_length,state_retention_priority);
+        }
+        /* TODO: This isn't currently totaly correct as END_INSTRUCTION might not create state */
+        no_of_state_create++;
+        if ( no_of_state_create > 4 ) {
+            result_code = 12;
+            goto decompression_failure;
+        }
+        state_length_buff[no_of_state_create] = state_length;
+        state_address_buff[no_of_state_create] = state_address;
+        state_instruction_buff[no_of_state_create] = state_instruction;
+        /* Not used ? */
+        state_minimum_access_length_buff[no_of_state_create] = minimum_access_length;
+        /* state_state_retention_priority_buff[no_of_state_create] = state_retention_priority; */
+
+        /* Execute the instruction
+         */
+        proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"no_of_state_create %u",no_of_state_create);
+        if ( no_of_state_create != 0 ) {
+            memset(sha1_digest_buf, 0, STATE_BUFFER_SIZE);
+            n = 1;
+            byte_copy_right = buff[66] << 8;
+            byte_copy_right = byte_copy_right | buff[67];
+            byte_copy_left = buff[64] << 8;
+            byte_copy_left = byte_copy_left | buff[65];
+            while ( n < no_of_state_create + 1 ) {
+                sha1buff = (guint8 *)g_malloc(state_length_buff[n]+8);
+                sha1buff[0] = state_length_buff[n] >> 8;
+                sha1buff[1] = state_length_buff[n] & 0xff;
+                sha1buff[2] = state_address_buff[n] >> 8;
+                sha1buff[3] = state_address_buff[n] & 0xff;
+                sha1buff[4] = state_instruction_buff[n] >> 8;
+                sha1buff[5] = state_instruction_buff[n] & 0xff;
+                sha1buff[6] = state_minimum_access_length_buff[n] >> 8;
+                sha1buff[7] = state_minimum_access_length_buff[n] & 0xff;
+                if (print_level_3 ) {
+                    for ( x=0; x < 8; x++) {
+                        proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"sha1buff %u 0x%x",
+                                            x,sha1buff[x]);
+                    }
+                }
+                k = state_address_buff[n];
+                for ( x=0; x < state_length_buff[n]; x++)
+                {
+                    if ( k == byte_copy_right ) {
+                        k = byte_copy_left;
+                    }
+                    sha1buff[8+x] = buff[k];
+                    k = ( k + 1 ) & 0xffff;
+                }
+
+                sha1_starts( &ctx );
+                sha1_update( &ctx, (guint8 *) sha1buff, state_length_buff[n] + 8);
+                sha1_finish( &ctx, sha1_digest_buf );
+                if (print_level_3 ) {
+                    proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"SHA1 digest %s", bytes_to_str(wmem_packet_scope(), sha1_digest_buf, STATE_BUFFER_SIZE));
+
+                }
 /* begin partial state-id change cco@iptel.org */
 #if 0
-				udvm_state_create(sha1buff, sha1_digest_buf, state_minimum_access_length_buff[n]);
+                udvm_state_create(sha1buff, sha1_digest_buf, state_minimum_access_length_buff[n]);
 #endif
-				udvm_state_create(sha1buff, sha1_digest_buf, STATE_MIN_ACCESS_LEN);
+                udvm_state_create(sha1buff, sha1_digest_buf, STATE_MIN_ACCESS_LEN);
 /* end partial state-id change cco@iptel.org */
-				proto_tree_add_text(udvm_tree,bytecode_tvb, 0, -1,"### Creating state ###");
-				proto_tree_add_string(udvm_tree,hf_id, bytecode_tvb, 0, 0, bytes_to_str(wmem_packet_scope(), sha1_digest_buf, STATE_MIN_ACCESS_LEN));
-
-				n++;
-
-			}
-		}
-
-
-
-		/* At least something got decompressed, show it */
-		decomp_tvb = tvb_new_child_real_data(message_tvb, out_buff,output_address,output_address);
-		/* Arrange that the allocated packet data copy be freed when the
-		 * tvbuff is freed.
-		 */
-		tvb_set_free_cb( decomp_tvb, g_free );
-
-		add_new_data_source(pinfo, decomp_tvb, "Decompressed SigComp message");
-		/*
-		proto_tree_add_text(udvm_tree, decomp_tvb, 0, -1,"SigComp message Decompressed");
-		*/
-		used_udvm_cycles = used_udvm_cycles + state_length;
-		proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"maximum_UDVM_cycles %u used_udvm_cycles %u",
-			maximum_UDVM_cycles, used_udvm_cycles);
-		return decomp_tvb;
-		break;
-
-	default:
-	    proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1," ### Addr %u Invalid instruction: %u (0x%x)",
-			current_address,current_instruction,current_instruction);
-		break;
-		}
-		g_free(out_buff);
-		return NULL;
+                proto_tree_add_text(udvm_tree,bytecode_tvb, 0, -1,"### Creating state ###");
+                proto_tree_add_string(udvm_tree,hf_id, bytecode_tvb, 0, 0, bytes_to_str(wmem_packet_scope(), sha1_digest_buf, STATE_MIN_ACCESS_LEN));
+
+                n++;
+
+            }
+        }
+
+
+
+        /* At least something got decompressed, show it */
+        decomp_tvb = tvb_new_child_real_data(message_tvb, out_buff,output_address,output_address);
+        /* Arrange that the allocated packet data copy be freed when the
+         * tvbuff is freed.
+         */
+        tvb_set_free_cb( decomp_tvb, g_free );
+
+        add_new_data_source(pinfo, decomp_tvb, "Decompressed SigComp message");
+        /*
+          proto_tree_add_text(udvm_tree, decomp_tvb, 0, -1,"SigComp message Decompressed");
+        */
+        used_udvm_cycles = used_udvm_cycles + state_length;
+        proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"maximum_UDVM_cycles %u used_udvm_cycles %u",
+                            maximum_UDVM_cycles, used_udvm_cycles);
+        return decomp_tvb;
+        break;
+
+    default:
+        proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1," ### Addr %u Invalid instruction: %u (0x%x)",
+                            current_address,current_instruction,current_instruction);
+        break;
+    }
+    g_free(out_buff);
+    return NULL;
 decompression_failure:
 
-		proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"DECOMPRESSION FAILURE: %s",
-				    val_to_str(result_code, result_code_vals,"Unknown (%u)"));
-		g_free(out_buff);
-		THROW(ReportedBoundsError);
-		return NULL;
+    proto_tree_add_text(udvm_tree, bytecode_tvb, 0, -1,"DECOMPRESSION FAILURE: %s",
+                        val_to_str(result_code, result_code_vals,"Unknown (%u)"));
+    g_free(out_buff);
+    THROW(ReportedBoundsError);
+    return NULL;
 
 }
 
@@ -4359,11 +4359,11 @@ decompression_failure:
 static int
 dissect_sigcomp_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *_data _U_)
 {
-    proto_item  *ti;
-    proto_tree  *sigcomp_tree;
-    tvbuff_t    *unescaped_tvb;
+    proto_item *ti;
+    proto_tree *sigcomp_tree;
+    tvbuff_t   *unescaped_tvb;
 
-    guint8      *buff;
+    guint8     *buff;
     int         offset = 0;
     int         length;
     guint8      octet;
@@ -4376,11 +4376,11 @@ dissect_sigcomp_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *_
 
     /* Is this SIGCOMP ? */
     data = tvb_get_ntohs(tvb, offset);
-    if(data == 0xffff){
+    if (data == 0xffff) {
         /* delimiter */
         offset = offset + 2;
         octet = tvb_get_guint8(tvb,offset);
-    }else{
+    } else {
         octet = tvb_get_guint8(tvb,offset);
     }
     if ((octet  & 0xf8) != 0xf8)
@@ -4388,16 +4388,16 @@ dissect_sigcomp_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *_
 
     /* Search for delimiter 0xffff in the remain tvb buffer */
     length = tvb_ensure_length_remaining(tvb, offset);
-    for(i=0; i<(length-1); ++i){
+    for (i=0; i<(length-1); ++i) {
         /* Loop end criteria is (length-1) because we take 2 bytes each loop */
         data = tvb_get_ntohs(tvb, offset+i);
         if (0xffff == data) break;
     }
-    if (i >= (length-1)){
+    if (i >= (length-1)) {
         /* SIGCOMP may be subdissector of SIP, so we use
          * pinfo->saved_can_desegment to determine whether do desegment
          * as well as pinfo->can_desegment */
-        if (pinfo->can_desegment || pinfo->saved_can_desegment){
+        if (pinfo->can_desegment || pinfo->saved_can_desegment) {
             /* Delimiter oxffff was not found, not a complete SIGCOMP PDU */
             pinfo->desegment_offset = offset;
             pinfo->desegment_len=DESEGMENT_ONE_MORE_SEGMENT;
@@ -4421,10 +4421,10 @@ try_again:
     buff = (guint8 *)wmem_alloc(pinfo->pool, length-offset);
     if (udvm_print_detail_level>2)
         proto_tree_add_text(sigcomp_tree, tvb, offset, -1,"Starting to remove escape digits");
-    while ((offset < length) && (end_off_message == FALSE)){
+    while ((offset < length) && (end_off_message == FALSE)) {
         octet = tvb_get_guint8(tvb,offset);
-        if ( octet == 0xff ){
-            if ( offset +1 >= length ){
+        if ( octet == 0xff ) {
+            if ( offset +1 >= length ) {
                 /* if the tvb is short don't check for the second escape digit */
                 offset++;
                 continue;
@@ -4433,20 +4433,20 @@ try_again:
                 proto_tree_add_text(sigcomp_tree, tvb, offset, 2,
                     "              Escape digit found (0xFF)");
             octet = tvb_get_guint8(tvb, offset+1);
-            if ( octet == 0){
+            if ( octet == 0) {
                 buff[i] = 0xff;
                 offset = offset +2;
                 i++;
                 continue;
             }
-            if ((octet > 0x7f) && (octet < 0xff )){
+            if ((octet > 0x7f) && (octet < 0xff )) {
                 if (udvm_print_detail_level>2)
                     proto_tree_add_text(sigcomp_tree, tvb, offset, 2,
                         "              Illegal escape code");
                 offset = offset + tvb_length_remaining(tvb,offset);
                 return offset;
             }
-            if ( octet == 0xff){
+            if ( octet == 0xff) {
                 if (udvm_print_detail_level>2)
                     proto_tree_add_text(sigcomp_tree, tvb, offset, 2,
                         "              End of SigComp message indication found (0xFFFF)");
@@ -4463,10 +4463,10 @@ try_again:
             if (udvm_print_detail_level>2)
             proto_tree_add_text(sigcomp_tree, tvb, offset, octet,
                         "              Copying %u bytes literally",octet);
-            if( offset+octet >= length)
+            if ( offset+octet >= length)
                 /* if the tvb is short don't copy further than the end */
                 octet = length - offset;
-            for ( n=0; n < octet; n++ ){
+            for ( n=0; n < octet; n++ ) {
                 buff[i] = tvb_get_guint8(tvb, offset);
                 if (udvm_print_detail_level>2)
                     proto_tree_add_text(sigcomp_tree, tvb, offset, 1,
@@ -4489,12 +4489,12 @@ try_again:
     add_new_data_source(pinfo, unescaped_tvb, "Unescaped Data handed to the SigComp dissector");
 
     proto_tree_add_text(sigcomp_tree, unescaped_tvb, 0, -1,"Data handed to the Sigcomp dissector");
-    if (end_off_message == TRUE){
+    if (end_off_message == TRUE) {
         dissect_sigcomp_common(unescaped_tvb, pinfo, sigcomp_tree);
-    }else{
+    } else {
         proto_tree_add_text(sigcomp_tree, unescaped_tvb, 0, -1,"TCP Fragment, no end mark found");
     }
-    if ( offset < length){
+    if ( offset < length) {
         goto try_again;
     }
 
@@ -4504,8 +4504,8 @@ try_again:
 static int
 dissect_sigcomp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
 {
-    proto_item  *ti;
-    proto_tree  *sigcomp_tree;
+    proto_item *ti;
+    proto_tree *sigcomp_tree;
     gint        offset = 0;
     gint8       octet;
 
@@ -4537,22 +4537,22 @@ dissect_sigcomp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sigcomp_tr
 {
 
 /* Set up structures needed to add the protocol subtree and manage it */
-    tvbuff_t    *udvm_tvb, *msg_tvb, *udvm2_tvb;
-    tvbuff_t    *decomp_tvb = NULL;
-    proto_item  *udvm_bytecode_item, *udvm_exe_item;
-    proto_tree  *sigcomp_udvm_tree, *sigcomp_udvm_exe_tree;
-    gint        offset = 0;
+    tvbuff_t   *udvm_tvb, *msg_tvb, *udvm2_tvb;
+    tvbuff_t   *decomp_tvb   = NULL;
+    proto_item *udvm_bytecode_item, *udvm_exe_item;
+    proto_tree *sigcomp_udvm_tree, *sigcomp_udvm_exe_tree;
+    gint        offset       = 0;
     gint        bytecode_offset;
     guint16     partial_state_len;
     guint       octet;
     guint8      returned_feedback_field[128];
     guint8      partial_state[12];
     guint       tbit;
-    guint16     len = 0;
+    guint16     len          = 0;
     guint16     bytecode_len = 0;
     guint       destination;
-    gint        msg_len = 0;
-    guint8      *buff;
+    gint        msg_len      = 0;
+    guint8     *buff;
     guint16     p_id_start;
     guint8      i;
     guint16     state_begin;
@@ -4560,7 +4560,7 @@ dissect_sigcomp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sigcomp_tr
     guint16     state_address;
     guint16     state_instruction;
     guint16     result_code;
-    gchar       *partial_state_str;
+    gchar      *partial_state_str;
     guint8      nack_version;
 
 
@@ -4634,7 +4634,7 @@ dissect_sigcomp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sigcomp_tr
     tbit = ( octet & 0x04)>>2;
     partial_state_len = octet & 0x03;
     offset ++;
-    if ( partial_state_len != 0 ){
+    if ( partial_state_len != 0 ) {
         /*
          * The len field encodes the number of transmitted bytes as follows:
          *
@@ -4669,7 +4669,7 @@ dissect_sigcomp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sigcomp_tr
              * Figure 4: Format of returned feedback item
              */
 
-            if ( (octet & 0x80) != 0 ){
+            if ( (octet & 0x80) != 0 ) {
                 len = octet & 0x7f;
                 proto_tree_add_item(sigcomp_tree,hf_sigcomp_returned_feedback_item_len,
                                     tvb, offset, 1, ENC_BIG_ENDIAN);
@@ -4689,7 +4689,7 @@ dissect_sigcomp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sigcomp_tr
         offset = offset + partial_state_len;
         msg_len = tvb_reported_length_remaining(tvb, offset);
 
-        if(msg_len>0){
+        if (msg_len>0) {
             proto_item *ti;
             ti = proto_tree_add_uint(sigcomp_tree, hf_sigcomp_remaining_message_bytes, tvb,
                                      offset, 0, msg_len);
@@ -4723,7 +4723,7 @@ dissect_sigcomp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sigcomp_tr
             state_instruction =0;
 
             i = 0;
-            while ( i < partial_state_len ){
+            while ( i < partial_state_len ) {
                 buff[i] = partial_state[i];
                 i++;
             }
@@ -4737,7 +4737,7 @@ dissect_sigcomp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sigcomp_tr
                 &state_address, &state_instruction, hf_sigcomp_partial_state);
 
 /* end partial state-id change cco@iptel.org */
-            if ( result_code != 0 ){
+            if ( result_code != 0 ) {
                 proto_item *ti;
                 ti = proto_tree_add_text(sigcomp_tree, tvb, 0, -1,"Failed to Access state Wireshark UDVM diagnostic: %s.",
                                          val_to_str(result_code, result_code_vals,"Unknown (%u)"));
@@ -4760,7 +4760,7 @@ dissect_sigcomp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sigcomp_tr
                            offset, state_length, partial_state_len, state_instruction);
 
 
-            if ( decomp_tvb ){
+            if ( decomp_tvb ) {
                 proto_item *ti;
                 guint32 compression_ratio =
                     (guint32)(((float)tvb_length(decomp_tvb) / (float)tvb_length(tvb)) * 100);
@@ -4792,7 +4792,7 @@ dissect_sigcomp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sigcomp_tr
              */
             len = 1;
             octet = tvb_get_guint8(tvb, offset);
-            if ( (octet & 0x80) != 0 ){
+            if ( (octet & 0x80) != 0 ) {
                 len = octet & 0x7f;
                 proto_tree_add_item(sigcomp_tree,hf_sigcomp_returned_feedback_item_len,
                                     tvb, offset, 1, ENC_BIG_ENDIAN);
@@ -4805,7 +4805,7 @@ dissect_sigcomp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sigcomp_tr
         }
         len = tvb_get_ntohs(tvb, offset) >> 4;
         nack_version = tvb_get_guint8(tvb, offset+1) & 0x0f;
-        if ((len == 0) && (nack_version == 1)){
+        if ((len == 0) && (nack_version == 1)) {
             /* NACK MESSAGE */
             proto_item *reason_ti;
             guint8 opcode;
@@ -4835,7 +4835,7 @@ dissect_sigcomp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sigcomp_tr
                             val_to_str_ext_const(octet, &sigcomp_nack_reason_code_vals_ext, "Unknown"),
                             val_to_str_ext_const(opcode, &udvm_instruction_code_vals_ext, "Unknown"));
 
-            switch ( octet){
+            switch ( octet) {
             case SIGCOMP_NACK_STATE_NOT_FOUND:
             case SIGCOMP_NACK_ID_NOT_UNIQUE:
             case SIGCOMP_NACK_STATE_TOO_SHORT:
@@ -4853,7 +4853,7 @@ dissect_sigcomp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sigcomp_tr
             default:
                 break;
             }
-        }else{
+        } else {
             octet = tvb_get_guint8(tvb, (offset + 1));
             destination = (octet & 0x0f);
             if ( destination != 0 )
@@ -4882,7 +4882,7 @@ dissect_sigcomp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sigcomp_tr
                                                      tvb_reported_length_remaining(tvb, offset));
                 PROTO_ITEM_SET_GENERATED(ti);
             }
-            if ( decompress ){
+            if ( decompress ) {
 
                 msg_tvb = tvb_new_subset_length(tvb, offset, msg_len);
 
@@ -4894,7 +4894,7 @@ dissect_sigcomp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sigcomp_tr
                            sigcomp_udvm_exe_tree, destination,
                            udvm_print_detail_level, hf_sigcomp_partial_state,
                            offset, 0, 0, destination);
-                if ( decomp_tvb ){
+                if ( decomp_tvb ) {
                     proto_item *ti;
                     guint32 compression_ratio =
                         (guint32)(((float)tvb_length(decomp_tvb) / (float)tvb_length(tvb)) * 100);
@@ -4961,17 +4961,17 @@ dissect_sigcomp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sigcomp_tr
 static void
 dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint start_address)
 {
-    guint instruction;
-    gint offset = 0;
-    gint start_offset = 0;
-    gint len;
-    gint n;
-    guint instruction_no = 0;
-    guint16 value = 0;
+    guint       instruction;
+    gint        offset         = 0;
+    gint        start_offset   = 0;
+    gint        len;
+    gint        n;
+    guint       instruction_no = 0;
+    guint16     value          = 0;
     proto_item *item, *item2;
-    guint UDVM_address = start_address;
-    gboolean is_memory_address;
-    guint16 msg_length = tvb_reported_length_remaining(udvm_tvb, offset);
+    guint       UDVM_address   = start_address;
+    gboolean    is_memory_address;
+    guint16     msg_length     = tvb_reported_length_remaining(udvm_tvb, offset);
 
 
     while (msg_length > offset) {
@@ -4997,10 +4997,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %operand_2*/
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2_addr,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5015,10 +5015,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %operand_2*/
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2_addr,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5041,10 +5041,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %operand_2*/
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2_addr,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5059,10 +5059,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %operand_2*/
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2_addr,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5077,10 +5077,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %operand_2*/
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2_addr,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5095,10 +5095,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %operand_2*/
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2_addr,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5113,10 +5113,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %operand_2*/
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2_addr,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5131,10 +5131,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %operand_2*/
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2_addr,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5149,10 +5149,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %operand_2*/
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2_addr,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_operand_2,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5175,10 +5175,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /*  %length, */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_length,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_length,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5199,10 +5199,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %value */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_value,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_value,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5225,10 +5225,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
                 /* %value */
                 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
                 len = offset - start_offset;
-                if ( is_memory_address ){
+                if ( is_memory_address ) {
                     proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_value,
                         udvm_tvb, start_offset, len, value);
-                }else{
+                } else {
                     proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_value,
                         udvm_tvb, start_offset, len, value);
                 }
@@ -5239,10 +5239,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %value */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_value,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_value,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5267,10 +5267,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /*  %length, */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_length,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_length,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5292,10 +5292,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /*  %length, */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_length,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_length,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5311,10 +5311,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %offset */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_offset,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_offset,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5322,10 +5322,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /*  %length, */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_length,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_length,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5347,10 +5347,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /*  %length, */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE, &start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_length,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_length,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5385,10 +5385,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %value_1 */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_value,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_value,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5396,10 +5396,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %value_2 */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_value,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_value,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5454,10 +5454,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %j */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_j,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_j,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5477,10 +5477,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %value */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_value,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_value,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5494,10 +5494,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %length */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_length,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_length,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5516,10 +5516,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %length */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_length,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_length,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5527,10 +5527,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %destination */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_destination,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_destination,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5547,10 +5547,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %length */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_length,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_length,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5558,10 +5558,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %destination */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_destination,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_destination,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5583,10 +5583,10 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /* %destination */
             offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, FALSE,&start_offset, &value, &is_memory_address);
             len = offset - start_offset;
-            if ( is_memory_address ){
+            if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_destination,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_destination,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5664,7 +5664,7 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_state_length_addr,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_state_length,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5676,7 +5676,7 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_state_address_addr,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_state_address,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5702,7 +5702,7 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_state_length_addr,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_state_length,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5714,7 +5714,7 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_state_address_addr,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_state_address,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5770,7 +5770,7 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_addr_output_start,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_output_start,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5782,7 +5782,7 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_output_length_addr,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_output_length,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5795,7 +5795,7 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
              * %state_retention_priority)
              */
             /* %requested_feedback_location */
-            if ((msg_length-1) < offset){
+            if ((msg_length-1) < offset) {
                 item2 = proto_tree_add_text(sigcomp_udvm_tree, udvm_tvb, 0, -1,
                         "All remaining parameters = 0(Not in the uploaded code as UDVM buffer initialized to Zero");
                 PROTO_ITEM_SET_GENERATED(item2);
@@ -5806,7 +5806,7 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_req_feedback_loc,
                 udvm_tvb, start_offset, len, value);
             /* returned_parameters_location */
-            if ((msg_length-1) < offset){
+            if ((msg_length-1) < offset) {
                 item2 = proto_tree_add_text(sigcomp_udvm_tree, udvm_tvb, offset-1, -1,
                         "All remaining parameters = 0(Not in the uploaded code as UDVM buffer initialized to Zero");
                 PROTO_ITEM_SET_GENERATED(item2);
@@ -5824,7 +5824,7 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_state_length_addr,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_state_length,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5836,7 +5836,7 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             if ( is_memory_address ) {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_state_address_addr,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_state_address,
                     udvm_tvb, start_offset, len, value);
             }
@@ -5857,17 +5857,17 @@ dissect_udvm_bytecode(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,guint st
             /*
              * %state_retention_priority
              */
-            if ( tvb_reported_length_remaining(udvm_tvb, offset) != 0 ){
+            if ( tvb_reported_length_remaining(udvm_tvb, offset) != 0 ) {
                 offset = dissect_udvm_multitype_operand(udvm_tvb, sigcomp_udvm_tree, offset, TRUE, &start_offset, &value, &is_memory_address);
                 len = offset - start_offset;
                 proto_tree_add_uint(sigcomp_udvm_tree, hf_udvm_state_ret_pri,
                     udvm_tvb, start_offset, len, value);
-            }else{
+            } else {
                 item2 = proto_tree_add_text(sigcomp_udvm_tree, udvm_tvb, offset, 1,
                         "state_retention_priority = 0(Not in the uploaded code as UDVM buffer initialized to Zero");
                 PROTO_ITEM_SET_GENERATED(item2);
             }
-            if ( tvb_reported_length_remaining(udvm_tvb, offset) != 0 ){
+            if ( tvb_reported_length_remaining(udvm_tvb, offset) != 0 ) {
                 len = tvb_reported_length_remaining(udvm_tvb, offset);
                 UDVM_address = start_address + offset;
                 proto_tree_add_text(sigcomp_udvm_tree, udvm_tvb, offset, len,
@@ -5900,16 +5900,16 @@ static int
 dissect_udvm_literal_operand(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,
                                gint offset, gint *start_offset, guint16 *value)
 {
-    guint bytecode;
+    guint   bytecode;
     guint16 operand;
-    guint test_bits;
-    guint display_bytecode;
+    guint   test_bits;
+    guint   display_bytecode;
 
     bytecode = tvb_get_guint8(udvm_tvb, offset);
     test_bits = bytecode >> 7;
-    if (test_bits == 1){
+    if (test_bits == 1) {
         test_bits = bytecode >> 6;
-        if (test_bits == 2){
+        if (test_bits == 2) {
             /*
              * 10nnnnnn nnnnnnnn               N                   0 - 16383
              */
@@ -5922,7 +5922,7 @@ dissect_udvm_literal_operand(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,
             *start_offset = offset;
             offset = offset + 2;
 
-        }else{
+        } else {
             /*
              * 111000000 nnnnnnnn nnnnnnnn      N                   0 - 65535
              */
@@ -5937,7 +5937,7 @@ dissect_udvm_literal_operand(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,
             offset = offset + 2;
 
         }
-    }else{
+    } else {
         /*
          * 0nnnnnnn                        N                   0 - 127
          */
@@ -5972,16 +5972,16 @@ static int
 dissect_udvm_reference_operand(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree,
                                gint offset, gint *start_offset, guint16 *value)
 {
-    guint bytecode;
+    guint   bytecode;
     guint16 operand;
-    guint test_bits;
-    guint display_bytecode;
+    guint   test_bits;
+    guint   display_bytecode;
 
     bytecode = tvb_get_guint8(udvm_tvb, offset);
     test_bits = bytecode >> 7;
-    if (test_bits == 1){
+    if (test_bits == 1) {
         test_bits = bytecode >> 6;
-        if (test_bits == 2){
+        if (test_bits == 2) {
             /*
              * 10nnnnnn nnnnnnnn               memory[2 * N]       0 - 65535
              */
@@ -5994,7 +5994,7 @@ dissect_udvm_reference_operand(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree
             *start_offset = offset;
             offset = offset + 2;
 
-        }else{
+        } else {
             /*
              * 11000000 nnnnnnnn nnnnnnnn      memory[N]           0 - 65535
              */
@@ -6009,7 +6009,7 @@ dissect_udvm_reference_operand(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree
             offset = offset + 2;
 
         }
-    }else{
+    } else {
         /*
          * 0nnnnnnn                        memory[2 * N]       0 - 65535
          */
@@ -6063,7 +6063,7 @@ dissect_udvm_multitype_operand(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree
     *is_memory_address = FALSE;
     bytecode = tvb_get_guint8(udvm_tvb, offset);
     test_bits = ( bytecode & 0xc0 ) >> 6;
-    switch (test_bits ){
+    switch (test_bits ) {
     case 0:
         /*
          * 00nnnnnn                        N                   0 - 63
@@ -6094,7 +6094,7 @@ dissect_udvm_multitype_operand(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree
     case 2:
         /* Check tree most significant bits */
         test_bits = ( bytecode & 0xe0 ) >> 5;
-        if ( test_bits == 5 ){
+        if ( test_bits == 5 ) {
         /*
          * 101nnnnn nnnnnnnn               N                   0 - 8191
          */
@@ -6106,9 +6106,9 @@ dissect_udvm_multitype_operand(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree
             *value = operand;
             *start_offset = offset;
             offset = offset + 2;
-        }else{
+        } else {
             test_bits = ( bytecode & 0xf0 ) >> 4;
-            if ( test_bits == 9 ){
+            if ( test_bits == 9 ) {
         /*
          * 1001nnnn nnnnnnnn               N + 61440       61440 - 65535
          */
@@ -6120,9 +6120,9 @@ dissect_udvm_multitype_operand(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree
                 *start_offset = offset;
                 *value = operand;
                 offset = offset + 2;
-            }else{
+            } else {
                 test_bits = ( bytecode & 0x08 ) >> 3;
-                if ( test_bits == 1){
+                if ( test_bits == 1) {
         /*
          * 10001nnn                        2 ^ (N + 8)    256 , ... , 32768
          */
@@ -6135,9 +6135,9 @@ dissect_udvm_multitype_operand(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree
                     *start_offset = offset;
                     *value = operand;
                     offset ++;
-                }else{
+                } else {
                     test_bits = ( bytecode & 0x0e ) >> 1;
-                    if ( test_bits == 3 ){
+                    if ( test_bits == 3 ) {
                         /*
                          * 1000 011n                        2 ^ (N + 6)        64 , 128
                          */
@@ -6150,7 +6150,7 @@ dissect_udvm_multitype_operand(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree
                         *start_offset = offset;
                         *value = operand;
                         offset ++;
-                    }else{
+                    } else {
                     /*
                      * 1000 0000 nnnnnnnn nnnnnnnn      N                   0 - 65535
                      * 1000 0001 nnnnnnnn nnnnnnnn      memory[N]           0 - 65535
@@ -6176,7 +6176,7 @@ dissect_udvm_multitype_operand(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree
 
     case 3:
         test_bits = ( bytecode & 0x20 ) >> 5;
-        if ( test_bits == 1 ){
+        if ( test_bits == 1 ) {
         /*
          * 111nnnnn                        N + 65504       65504 - 65535
          */
@@ -6188,7 +6188,7 @@ dissect_udvm_multitype_operand(tvbuff_t *udvm_tvb, proto_tree *sigcomp_udvm_tree
             *start_offset = offset;
             *value = operand;
             offset ++;
-        }else{
+        } else {
         /*
          * 110nnnnn nnnnnnnn               memory[N]           0 - 65535
          */
@@ -6216,7 +6216,7 @@ tvb_raw_text_add(tvbuff_t *tvb, proto_tree *tree)
     proto_item *ti = NULL;
     int offset, next_offset, linelen;
 
-    if(tree) {
+    if (tree) {
         ti = proto_tree_add_item(tree, proto_raw_sigcomp, tvb, 0, -1, ENC_NA);
         raw_tree = proto_item_add_subtree(ti, ett_raw_text);
     }
@@ -6662,7 +6662,7 @@ proto_reg_handoff_sigcomp(void)
 {
     static dissector_handle_t sigcomp_handle;
     static dissector_handle_t sigcomp_tcp_handle;
-    static gboolean Initialized=FALSE;
+    static gboolean Initialized = FALSE;
     static guint udp_port1;
     static guint udp_port2;
     static guint tcp_port1;
@@ -6673,7 +6673,7 @@ proto_reg_handoff_sigcomp(void)
         sigcomp_tcp_handle = new_create_dissector_handle(dissect_sigcomp_tcp,proto_sigcomp);
         sip_handle = find_dissector("sip");
         Initialized=TRUE;
-    }else{
+    } else {
         dissector_delete_uint("udp.port", udp_port1, sigcomp_handle);
         dissector_delete_uint("udp.port", udp_port2, sigcomp_handle);
         dissector_delete_uint("tcp.port", tcp_port1, sigcomp_tcp_handle);
diff --git a/epan/dissectors/packet-srvloc.c b/epan/dissectors/packet-srvloc.c
index f3b1c3d1eb..9cdb9503ee 100644
--- a/epan/dissectors/packet-srvloc.c
+++ b/epan/dissectors/packet-srvloc.c
@@ -367,7 +367,7 @@ dissect_authblk(tvbuff_t *tvb, int offset, proto_tree *tree)
 {
     guint16     length;
 
-	proto_tree_add_item(tree, hf_srvloc_timestamp, tvb, offset, 8, ENC_TIME_NTP|ENC_BIG_ENDIAN);
+    proto_tree_add_item(tree, hf_srvloc_timestamp, tvb, offset, 8, ENC_TIME_NTP|ENC_BIG_ENDIAN);
     proto_tree_add_item(tree, hf_srvloc_block_structure_descriptor, tvb, offset + 8, 2, ENC_BIG_ENDIAN);
     length = tvb_get_ntohs(tvb, offset + 10);
     proto_tree_add_item(tree, hf_srvloc_authenticator_length, tvb, offset + 10, 2, ENC_BIG_ENDIAN);
diff --git a/epan/jsmn/jsmn.c b/epan/jsmn/jsmn.c
index acdd2c8b44..30014239ea 100644
--- a/epan/jsmn/jsmn.c
+++ b/epan/jsmn/jsmn.c
@@ -28,18 +28,18 @@
  * Allocates a fresh unused token from the token pull.
  */
 static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser,
-		jsmntok_t *tokens, size_t num_tokens) {
-	jsmntok_t *tok;
-	if (parser->toknext >= num_tokens) {
-		return NULL;
-	}
-	tok = &tokens[parser->toknext++];
-	tok->start = tok->end = -1;
-	tok->size = 0;
+                                   jsmntok_t *tokens, size_t num_tokens) {
+    jsmntok_t *tok;
+    if (parser->toknext >= num_tokens) {
+        return NULL;
+    }
+    tok = &tokens[parser->toknext++];
+    tok->start = tok->end = -1;
+    tok->size = 0;
 #ifdef JSMN_PARENT_LINKS
-	tok->parent = -1;
+    tok->parent = -1;
 #endif
-	return tok;
+    return tok;
 }
 
 /**
@@ -47,278 +47,278 @@ static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser,
  */
 static void jsmn_fill_token(jsmntok_t *token, jsmntype_t type,
                             int start, int end) {
-	token->type = type;
-	token->start = start;
-	token->end = end;
-	token->size = 0;
+    token->type = type;
+    token->start = start;
+    token->end = end;
+    token->size = 0;
 }
 
 /**
  * Fills next available token with JSON primitive.
  */
 static int jsmn_parse_primitive(jsmn_parser *parser, const char *js,
-		size_t len, jsmntok_t *tokens, size_t num_tokens) {
-	jsmntok_t *token;
-	int start;
+        size_t len, jsmntok_t *tokens, size_t num_tokens) {
+    jsmntok_t *token;
+    int start;
 
-	start = parser->pos;
+    start = parser->pos;
 
-	for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
-		switch (js[parser->pos]) {
+    for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
+        switch (js[parser->pos]) {
 #ifndef JSMN_STRICT
-			/* In strict mode primitive must be followed by "," or "}" or "]" */
-			case ':':
+            /* In strict mode primitive must be followed by "," or "}" or "]" */
+            case ':':
 #endif
-			case '\t' : case '\r' : case '\n' : case ' ' :
-			case ','  : case ']'  : case '}' :
-				goto found;
-		}
-		if (js[parser->pos] < 32 || js[parser->pos] >= 127) {
-			parser->pos = start;
-			return JSMN_ERROR_INVAL;
-		}
-	}
+            case '\t' : case '\r' : case '\n' : case ' ' :
+            case ','  : case ']'  : case '}' :
+                goto found;
+        }
+        if (js[parser->pos] < 32 || js[parser->pos] >= 127) {
+            parser->pos = start;
+            return JSMN_ERROR_INVAL;
+        }
+    }
 #ifdef JSMN_STRICT
-	/* In strict mode primitive must be followed by a comma/object/array */
-	parser->pos = start;
-	return JSMN_ERROR_PART;
+    /* In strict mode primitive must be followed by a comma/object/array */
+    parser->pos = start;
+    return JSMN_ERROR_PART;
 #endif
 
 found:
-	if (tokens == NULL) {
-		parser->pos--;
-		return 0;
-	}
-	token = jsmn_alloc_token(parser, tokens, num_tokens);
-	if (token == NULL) {
-		parser->pos = start;
-		return JSMN_ERROR_NOMEM;
-	}
-	jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos);
+    if (tokens == NULL) {
+        parser->pos--;
+        return 0;
+    }
+    token = jsmn_alloc_token(parser, tokens, num_tokens);
+    if (token == NULL) {
+        parser->pos = start;
+        return JSMN_ERROR_NOMEM;
+    }
+    jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos);
 #ifdef JSMN_PARENT_LINKS
-	token->parent = parser->toksuper;
+    token->parent = parser->toksuper;
 #endif
-	parser->pos--;
-	return 0;
+    parser->pos--;
+    return 0;
 }
 
 /**
  * Filsl next token with JSON string.
  */
 static int jsmn_parse_string(jsmn_parser *parser, const char *js,
-		size_t len, jsmntok_t *tokens, size_t num_tokens) {
-	jsmntok_t *token;
+        size_t len, jsmntok_t *tokens, size_t num_tokens) {
+    jsmntok_t *token;
 
-	int start = parser->pos;
+    int start = parser->pos;
 
-	parser->pos++;
+    parser->pos++;
 
-	/* Skip starting quote */
-	for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
-		char c = js[parser->pos];
+    /* Skip starting quote */
+    for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
+        char c = js[parser->pos];
 
-		/* Quote: end of string */
-		if (c == '\"') {
-			if (tokens == NULL) {
-				return 0;
-			}
-			token = jsmn_alloc_token(parser, tokens, num_tokens);
-			if (token == NULL) {
-				parser->pos = start;
-				return JSMN_ERROR_NOMEM;
-			}
-			jsmn_fill_token(token, JSMN_STRING, start+1, parser->pos);
+        /* Quote: end of string */
+        if (c == '\"') {
+            if (tokens == NULL) {
+                return 0;
+            }
+            token = jsmn_alloc_token(parser, tokens, num_tokens);
+            if (token == NULL) {
+                parser->pos = start;
+                return JSMN_ERROR_NOMEM;
+            }
+            jsmn_fill_token(token, JSMN_STRING, start+1, parser->pos);
 #ifdef JSMN_PARENT_LINKS
-			token->parent = parser->toksuper;
+            token->parent = parser->toksuper;
 #endif
-			return 0;
-		}
+            return 0;
+        }
 
-		/* Backslash: Quoted symbol expected */
-		if (c == '\\' && parser->pos + 1 < len) {
-			int i;
-			parser->pos++;
-			switch (js[parser->pos]) {
-				/* Allowed escaped symbols */
-				case '\"': case '/' : case '\\' : case 'b' :
-				case 'f' : case 'r' : case 'n'  : case 't' :
-					break;
-				/* Allows escaped symbol \uXXXX */
-				case 'u':
-					parser->pos++;
-					for(i = 0; i < 4 && parser->pos < len && js[parser->pos] != '\0'; i++) {
-						/* If it isn't a hex character we have an error */
-						if(!((js[parser->pos] >= 48 && js[parser->pos] <= 57) || /* 0-9 */
-									(js[parser->pos] >= 65 && js[parser->pos] <= 70) || /* A-F */
-									(js[parser->pos] >= 97 && js[parser->pos] <= 102))) { /* a-f */
-							parser->pos = start;
-							return JSMN_ERROR_INVAL;
-						}
-						parser->pos++;
-					}
-					parser->pos--;
-					break;
-				/* Unexpected symbol */
-				default:
-					parser->pos = start;
-					return JSMN_ERROR_INVAL;
-			}
-		}
-	}
-	parser->pos = start;
-	return JSMN_ERROR_PART;
+        /* Backslash: Quoted symbol expected */
+        if (c == '\\' && parser->pos + 1 < len) {
+            int i;
+            parser->pos++;
+            switch (js[parser->pos]) {
+                /* Allowed escaped symbols */
+                case '\"': case '/' : case '\\' : case 'b' :
+                case 'f' : case 'r' : case 'n'  : case 't' :
+                    break;
+                /* Allows escaped symbol \uXXXX */
+                case 'u':
+                    parser->pos++;
+                    for(i = 0; i < 4 && parser->pos < len && js[parser->pos] != '\0'; i++) {
+                        /* If it isn't a hex character we have an error */
+                        if(!((js[parser->pos] >= 48 && js[parser->pos] <= 57) || /* 0-9 */
+                                    (js[parser->pos] >= 65 && js[parser->pos] <= 70) || /* A-F */
+                                    (js[parser->pos] >= 97 && js[parser->pos] <= 102))) { /* a-f */
+                            parser->pos = start;
+                            return JSMN_ERROR_INVAL;
+                        }
+                        parser->pos++;
+                    }
+                    parser->pos--;
+                    break;
+                /* Unexpected symbol */
+                default:
+                    parser->pos = start;
+                    return JSMN_ERROR_INVAL;
+            }
+        }
+    }
+    parser->pos = start;
+    return JSMN_ERROR_PART;
 }
 
 /**
  * Parse JSON string and fill tokens.
  */
 int jsmn_parse(jsmn_parser *parser, const char *js, size_t len,
-		jsmntok_t *tokens, unsigned int num_tokens) {
-	int r;
-	int i;
-	jsmntok_t *token;
-	int count = 0;
+        jsmntok_t *tokens, unsigned int num_tokens) {
+    int r;
+    int i;
+    jsmntok_t *token;
+    int count = 0;
 
-	for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
-		char c;
-		jsmntype_t type;
+    for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
+        char c;
+        jsmntype_t type;
 
-		c = js[parser->pos];
-		switch (c) {
-			case '{': case '[':
-				count++;
-				if (tokens == NULL) {
-					break;
-				}
-				token = jsmn_alloc_token(parser, tokens, num_tokens);
-				if (token == NULL)
-					return JSMN_ERROR_NOMEM;
-				if (parser->toksuper != -1) {
-					tokens[parser->toksuper].size++;
+        c = js[parser->pos];
+        switch (c) {
+            case '{': case '[':
+                count++;
+                if (tokens == NULL) {
+                    break;
+                }
+                token = jsmn_alloc_token(parser, tokens, num_tokens);
+                if (token == NULL)
+                    return JSMN_ERROR_NOMEM;
+                if (parser->toksuper != -1) {
+                    tokens[parser->toksuper].size++;
 #ifdef JSMN_PARENT_LINKS
-					token->parent = parser->toksuper;
+                    token->parent = parser->toksuper;
 #endif
-				}
-				token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY);
-				token->start = parser->pos;
-				parser->toksuper = parser->toknext - 1;
-				break;
-			case '}': case ']':
-				if (tokens == NULL)
-					break;
-				type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY);
+                }
+                token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY);
+                token->start = parser->pos;
+                parser->toksuper = parser->toknext - 1;
+                break;
+            case '}': case ']':
+                if (tokens == NULL)
+                    break;
+                type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY);
 #ifdef JSMN_PARENT_LINKS
-				if (parser->toknext < 1) {
-					return JSMN_ERROR_INVAL;
-				}
-				token = &tokens[parser->toknext - 1];
-				for (;;) {
-					if (token->start != -1 && token->end == -1) {
-						if (token->type != type) {
-							return JSMN_ERROR_INVAL;
-						}
-						token->end = parser->pos + 1;
-						parser->toksuper = token->parent;
-						break;
-					}
-					if (token->parent == -1) {
-						break;
-					}
-					token = &tokens[token->parent];
-				}
+                if (parser->toknext < 1) {
+                    return JSMN_ERROR_INVAL;
+                }
+                token = &tokens[parser->toknext - 1];
+                for (;;) {
+                    if (token->start != -1 && token->end == -1) {
+                        if (token->type != type) {
+                            return JSMN_ERROR_INVAL;
+                        }
+                        token->end = parser->pos + 1;
+                        parser->toksuper = token->parent;
+                        break;
+                    }
+                    if (token->parent == -1) {
+                        break;
+                    }
+                    token = &tokens[token->parent];
+                }
 #else
-				for (i = parser->toknext - 1; i >= 0; i--) {
-					token = &tokens[i];
-					if (token->start != -1 && token->end == -1) {
-						if (token->type != type) {
-							return JSMN_ERROR_INVAL;
-						}
-						parser->toksuper = -1;
-						token->end = parser->pos + 1;
-						break;
-					}
-				}
-				/* Error if unmatched closing bracket */
-				if (i == -1) return JSMN_ERROR_INVAL;
-				for (; i >= 0; i--) {
-					token = &tokens[i];
-					if (token->start != -1 && token->end == -1) {
-						parser->toksuper = i;
-						break;
-					}
-				}
+                for (i = parser->toknext - 1; i >= 0; i--) {
+                    token = &tokens[i];
+                    if (token->start != -1 && token->end == -1) {
+                        if (token->type != type) {
+                            return JSMN_ERROR_INVAL;
+                        }
+                        parser->toksuper = -1;
+                        token->end = parser->pos + 1;
+                        break;
+                    }
+                }
+                /* Error if unmatched closing bracket */
+                if (i == -1) return JSMN_ERROR_INVAL;
+                for (; i >= 0; i--) {
+                    token = &tokens[i];
+                    if (token->start != -1 && token->end == -1) {
+                        parser->toksuper = i;
+                        break;
+                    }
+                }
 #endif
-				break;
-			case '\"':
-				r = jsmn_parse_string(parser, js, len, tokens, num_tokens);
-				if (r < 0) return r;
-				count++;
-				if (parser->toksuper != -1 && tokens != NULL)
-					tokens[parser->toksuper].size++;
-				break;
-			case '\t' : case '\r' : case '\n' : case ' ':
-				break;
-			case ':':
-				parser->toksuper = parser->toknext - 1;
-				break;
-			case ',':
-				if (tokens != NULL && parser->toksuper != -1 &&
-						tokens[parser->toksuper].type != JSMN_ARRAY &&
-						tokens[parser->toksuper].type != JSMN_OBJECT) {
+                break;
+            case '\"':
+                r = jsmn_parse_string(parser, js, len, tokens, num_tokens);
+                if (r < 0) return r;
+                count++;
+                if (parser->toksuper != -1 && tokens != NULL)
+                    tokens[parser->toksuper].size++;
+                break;
+            case '\t' : case '\r' : case '\n' : case ' ':
+                break;
+            case ':':
+                parser->toksuper = parser->toknext - 1;
+                break;
+            case ',':
+                if (tokens != NULL && parser->toksuper != -1 &&
+                        tokens[parser->toksuper].type != JSMN_ARRAY &&
+                        tokens[parser->toksuper].type != JSMN_OBJECT) {
 #ifdef JSMN_PARENT_LINKS
-					parser->toksuper = tokens[parser->toksuper].parent;
+                    parser->toksuper = tokens[parser->toksuper].parent;
 #else
-					for (i = parser->toknext - 1; i >= 0; i--) {
-						if (tokens[i].type == JSMN_ARRAY || tokens[i].type == JSMN_OBJECT) {
-							if (tokens[i].start != -1 && tokens[i].end == -1) {
-								parser->toksuper = i;
-								break;
-							}
-						}
-					}
+                    for (i = parser->toknext - 1; i >= 0; i--) {
+                        if (tokens[i].type == JSMN_ARRAY || tokens[i].type == JSMN_OBJECT) {
+                            if (tokens[i].start != -1 && tokens[i].end == -1) {
+                                parser->toksuper = i;
+                                break;
+                            }
+                        }
+                    }
 #endif
-				}
-				break;
+                }
+                break;
 #ifdef JSMN_STRICT
-			/* In strict mode primitives are: numbers and booleans */
-			case '-': case '0': case '1' : case '2': case '3' : case '4':
-			case '5': case '6': case '7' : case '8': case '9':
-			case 't': case 'f': case 'n' :
-				/* And they must not be keys of the object */
-				if (tokens != NULL && parser->toksuper != -1) {
-					jsmntok_t *t = &tokens[parser->toksuper];
-					if (t->type == JSMN_OBJECT ||
-							(t->type == JSMN_STRING && t->size != 0)) {
-						return JSMN_ERROR_INVAL;
-					}
-				}
+            /* In strict mode primitives are: numbers and booleans */
+            case '-': case '0': case '1' : case '2': case '3' : case '4':
+            case '5': case '6': case '7' : case '8': case '9':
+            case 't': case 'f': case 'n' :
+                /* And they must not be keys of the object */
+                if (tokens != NULL && parser->toksuper != -1) {
+                    jsmntok_t *t = &tokens[parser->toksuper];
+                    if (t->type == JSMN_OBJECT ||
+                            (t->type == JSMN_STRING && t->size != 0)) {
+                        return JSMN_ERROR_INVAL;
+                    }
+                }
 #else
-			/* In non-strict mode every unquoted value is a primitive */
-			default:
+            /* In non-strict mode every unquoted value is a primitive */
+            default:
 #endif
-				r = jsmn_parse_primitive(parser, js, len, tokens, num_tokens);
-				if (r < 0) return r;
-				count++;
-				if (parser->toksuper != -1 && tokens != NULL)
-					tokens[parser->toksuper].size++;
-				break;
+                r = jsmn_parse_primitive(parser, js, len, tokens, num_tokens);
+                if (r < 0) return r;
+                count++;
+                if (parser->toksuper != -1 && tokens != NULL)
+                    tokens[parser->toksuper].size++;
+                break;
 
 #ifdef JSMN_STRICT
-			/* Unexpected char in strict mode */
-			default:
-				return JSMN_ERROR_INVAL;
+            /* Unexpected char in strict mode */
+            default:
+                return JSMN_ERROR_INVAL;
 #endif
-		}
-	}
+        }
+    }
 
-	for (i = parser->toknext - 1; i >= 0; i--) {
-		/* Unmatched opened object or array */
-		if (tokens[i].start != -1 && tokens[i].end == -1) {
-			return JSMN_ERROR_PART;
-		}
-	}
+    for (i = parser->toknext - 1; i >= 0; i--) {
+        /* Unmatched opened object or array */
+        if (tokens[i].start != -1 && tokens[i].end == -1) {
+            return JSMN_ERROR_PART;
+        }
+    }
 
-	return count;
+    return count;
 }
 
 /**
@@ -326,9 +326,9 @@ int jsmn_parse(jsmn_parser *parser, const char *js, size_t len,
  * available.
  */
 void jsmn_init(jsmn_parser *parser) {
-	parser->pos = 0;
-	parser->toknext = 0;
-	parser->toksuper = -1;
+    parser->pos = 0;
+    parser->toknext = 0;
+    parser->toksuper = -1;
 }
 
 /*
@@ -336,10 +336,10 @@ void jsmn_init(jsmn_parser *parser) {
  *
  * Local variables:
  * c-basic-offset: 4
- * tab-width: 4
+ * tab-width: 8
  * indent-tabs-mode: nil
  * End:
  *
- * vi: set shiftwidth=4 tabstop=4 expandtab:
- * :indentSize=4:tabSize=4:noTabs=true:
+ * vi: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=8:noTabs=true:
  */
diff --git a/epan/jsmn/jsmn.h b/epan/jsmn/jsmn.h
index 9644f42380..458e7d447b 100644
--- a/epan/jsmn/jsmn.h
+++ b/epan/jsmn/jsmn.h
@@ -31,25 +31,25 @@ extern "C" {
 
 /**
  * JSON type identifier. Basic types are:
- * 	o Object
- * 	o Array
- * 	o String
- * 	o Other primitive: number, boolean (true/false) or null
+ *  o Object
+ *  o Array
+ *  o String
+ *  o Other primitive: number, boolean (true/false) or null
  */
 typedef enum {
-	JSMN_PRIMITIVE = 0,
-	JSMN_OBJECT = 1,
-	JSMN_ARRAY = 2,
-	JSMN_STRING = 3
+    JSMN_PRIMITIVE = 0,
+    JSMN_OBJECT = 1,
+    JSMN_ARRAY = 2,
+    JSMN_STRING = 3
 } jsmntype_t;
 
 typedef enum {
-	/* Not enough tokens were provided */
-	JSMN_ERROR_NOMEM = -1,
-	/* Invalid character inside JSON string */
-	JSMN_ERROR_INVAL = -2,
-	/* The string is not a full JSON packet, more bytes expected */
-	JSMN_ERROR_PART = -3
+    /* Not enough tokens were provided */
+    JSMN_ERROR_NOMEM = -1,
+    /* Invalid character inside JSON string */
+    JSMN_ERROR_INVAL = -2,
+    /* The string is not a full JSON packet, more bytes expected */
+    JSMN_ERROR_PART = -3
 } jsmnerr_t;
 
 /**
@@ -60,12 +60,12 @@ typedef enum {
  * size  the size of the token
  */
 typedef struct {
-	jsmntype_t type;
-	int start;
-	int end;
-	int size;
+    jsmntype_t type;
+    int start;
+    int end;
+    int size;
 #ifdef JSMN_PARENT_LINKS
-	int parent;
+    int parent;
 #endif
 } jsmntok_t;
 
@@ -74,9 +74,9 @@ typedef struct {
  * the string being parsed now and current position in that string
  */
 typedef struct {
-	unsigned int pos; /* offset in the JSON string */
-	unsigned int toknext; /* next token to allocate */
-	int toksuper; /* superior token node, e.g parent object or array */
+    unsigned int pos;           /* offset in the JSON string */
+    unsigned int toknext;       /* next token to allocate */
+    int          toksuper;      /* superior token node, e.g parent object or array */
 } jsmn_parser;
 
 /**
@@ -89,7 +89,7 @@ void jsmn_init(jsmn_parser *parser);
  * a single JSON object.
  */
 int jsmn_parse(jsmn_parser *parser, const char *js, size_t len,
-		jsmntok_t *tokens, unsigned int num_tokens);
+               jsmntok_t *tokens, unsigned int num_tokens);
 
 #ifdef __cplusplus
 }
@@ -102,10 +102,10 @@ int jsmn_parse(jsmn_parser *parser, const char *js, size_t len,
  *
  * Local variables:
  * c-basic-offset: 4
- * tab-width: 4
+ * tab-width: 8
  * indent-tabs-mode: nil
  * End:
  *
- * vi: set shiftwidth=4 tabstop=4 expandtab:
- * :indentSize=4:tabSize=4:noTabs=true:
+ * vi: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=9:noTabs=true:
  */
diff --git a/epan/rtp_pt.h b/epan/rtp_pt.h
index ebf30586ef..c10c344c16 100644
--- a/epan/rtp_pt.h
+++ b/epan/rtp_pt.h
@@ -35,71 +35,71 @@ extern "C" {
  * Table B.2 / H.225.0
  * Also RFC 3551, and
  *
- *	http://www.iana.org/assignments/rtp-parameters
+ *  http://www.iana.org/assignments/rtp-parameters
  */
-#define PT_PCMU			0	/* RFC 3551 */
-#define PT_1016			1	/* RFC 1890 (reserved in RFC 3551) */
-#define PT_G721			2	/* RFC 1890 (reserved in RFC 3551) */
-#define PT_GSM			3	/* RFC 3551 */
-#define PT_G723			4	/* From Vineet Kumar of Intel; see the Web page */
-#define PT_DVI4_8000	5	/* RFC 3551 */
-#define PT_DVI4_16000	6	/* RFC 3551 */
-#define PT_LPC			7	/* RFC 3551 */
-#define PT_PCMA			8	/* RFC 3551 */
-#define PT_G722			9	/* RFC 3551 */
-#define PT_L16_STEREO	10	/* RFC 3551 */
-#define PT_L16_MONO		11	/* RFC 3551 */
-#define PT_QCELP		12	/* Qualcomm Code Excited Linear Predictive coding? */
-#define PT_CN			13	/* RFC 3389 */
-#define PT_MPA			14	/* RFC 3551, RFC 2250 */
-#define PT_G728			15	/* RFC 3551 */
-#define PT_DVI4_11025	16	/* from Joseph Di Pol of Sun; see the Web page */
-#define PT_DVI4_22050	17	/* from Joseph Di Pol of Sun; see the Web page */
-#define PT_G729			18
-#define PT_CN_OLD		19	/* Payload type reserved (old version Comfort Noise) */
-#define PT_CELB			25	/* RFC 2029 */
-#define PT_JPEG			26	/* RFC 2435 */
-#define PT_NV			28	/* RFC 1890 */
-#define PT_H261			31	/* RFC 2032 */
-#define PT_MPV			32	/* RFC 2250 */
-#define PT_MP2T			33	/* RFC 2250 */
-#define PT_H263			34	/* from Chunrong Zhu of Intel; see the Web page */
+#define PT_PCMU           0  /* RFC 3551 */
+#define PT_1016           1  /* RFC 1890 (reserved in RFC 3551) */
+#define PT_G721           2  /* RFC 1890 (reserved in RFC 3551) */
+#define PT_GSM            3  /* RFC 3551 */
+#define PT_G723           4  /* From Vineet Kumar of Intel; see the Web page */
+#define PT_DVI4_8000      5  /* RFC 3551 */
+#define PT_DVI4_16000     6  /* RFC 3551 */
+#define PT_LPC            7  /* RFC 3551 */
+#define PT_PCMA           8  /* RFC 3551 */
+#define PT_G722           9  /* RFC 3551 */
+#define PT_L16_STEREO    10  /* RFC 3551 */
+#define PT_L16_MONO      11  /* RFC 3551 */
+#define PT_QCELP         12  /* Qualcomm Code Excited Linear Predictive coding? */
+#define PT_CN            13  /* RFC 3389 */
+#define PT_MPA           14  /* RFC 3551, RFC 2250 */
+#define PT_G728          15  /* RFC 3551 */
+#define PT_DVI4_11025    16  /* from Joseph Di Pol of Sun; see the Web page */
+#define PT_DVI4_22050    17  /* from Joseph Di Pol of Sun; see the Web page */
+#define PT_G729          18
+#define PT_CN_OLD        19  /* Payload type reserved (old version Comfort Noise) */
+#define PT_CELB          25  /* RFC 2029 */
+#define PT_JPEG          26  /* RFC 2435 */
+#define PT_NV            28  /* RFC 1890 */
+#define PT_H261          31  /* RFC 2032 */
+#define PT_MPV           32  /* RFC 2250 */
+#define PT_MP2T          33  /* RFC 2250 */
+#define PT_H263          34  /* from Chunrong Zhu of Intel; see the Web page */
 
 /* Added to by Alex Lindberg to cover port ranges 96-127 - Dynamic RTP
    Some of these ports are used by Avaya for Modem and FAX support */
 
-#define PT_UNDF_96		96  /* RFC 3551 */
-#define PT_UNDF_97		97
-#define PT_UNDF_98		98
-#define PT_UNDF_99		99
-#define PT_UNDF_100		100
-#define PT_UNDF_101		101
-#define PT_UNDF_102		102
-#define PT_UNDF_103		103
-#define PT_UNDF_104		104
-#define PT_UNDF_105		105
-#define PT_UNDF_106		106
-#define PT_UNDF_107		107
-#define PT_UNDF_108		108
-#define PT_UNDF_109		109
-#define PT_UNDF_110		110
-#define PT_UNDF_111		111
-#define PT_UNDF_112		112
-#define PT_UNDF_113		113
-#define PT_UNDF_114		114
-#define PT_UNDF_115		115
-#define PT_UNDF_116		116
-#define PT_UNDF_117		117
-#define PT_UNDF_118		118
-#define PT_UNDF_119		119
-#define PT_UNDF_120		120
-#define PT_UNDF_121		121
-#define PT_UNDF_122		122
-#define PT_UNDF_123		123
-#define PT_UNDF_124		124
-#define PT_UNDF_125		125
-#define PT_UNDF_126		126
-#define PT_UNDF_127		127
+#define PT_UNDF_96       96  /* RFC 3551 */
+#define PT_UNDF_97       97
+#define PT_UNDF_98       98
+#define PT_UNDF_99       99
+#define PT_UNDF_100     100
+#define PT_UNDF_101     101
+#define PT_UNDF_102     102
+#define PT_UNDF_103     103
+#define PT_UNDF_104     104
+#define PT_UNDF_105     105
+#define PT_UNDF_106     106
+#define PT_UNDF_107     107
+#define PT_UNDF_108     108
+#define PT_UNDF_109     109
+#define PT_UNDF_110     110
+#define PT_UNDF_111     111
+#define PT_UNDF_112     112
+#define PT_UNDF_113     113
+#define PT_UNDF_114     114
+#define PT_UNDF_115     115
+#define PT_UNDF_116     116
+#define PT_UNDF_117     117
+#define PT_UNDF_118     118
+#define PT_UNDF_119     119
+#define PT_UNDF_120     120
+#define PT_UNDF_121     121
+#define PT_UNDF_122     122
+#define PT_UNDF_123     123
+#define PT_UNDF_124     124
+#define PT_UNDF_125     125
+#define PT_UNDF_126     126
+#define PT_UNDF_127     127
 
 WS_DLL_PUBLIC value_string_ext rtp_payload_type_vals_ext;
 WS_DLL_PUBLIC value_string_ext rtp_payload_type_short_vals_ext;
diff --git a/epan/stat_tap_ui.h b/epan/stat_tap_ui.h
index 3fee0fd6a5..359cf4bf9a 100644
--- a/epan/stat_tap_ui.h
+++ b/epan/stat_tap_ui.h
@@ -37,32 +37,32 @@ extern "C" {
 #include <epan/stat_groups.h>
 
 typedef enum {
-	PARAM_UINT,
-	PARAM_STRING,
-	PARAM_ENUM,
-	PARAM_UUID,
-	PARAM_FILTER
+    PARAM_UINT,
+    PARAM_STRING,
+    PARAM_ENUM,
+    PARAM_UUID,
+    PARAM_FILTER
 } param_type;
 
 typedef struct _tap_param {
-	param_type type;		/* type of parameter */
-	const char *name;		/* name to use in error messages */
-	const char *title;		/* title to use in GUI widgets */
-	const enum_val_t *enum_vals;	/* values for PARAM_ENUM */
-	gboolean optional;		/* TRUE if the parameter is optional */
+    param_type        type;      /* type of parameter */
+    const char       *name;      /* name to use in error messages */
+    const char       *title;     /* title to use in GUI widgets */
+    const enum_val_t *enum_vals; /* values for PARAM_ENUM */
+    gboolean          optional;  /* TRUE if the parameter is optional */
 } tap_param;
 
 /*
  * UI information for a tap.
  */
 typedef struct _stat_tap_ui {
-	register_stat_group_t group;	/* group to which statistic belongs */
-	const char *title;		/* title of statistic */
-	const char *cli_string;		/* initial part of the "-z" argument for statistic */
-	void (* tap_init_cb)(const char *,void*);	/* callback to init function of the tap */
-	gint index;			/* initiate this value always with "-1" */
-	size_t nparams;			/* number of parameters */
-	tap_param *params;		/* pointer to table of parameter info */
+    register_stat_group_t  group;      /* group to which statistic belongs */
+    const char            *title;      /* title of statistic */
+    const char            *cli_string; /* initial part of the "-z" argument for statistic */
+    void (* tap_init_cb)(const char *, void*); /* callback to init function of the tap */
+    gint                   index;      /* initiate this value always with "-1" */
+    size_t                 nparams;    /* number of parameters */
+    tap_param             *params;     /* pointer to table of parameter info */
 } stat_tap_ui;
 
 /** Register UI information for a tap.
diff --git a/epan/wslua/wslua_util.c b/epan/wslua/wslua_util.c
index ec0a4e3784..2b53d9f91e 100644
--- a/epan/wslua/wslua_util.c
+++ b/epan/wslua/wslua_util.c
@@ -271,7 +271,7 @@ WSLUA_FUNCTION wslua_register_stat_cmd_arg(lua_State* L) {
     sc->func_ref = luaL_ref(L, LUA_REGISTRYINDEX);
     lua_remove(L,1);
 
-    ui_info.group = REGISTER_STAT_GROUP_UNSORTED;	/* XXX - need group for CLI-only? */
+    ui_info.group = REGISTER_STAT_GROUP_UNSORTED;  /* XXX - need group for CLI-only? */
     ui_info.title = NULL;
     ui_info.cli_string = arg;
     ui_info.tap_init_cb = statcmd_init;