/* packet-isup.c
 * Routines for ISUP dissection
 * Copyright 2001, Martina Obermeier <martina.obermeier@icn.siemens.de>
 *
 * Modified 2003-09-10 by Anders Broman
 *          <anders.broman@ericsson.com>
 * Inserted routines for BICC dissection according to Q.765.5 Q.1902 Q.1970 Q.1990,
 * calling SDP dissector for RFC2327 decoding.
 * Modified 2004-01-10 by Anders Broman to add ability to dissect
 * Content type application/ISUP RFC 3204 used in SIP-T
 *
 * Copyright 2004-2005, Anders Broman <anders.broman@ericsson.com>
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * Copied from README.developer
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 * References:
 * ISUP:
 * http://www.itu.int/rec/recommendation.asp?type=products&lang=e&parent=T-REC-Q
 * Q.763-199912, Q.763-200212Amd2
 * ITU-T Q.763/Amd.1 (03/2001)
 *
 * National variants
 * French ISUP Specification: SPIROU 1998 - 002-005 edition 1 ( Info found here http://www.icg-corp.com/docs/ISUP.pdf ).
 *   See also http://www.fftelecoms.org/sites/default/files/contenus_lies/fft_interco_ip_-_sip-i_interface_specification_v1_0.pdf
 * Israeli ISUP Specification: excertp (for BCM message) found in https://gitlab.com/wireshark/wireshark/-/issues/4231 .
 * Russian national ISUP-R 2000: RD 45.217-2001 book 4
 * Japan ISUP http://www.ttc.or.jp/jp/document_list/sum/sum_JT-Q763v21.1.pdf
 */

#include "config.h"

#include <epan/packet.h>
#include <epan/expert.h>
#include <epan/exceptions.h>
#include <epan/conversation.h>
#include <epan/stats_tree.h>
#include <epan/asn1.h>
#include <epan/prefs.h>
#include <epan/sctpppids.h>
#include <epan/osi-utils.h>
#include <epan/reassemble.h>
#include <epan/to_str.h>
#include <epan/media_params.h>
#include <epan/tfs.h>
#include <epan/unit_strings.h>

#include <wsutil/array.h>
#include "packet-q931.h"
#include "packet-isup.h"
#include "packet-e164.h"
#include "packet-charging_ase.h"
#include "packet-mtp3.h"
#include "packet-media-type.h"

void proto_register_isup(void);
void proto_reg_handoff_isup(void);
void proto_register_bicc(void);
void proto_reg_handoff_bicc(void);

static dissector_handle_t isup_handle;

#define ISUP_ITU_STANDARD_VARIANT 0
#define ISUP_FRENCH_VARIANT       1
#define ISUP_ISRAELI_VARIANT      2
#define ISUP_RUSSIAN_VARIANT      3
#define ISUP_JAPAN_VARIANT        4
#define ISUP_JAPAN_TTC_VARIANT    5

static int isup_standard = ITU_STANDARD;
/* Preference standard or national ISUP variants */
static int g_isup_variant = ISUP_ITU_STANDARD_VARIANT;

#define ASCII_NUMBER_DELTA              0x30
#define ASCII_LETTER_DELTA              0x37

/* Definition of protocol field values und lengths */

/* Definition of Message Types */
#define MESSAGE_TYPE_INITIAL_ADDR        1
#define MESSAGE_TYPE_SUBSEQ_ADDR         2
#define MESSAGE_TYPE_INFO_REQ            3
#define MESSAGE_TYPE_INFO                4
#define MESSAGE_TYPE_CONTINUITY          5
#define MESSAGE_TYPE_ADDR_CMPL           6
#define MESSAGE_TYPE_CONNECT             7
#define MESSAGE_TYPE_FORW_TRANS          8
#define MESSAGE_TYPE_ANSWER              9
#define MESSAGE_TYPE_RELEASE            12
#define MESSAGE_TYPE_SUSPEND            13
#define MESSAGE_TYPE_RESUME             14
#define MESSAGE_TYPE_REL_CMPL           16
#define MESSAGE_TYPE_CONT_CHECK_REQ     17
#define MESSAGE_TYPE_RESET_CIRCUIT      18
#define MESSAGE_TYPE_BLOCKING           19
#define MESSAGE_TYPE_UNBLOCKING         20
#define MESSAGE_TYPE_BLOCK_ACK          21
#define MESSAGE_TYPE_UNBLOCK_ACK        22
#define MESSAGE_TYPE_CIRC_GRP_RST       23
#define MESSAGE_TYPE_CIRC_GRP_BLCK      24
#define MESSAGE_TYPE_CIRC_GRP_UNBL      25
#define MESSAGE_TYPE_CIRC_GRP_BL_ACK    26
#define MESSAGE_TYPE_CIRC_GRP_UNBL_ACK  27
#define MESSAGE_TYPE_FACILITY_REQ       31
#define MESSAGE_TYPE_FACILITY_ACC       32
#define MESSAGE_TYPE_FACILITY_REJ       33
#define MESSAGE_TYPE_LOOP_BACK_ACK      36
#define MESSAGE_TYPE_PASS_ALONG         40
#define MESSAGE_TYPE_CIRC_GRP_RST_ACK   41
#define MESSAGE_TYPE_CIRC_GRP_QRY       42
#define MESSAGE_TYPE_CIRC_GRP_QRY_RSP   43
#define MESSAGE_TYPE_CALL_PROGRSS       44
#define MESSAGE_TYPE_USER2USER_INFO     45
#define MESSAGE_TYPE_UNEQUIPPED_CIC     46
#define MESSAGE_TYPE_CONFUSION          47
#define MESSAGE_TYPE_OVERLOAD           48
#define MESSAGE_TYPE_CHARGE_INFO        49
#define MESSAGE_TYPE_NETW_RESRC_MGMT    50
#define MESSAGE_TYPE_FACILITY           51
#define MESSAGE_TYPE_USER_PART_TEST     52
#define MESSAGE_TYPE_USER_PART_AVAIL    53
#define MESSAGE_TYPE_IDENT_REQ          54
#define MESSAGE_TYPE_IDENT_RSP          55
#define MESSAGE_TYPE_SEGMENTATION       56
#define MESSAGE_TYPE_LOOP_PREVENTION    64
#define MESSAGE_TYPE_APPLICATION_TRANS  65
#define MESSAGE_TYPE_PRE_RELEASE_INFO   66
#define MESSAGE_TYPE_SUBSEQUENT_DIR_NUM 67

#define ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES_ACK  0xE9
#define ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES      0xEA
#define ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST_RSP 0xEB
#define ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST     0xEC
#define ANSI_ISUP_MESSAGE_TYPE_EXIT             0xED

static const value_string isup_message_type_value[] = {
  { MESSAGE_TYPE_INITIAL_ADDR,                "Initial address"},
  { MESSAGE_TYPE_SUBSEQ_ADDR,                 "Subsequent address"},
  { MESSAGE_TYPE_INFO_REQ,                    "Information request (national use)"},
  { MESSAGE_TYPE_INFO,                        "Information (national use)"},
  { MESSAGE_TYPE_CONTINUITY,                  "Continuity"},
  { MESSAGE_TYPE_ADDR_CMPL,                   "Address complete"},
  { MESSAGE_TYPE_CONNECT,                     "Connect"},
  { MESSAGE_TYPE_FORW_TRANS,                  "Forward transfer"},
  { MESSAGE_TYPE_ANSWER,                      "Answer"},

  { 10,                                       "Reserved (used in 1984 version)"},
  { 11,                                       "Reserved (used in 1984 version)"},

  { MESSAGE_TYPE_RELEASE,                     "Release"},
  { MESSAGE_TYPE_SUSPEND,                     "Suspend"},
  { MESSAGE_TYPE_RESUME,                      "Resume"},

  { 15,                                       "Reserved"},

  { MESSAGE_TYPE_REL_CMPL,                    "Release complete"},
  { MESSAGE_TYPE_CONT_CHECK_REQ,              "Continuity check request"},
  { MESSAGE_TYPE_RESET_CIRCUIT,               "Reset Circuit"},
  { MESSAGE_TYPE_BLOCKING,                    "Blocking"},
  { MESSAGE_TYPE_UNBLOCKING,                  "Unblocking"},
  { MESSAGE_TYPE_BLOCK_ACK,                   "Blocking acknowledgement"},
  { MESSAGE_TYPE_UNBLOCK_ACK,                 "Unblocking acknowledgment"},
  { MESSAGE_TYPE_CIRC_GRP_RST,                "Circuit group reset"},
  { MESSAGE_TYPE_CIRC_GRP_BLCK,               "Circuit group blocking"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL,               "Circuit group unblocking"},
  { MESSAGE_TYPE_CIRC_GRP_BL_ACK,             "Circuit group blocking acknowledgement"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK,           "Circuit group unblocking acknowledgement"},

  { 28,                                       "Reserved (used in 1988 version)"},
  { 29,                                       "Reserved (used in 1988 version)"},
  { 30,                                       "Reserved (used in 1988 version)"},

  { MESSAGE_TYPE_FACILITY_REQ,                "Facility request"},
  { MESSAGE_TYPE_FACILITY_ACC,                "Facility accepted"},
  { MESSAGE_TYPE_FACILITY_REJ,                "Facility reject"},

  { 34,                                       "Reserved (used in 1984 version)"},
  { 35,                                       "Reserved (used in 1984 version)"},

  { MESSAGE_TYPE_LOOP_BACK_ACK,               "Loop back acknowledgement (national use)"},

  { 37,                                       "Reserved (used in 1984 version)"},
  { 38,                                       "Reserved (used in 1984 version)"},
  { 39,                                       "Reserved (used in 1984 version)"},

  { MESSAGE_TYPE_PASS_ALONG,                  "Pass-along (national use)"},
  { MESSAGE_TYPE_CIRC_GRP_RST_ACK,            "Circuit group reset acknowledgement"},
  { MESSAGE_TYPE_CIRC_GRP_QRY,                "Circuit group query (national use)"},
  { MESSAGE_TYPE_CIRC_GRP_QRY_RSP,            "Circuit group query response (national use)"},
  { MESSAGE_TYPE_CALL_PROGRSS,                "Call progress"},
  { MESSAGE_TYPE_USER2USER_INFO,              "User-to-user information"},
  { MESSAGE_TYPE_UNEQUIPPED_CIC,              "Unequipped CIC (national use)"},
  { MESSAGE_TYPE_CONFUSION,                   "Confusion"},
  { MESSAGE_TYPE_OVERLOAD,                    "Overload (national use)"},
  { MESSAGE_TYPE_CHARGE_INFO,                 "Charge information (national use)"},
  { MESSAGE_TYPE_NETW_RESRC_MGMT,             "Network resource management"},
  { MESSAGE_TYPE_FACILITY,                    "Facility"},
  { MESSAGE_TYPE_USER_PART_TEST,              "User part test"},
  { MESSAGE_TYPE_USER_PART_AVAIL,             "User part available"},
  { MESSAGE_TYPE_IDENT_REQ,                   "Identification request"},
  { MESSAGE_TYPE_IDENT_RSP,                   "Identification response"},
  { MESSAGE_TYPE_SEGMENTATION,                "Segmentation"},

  { 57,                                       "Reserved (used in B-ISUP)"},
  { 58,                                       "Reserved (used in B-ISUP)"},
  { 59,                                       "Reserved (used in B-ISUP)"},
  { 60,                                       "Reserved (used in B-ISUP)"},
  { 61,                                       "Reserved (used in B-ISUP)"},

  { 62,                                       "Unknown"},
  { 63,                                       "Unknown"},

  { MESSAGE_TYPE_LOOP_PREVENTION,             "Loop prevention"},
  { MESSAGE_TYPE_APPLICATION_TRANS,           "Application transport"},
  { MESSAGE_TYPE_PRE_RELEASE_INFO,            "Pre-release information"},
  { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM,          "Subsequent Directory Number (national use)"},
  { 0,                                  NULL}};
static value_string_ext isup_message_type_value_ext = VALUE_STRING_EXT_INIT(isup_message_type_value);

#define FRENCH_CHARGING_PULSE 0xe1
#define FRENCH_CHARGING_ACK 0xe2
static const value_string french_isup_message_type_value[] = {
  { MESSAGE_TYPE_INITIAL_ADDR,                "Initial address"},
  { MESSAGE_TYPE_SUBSEQ_ADDR,                 "Subsequent address"},
  { MESSAGE_TYPE_INFO_REQ,                    "Information request (national use)"},
  { MESSAGE_TYPE_INFO,                        "Information (national use)"},
  { MESSAGE_TYPE_CONTINUITY,                  "Continuity"},
  { MESSAGE_TYPE_ADDR_CMPL,                   "Address complete"},
  { MESSAGE_TYPE_CONNECT,                     "Connect"},
  { MESSAGE_TYPE_FORW_TRANS,                  "Forward transfer"},
  { MESSAGE_TYPE_ANSWER,                      "Answer"},

  { 10,                                       "Reserved (used in 1984 version)"},
  { 11,                                       "Reserved (used in 1984 version)"},

  { MESSAGE_TYPE_RELEASE,                     "Release"},
  { MESSAGE_TYPE_SUSPEND,                     "Suspend"},
  { MESSAGE_TYPE_RESUME,                      "Resume"},

  { 15,                                       "Reserved"},

  { MESSAGE_TYPE_REL_CMPL,                    "Release complete"},
  { MESSAGE_TYPE_CONT_CHECK_REQ,              "Continuity check request"},
  { MESSAGE_TYPE_RESET_CIRCUIT,               "Reset Circuit"},
  { MESSAGE_TYPE_BLOCKING,                    "Blocking"},
  { MESSAGE_TYPE_UNBLOCKING,                  "Unblocking"},
  { MESSAGE_TYPE_BLOCK_ACK,                   "Blocking acknowledgement"},
  { MESSAGE_TYPE_UNBLOCK_ACK,                 "Unblocking acknowledgment"},
  { MESSAGE_TYPE_CIRC_GRP_RST,                "Circuit group reset"},
  { MESSAGE_TYPE_CIRC_GRP_BLCK,               "Circuit group blocking"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL,               "Circuit group unblocking"},
  { MESSAGE_TYPE_CIRC_GRP_BL_ACK,             "Circuit group blocking acknowledgement"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK,           "Circuit group unblocking acknowledgement"},

  { 28,                                       "Reserved (used in 1988 version)"},
  { 29,                                       "Reserved (used in 1988 version)"},
  { 30,                                       "Reserved (used in 1988 version)"},

  { MESSAGE_TYPE_FACILITY_REQ,                "Facility request"},
  { MESSAGE_TYPE_FACILITY_ACC,                "Facility accepted"},
  { MESSAGE_TYPE_FACILITY_REJ,                "Facility reject"},

  { 34,                                       "Reserved (used in 1984 version)"},
  { 35,                                       "Reserved (used in 1984 version)"},

  { MESSAGE_TYPE_LOOP_BACK_ACK,               "Loop back acknowledgement (national use)"},

  { 37,                                       "Reserved (used in 1984 version)"},
  { 38,                                       "Reserved (used in 1984 version)"},
  { 39,                                       "Reserved (used in 1984 version)"},

  { MESSAGE_TYPE_PASS_ALONG,                  "Pass-along (national use)"},
  { MESSAGE_TYPE_CIRC_GRP_RST_ACK,            "Circuit group reset acknowledgement"},
  { MESSAGE_TYPE_CIRC_GRP_QRY,                "Circuit group query (national use)"},
  { MESSAGE_TYPE_CIRC_GRP_QRY_RSP,            "Circuit group query response (national use)"},
  { MESSAGE_TYPE_CALL_PROGRSS,                "Call progress"},
  { MESSAGE_TYPE_USER2USER_INFO,              "User-to-user information"},
  { MESSAGE_TYPE_UNEQUIPPED_CIC,              "Unequipped CIC (national use)"},
  { MESSAGE_TYPE_CONFUSION,                   "Confusion"},
  { MESSAGE_TYPE_OVERLOAD,                    "Overload (national use)"},
  { MESSAGE_TYPE_CHARGE_INFO,                 "Charge information (national use)"},
  { MESSAGE_TYPE_NETW_RESRC_MGMT,             "Network resource management"},
  { MESSAGE_TYPE_FACILITY,                    "Facility"},
  { MESSAGE_TYPE_USER_PART_TEST,              "User part test"},
  { MESSAGE_TYPE_USER_PART_AVAIL,             "User part available"},
  { MESSAGE_TYPE_IDENT_REQ,                   "Identification request"},
  { MESSAGE_TYPE_IDENT_RSP,                   "Identification response"},
  { MESSAGE_TYPE_SEGMENTATION,                "Segmentation"},

  { 57,                                       "Reserved (used in B-ISUP)"},
  { 58,                                       "Reserved (used in B-ISUP)"},
  { 59,                                       "Reserved (used in B-ISUP)"},
  { 60,                                       "Reserved (used in B-ISUP)"},
  { 61,                                       "Reserved (used in B-ISUP)"},

  { 62,                                       "Unknown"},
  { 63,                                       "Unknown"},

  { MESSAGE_TYPE_LOOP_PREVENTION,             "Loop prevention"},
  { MESSAGE_TYPE_APPLICATION_TRANS,           "Application transport"},
  { MESSAGE_TYPE_PRE_RELEASE_INFO,            "Pre-release information"},
  { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM,          "Subsequent Directory Number (national use)"},
  { FRENCH_CHARGING_PULSE,                    "Charging Pulse"},
  { FRENCH_CHARGING_ACK,                      "Charging Acknowledge"},
  { 0,                                  NULL}};
static value_string_ext french_isup_message_type_value_ext = VALUE_STRING_EXT_INIT(french_isup_message_type_value);

#define ISRAELI_BACKWARD_CHARGING 232
#define ISRAELI_TRAFFIC_CHANGE 233
#define ISRAELI_CHARGE_ACK 234
static const value_string israeli_isup_message_type_value[] = {
  { MESSAGE_TYPE_INITIAL_ADDR,                "Initial address"},
  { MESSAGE_TYPE_SUBSEQ_ADDR,                 "Subsequent address"},
  { MESSAGE_TYPE_INFO_REQ,                    "Information request (national use)"},
  { MESSAGE_TYPE_INFO,                        "Information (national use)"},
  { MESSAGE_TYPE_CONTINUITY,                  "Continuity"},
  { MESSAGE_TYPE_ADDR_CMPL,                   "Address complete"},
  { MESSAGE_TYPE_CONNECT,                     "Connect"},
  { MESSAGE_TYPE_FORW_TRANS,                  "Forward transfer"},
  { MESSAGE_TYPE_ANSWER,                      "Answer"},

  { 10,                                       "Reserved (used in 1984 version)"},
  { 11,                                       "Reserved (used in 1984 version)"},

  { MESSAGE_TYPE_RELEASE,                     "Release"},
  { MESSAGE_TYPE_SUSPEND,                     "Suspend"},
  { MESSAGE_TYPE_RESUME,                      "Resume"},

  { 15,                                       "Reserved"},

  { MESSAGE_TYPE_REL_CMPL,                    "Release complete"},
  { MESSAGE_TYPE_CONT_CHECK_REQ,              "Continuity check request"},
  { MESSAGE_TYPE_RESET_CIRCUIT,               "Reset Circuit"},
  { MESSAGE_TYPE_BLOCKING,                    "Blocking"},
  { MESSAGE_TYPE_UNBLOCKING,                  "Unblocking"},
  { MESSAGE_TYPE_BLOCK_ACK,                   "Blocking acknowledgement"},
  { MESSAGE_TYPE_UNBLOCK_ACK,                 "Unblocking acknowledgment"},
  { MESSAGE_TYPE_CIRC_GRP_RST,                "Circuit group reset"},
  { MESSAGE_TYPE_CIRC_GRP_BLCK,               "Circuit group blocking"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL,               "Circuit group unblocking"},
  { MESSAGE_TYPE_CIRC_GRP_BL_ACK,             "Circuit group blocking acknowledgement"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK,           "Circuit group unblocking acknowledgement"},

  { 28,                                       "Reserved (used in 1988 version)"},
  { 29,                                       "Reserved (used in 1988 version)"},
  { 30,                                       "Reserved (used in 1988 version)"},

  { MESSAGE_TYPE_FACILITY_REQ,                "Facility request"},
  { MESSAGE_TYPE_FACILITY_ACC,                "Facility accepted"},
  { MESSAGE_TYPE_FACILITY_REJ,                "Facility reject"},

  { 34,                                       "Reserved (used in 1984 version)"},
  { 35,                                       "Reserved (used in 1984 version)"},

  { MESSAGE_TYPE_LOOP_BACK_ACK,               "Loop back acknowledgement (national use)"},

  { 37,                                       "Reserved (used in 1984 version)"},
  { 38,                                       "Reserved (used in 1984 version)"},
  { 39,                                       "Reserved (used in 1984 version)"},

  { MESSAGE_TYPE_PASS_ALONG,                  "Pass-along (national use)"},
  { MESSAGE_TYPE_CIRC_GRP_RST_ACK,            "Circuit group reset acknowledgement"},
  { MESSAGE_TYPE_CIRC_GRP_QRY,                "Circuit group query (national use)"},
  { MESSAGE_TYPE_CIRC_GRP_QRY_RSP,            "Circuit group query response (national use)"},
  { MESSAGE_TYPE_CALL_PROGRSS,                "Call progress"},
  { MESSAGE_TYPE_USER2USER_INFO,              "User-to-user information"},
  { MESSAGE_TYPE_UNEQUIPPED_CIC,              "Unequipped CIC (national use)"},
  { MESSAGE_TYPE_CONFUSION,                   "Confusion"},
  { MESSAGE_TYPE_OVERLOAD,                    "Overload (national use)"},
  { MESSAGE_TYPE_CHARGE_INFO,                 "Charge information (national use)"},
  { MESSAGE_TYPE_NETW_RESRC_MGMT,             "Network resource management"},
  { MESSAGE_TYPE_FACILITY,                    "Facility"},
  { MESSAGE_TYPE_USER_PART_TEST,              "User part test"},
  { MESSAGE_TYPE_USER_PART_AVAIL,             "User part available"},
  { MESSAGE_TYPE_IDENT_REQ,                   "Identification request"},
  { MESSAGE_TYPE_IDENT_RSP,                   "Identification response"},
  { MESSAGE_TYPE_SEGMENTATION,                "Segmentation"},

  { 57,                                       "Reserved (used in B-ISUP)"},
  { 58,                                       "Reserved (used in B-ISUP)"},
  { 59,                                       "Reserved (used in B-ISUP)"},
  { 60,                                       "Reserved (used in B-ISUP)"},
  { 61,                                       "Reserved (used in B-ISUP)"},

  { 62,                                       "Unknown"},
  { 63,                                       "Unknown"},

  { MESSAGE_TYPE_LOOP_PREVENTION,             "Loop prevention"},
  { MESSAGE_TYPE_APPLICATION_TRANS,           "Application transport"},
  { MESSAGE_TYPE_PRE_RELEASE_INFO,            "Pre-release information"},
  { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM,          "Subsequent Directory Number (national use)"},
  { ISRAELI_BACKWARD_CHARGING,                 "Backward Charging"},
  { ISRAELI_TRAFFIC_CHANGE,                    "Traffic Change"},
  { ISRAELI_CHARGE_ACK,                        "Charge Ack"},
  { 0,                                  NULL}};
static value_string_ext israeli_isup_message_type_value_ext = VALUE_STRING_EXT_INIT(israeli_isup_message_type_value);

#define RUSSIAN_CLEAR_CALLING_LINE 252
#define RUSSIAN_RINGING            255

static const value_string russian_isup_message_type_value[] = {
  { MESSAGE_TYPE_INITIAL_ADDR,                "Initial address"},
  { MESSAGE_TYPE_SUBSEQ_ADDR,                 "Subsequent address"},
  { MESSAGE_TYPE_INFO_REQ,                    "Information request (national use)"},
  { MESSAGE_TYPE_INFO,                        "Information (national use)"},
  { MESSAGE_TYPE_CONTINUITY,                  "Continuity"},
  { MESSAGE_TYPE_ADDR_CMPL,                   "Address complete"},
  { MESSAGE_TYPE_CONNECT,                     "Connect"},
  { MESSAGE_TYPE_FORW_TRANS,                  "Forward transfer"},
  { MESSAGE_TYPE_ANSWER,                      "Answer"},

  { 10,                                       "Reserved (used in 1984 version)"},
  { 11,                                       "Reserved (used in 1984 version)"},

  { MESSAGE_TYPE_RELEASE,                     "Release"},
  { MESSAGE_TYPE_SUSPEND,                     "Suspend"},
  { MESSAGE_TYPE_RESUME,                      "Resume"},

  { 15,                                       "Reserved"},

  { MESSAGE_TYPE_REL_CMPL,                    "Release complete"},
  { MESSAGE_TYPE_CONT_CHECK_REQ,              "Continuity check request"},
  { MESSAGE_TYPE_RESET_CIRCUIT,               "Reset Circuit"},
  { MESSAGE_TYPE_BLOCKING,                    "Blocking"},
  { MESSAGE_TYPE_UNBLOCKING,                  "Unblocking"},
  { MESSAGE_TYPE_BLOCK_ACK,                   "Blocking acknowledgement"},
  { MESSAGE_TYPE_UNBLOCK_ACK,                 "Unblocking acknowledgment"},
  { MESSAGE_TYPE_CIRC_GRP_RST,                "Circuit group reset"},
  { MESSAGE_TYPE_CIRC_GRP_BLCK,               "Circuit group blocking"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL,               "Circuit group unblocking"},
  { MESSAGE_TYPE_CIRC_GRP_BL_ACK,             "Circuit group blocking acknowledgement"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK,           "Circuit group unblocking acknowledgement"},

  { 28,                                       "Reserved (used in 1988 version)"},
  { 29,                                       "Reserved (used in 1988 version)"},
  { 30,                                       "Reserved (used in 1988 version)"},

  { MESSAGE_TYPE_FACILITY_REQ,                "Facility request"},
  { MESSAGE_TYPE_FACILITY_ACC,                "Facility accepted"},
  { MESSAGE_TYPE_FACILITY_REJ,                "Facility reject"},

  { 34,                                       "Reserved (used in 1984 version)"},
  { 35,                                       "Reserved (used in 1984 version)"},

  { MESSAGE_TYPE_LOOP_BACK_ACK,               "Loop back acknowledgement (national use)"},

  { 37,                                       "Reserved (used in 1984 version)"},
  { 38,                                       "Reserved (used in 1984 version)"},
  { 39,                                       "Reserved (used in 1984 version)"},

  { MESSAGE_TYPE_PASS_ALONG,                  "Pass-along (national use)"},
  { MESSAGE_TYPE_CIRC_GRP_RST_ACK,            "Circuit group reset acknowledgement"},
  { MESSAGE_TYPE_CIRC_GRP_QRY,                "Circuit group query (national use)"},
  { MESSAGE_TYPE_CIRC_GRP_QRY_RSP,            "Circuit group query response (national use)"},
  { MESSAGE_TYPE_CALL_PROGRSS,                "Call progress"},
  { MESSAGE_TYPE_USER2USER_INFO,              "User-to-user information"},
  { MESSAGE_TYPE_UNEQUIPPED_CIC,              "Unequipped CIC (national use)"},
  { MESSAGE_TYPE_CONFUSION,                   "Confusion"},
  { MESSAGE_TYPE_OVERLOAD,                    "Overload (national use)"},
  { MESSAGE_TYPE_CHARGE_INFO,                 "Charge information (national use)"},
  { MESSAGE_TYPE_NETW_RESRC_MGMT,             "Network resource management"},
  { MESSAGE_TYPE_FACILITY,                    "Facility"},
  { MESSAGE_TYPE_USER_PART_TEST,              "User part test"},
  { MESSAGE_TYPE_USER_PART_AVAIL,             "User part available"},
  { MESSAGE_TYPE_IDENT_REQ,                   "Identification request"},
  { MESSAGE_TYPE_IDENT_RSP,                   "Identification response"},
  { MESSAGE_TYPE_SEGMENTATION,                "Segmentation"},

  { 57,                                       "Reserved (used in B-ISUP)"},
  { 58,                                       "Reserved (used in B-ISUP)"},
  { 59,                                       "Reserved (used in B-ISUP)"},
  { 60,                                       "Reserved (used in B-ISUP)"},
  { 61,                                       "Reserved (used in B-ISUP)"},

  { 62,                                       "Unknown"},
  { 63,                                       "Unknown"},

  { MESSAGE_TYPE_LOOP_PREVENTION,             "Loop prevention"},
  { MESSAGE_TYPE_APPLICATION_TRANS,           "Application transport"},
  { MESSAGE_TYPE_PRE_RELEASE_INFO,            "Pre-release information"},
  { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM,          "Subsequent Directory Number (national use)"},
  { RUSSIAN_CLEAR_CALLING_LINE,               "Clear Calling Line"}, /* 252 */
  { RUSSIAN_RINGING,                          "Ringing"},            /* 255 */

  { 0,                                  NULL}};
static value_string_ext russian_isup_message_type_value_ext = VALUE_STRING_EXT_INIT(russian_isup_message_type_value);

/* http://www.ttc.or.jp/jp/document_list/sum/sum_JT-Q763v21.1.pdf */
#define MESSAGE_TYPE_JAPAN_CHARG_INF 254
static const value_string japan_isup_message_type_value[] = {
  { MESSAGE_TYPE_INITIAL_ADDR,                "Initial address"},
  { MESSAGE_TYPE_SUBSEQ_ADDR,                 "Subsequent address"},
  { MESSAGE_TYPE_INFO_REQ,                    "Information request (national use)"},
  { MESSAGE_TYPE_INFO,                        "Information (national use)"},
  { MESSAGE_TYPE_CONTINUITY,                  "Continuity"},
  { MESSAGE_TYPE_ADDR_CMPL,                   "Address complete"},
  { MESSAGE_TYPE_CONNECT,                     "Connect"},
  { MESSAGE_TYPE_FORW_TRANS,                  "Forward transfer"},
  { MESSAGE_TYPE_ANSWER,                      "Answer"},

  { 0x0a,                                     "Reserved (used in 1984 version)"},
  { 0x0b,                                     "Reserved (used in 1984 version)"},

  { MESSAGE_TYPE_RELEASE,                     "Release"},
  { MESSAGE_TYPE_SUSPEND,                     "Suspend"},
  { MESSAGE_TYPE_RESUME,                      "Resume"},

  { 15,                                       "Reserved"},

  { MESSAGE_TYPE_REL_CMPL,                    "Release complete"},
  { MESSAGE_TYPE_CONT_CHECK_REQ,              "Continuity check request"},
  { MESSAGE_TYPE_RESET_CIRCUIT,               "Reset Circuit"},
  { MESSAGE_TYPE_BLOCKING,                    "Blocking"},
  { MESSAGE_TYPE_UNBLOCKING,                  "Unblocking"},
  { MESSAGE_TYPE_BLOCK_ACK,                   "Blocking acknowledgement"},
  { MESSAGE_TYPE_UNBLOCK_ACK,                 "Unblocking acknowledgment"},
  { MESSAGE_TYPE_CIRC_GRP_RST,                "Circuit group reset"},
  { MESSAGE_TYPE_CIRC_GRP_BLCK,               "Circuit group blocking"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL,               "Circuit group unblocking"},
  { MESSAGE_TYPE_CIRC_GRP_BL_ACK,             "Circuit group blocking acknowledgement"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK,           "Circuit group unblocking acknowledgement"},

  { 28,                                       "Reserved (used in 1988 version)"},
  { 29,                                       "Reserved (used in 1988 version)"},
  { 30,                                       "Reserved (used in 1988 version)"},

  { MESSAGE_TYPE_FACILITY_REQ,                "Facility request"},
  { MESSAGE_TYPE_FACILITY_ACC,                "Facility accepted"},
  { MESSAGE_TYPE_FACILITY_REJ,                "Facility reject"},

  { 34,                                       "Reserved (used in 1984 version)"},
  { 35,                                       "Reserved (used in 1984 version)"},

  { MESSAGE_TYPE_LOOP_BACK_ACK,               "Loop back acknowledgement (national use)"},

  { 37,                                       "Reserved (used in 1984 version)"},
  { 38,                                       "Reserved (used in 1984 version)"},
  { 39,                                       "Reserved (used in 1984 version)"},

  { MESSAGE_TYPE_PASS_ALONG,                  "Pass-along (national use)"},
  { MESSAGE_TYPE_CIRC_GRP_RST_ACK,            "Circuit group reset acknowledgement"},
  { MESSAGE_TYPE_CIRC_GRP_QRY,                "Circuit group query (national use)"},
  { MESSAGE_TYPE_CIRC_GRP_QRY_RSP,            "Circuit group query response (national use)"},
  { MESSAGE_TYPE_CALL_PROGRSS,                "Call progress"},
  { MESSAGE_TYPE_USER2USER_INFO,              "User-to-user information"},
  { MESSAGE_TYPE_UNEQUIPPED_CIC,              "Unequipped CIC (national use)"},
  { MESSAGE_TYPE_CONFUSION,                   "Confusion"},
  { MESSAGE_TYPE_OVERLOAD,                    "Overload (national use)"},
  { MESSAGE_TYPE_CHARGE_INFO,                 "Charge information (national use)"},
  { MESSAGE_TYPE_NETW_RESRC_MGMT,             "Network resource management"},
  { MESSAGE_TYPE_FACILITY,                    "Facility"},
  { MESSAGE_TYPE_USER_PART_TEST,              "User part test"},
  { MESSAGE_TYPE_USER_PART_AVAIL,             "User part available"},
  { MESSAGE_TYPE_IDENT_REQ,                   "Identification request"},
  { MESSAGE_TYPE_IDENT_RSP,                   "Identification response"},
  { MESSAGE_TYPE_SEGMENTATION,                "Segmentation"},

  { 57,                                       "Reserved (used in B-ISUP)"},
  { 58,                                       "Reserved (used in B-ISUP)"},
  { 59,                                       "Reserved (used in B-ISUP)"},
  { 60,                                       "Reserved (used in B-ISUP)"},
  { 61,                                       "Reserved (used in B-ISUP)"},

  { 62,                                       "Unknown"},
  { 63,                                       "Unknown"},

  { MESSAGE_TYPE_LOOP_PREVENTION,             "Loop prevention"},
  { MESSAGE_TYPE_APPLICATION_TRANS,           "Application transport"},
  { MESSAGE_TYPE_PRE_RELEASE_INFO,            "Pre-release information"},
  { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM,          "Subsequent Directory Number (national use)"},
  { MESSAGE_TYPE_JAPAN_CHARG_INF,             "Charge information"},
  { 0,                                  NULL}};
static value_string_ext japan_isup_message_type_value_ext = VALUE_STRING_EXT_INIT(japan_isup_message_type_value);

static const value_string ansi_isup_message_type_value[] = {
  { MESSAGE_TYPE_INITIAL_ADDR,                "Initial address"},
  { MESSAGE_TYPE_SUBSEQ_ADDR,                 "Subsequent address"},
  { MESSAGE_TYPE_INFO_REQ,                    "Information request (national use)"},
  { MESSAGE_TYPE_INFO,                        "Information (national use)"},
  { MESSAGE_TYPE_CONTINUITY,                  "Continuity"},
  { MESSAGE_TYPE_ADDR_CMPL,                   "Address complete"},
  { MESSAGE_TYPE_CONNECT,                     "Connect"},
  { MESSAGE_TYPE_FORW_TRANS,                  "Forward transfer"},
  { MESSAGE_TYPE_ANSWER,                      "Answer"},
  { MESSAGE_TYPE_RELEASE,                     "Release"},
  { MESSAGE_TYPE_SUSPEND,                     "Suspend"},
  { MESSAGE_TYPE_RESUME,                      "Resume"},
  { MESSAGE_TYPE_REL_CMPL,                    "Release complete"},
  { MESSAGE_TYPE_CONT_CHECK_REQ,              "Continuity check request"},
  { MESSAGE_TYPE_RESET_CIRCUIT,               "Reset Circuit"},
  { MESSAGE_TYPE_BLOCKING,                    "Blocking"},
  { MESSAGE_TYPE_UNBLOCKING,                  "Unblocking"},
  { MESSAGE_TYPE_BLOCK_ACK,                   "Blocking acknowledgement"},
  { MESSAGE_TYPE_UNBLOCK_ACK,                 "Unblocking acknowledgment"},
  { MESSAGE_TYPE_CIRC_GRP_RST,                "Circuit group reset"},
  { MESSAGE_TYPE_CIRC_GRP_BLCK,               "Circuit group blocking"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL,               "Circuit group unblocking"},
  { MESSAGE_TYPE_CIRC_GRP_BL_ACK,             "Circuit group blocking acknowledgement"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK,           "Circuit group unblocking acknowledgement"},
  { MESSAGE_TYPE_FACILITY_REQ,                "Facility request"},
  { MESSAGE_TYPE_FACILITY_ACC,                "Facility accepted"},
  { MESSAGE_TYPE_FACILITY_REJ,                "Facility reject"},
  { MESSAGE_TYPE_LOOP_BACK_ACK,               "Loop back acknowledgement (national use)"},
  { MESSAGE_TYPE_PASS_ALONG,                  "Pass-along (national use)"},
  { MESSAGE_TYPE_CIRC_GRP_RST_ACK,            "Circuit group reset acknowledgement"},
  { MESSAGE_TYPE_CIRC_GRP_QRY,                "Circuit group query (national use)"},
  { MESSAGE_TYPE_CIRC_GRP_QRY_RSP,            "Circuit group query response (national use)"},
  { MESSAGE_TYPE_CALL_PROGRSS,                "Call progress"},
  { MESSAGE_TYPE_USER2USER_INFO,              "User-to-user information"},
  { MESSAGE_TYPE_UNEQUIPPED_CIC,              "Unequipped CIC (national use)"},
  { MESSAGE_TYPE_CONFUSION,                   "Confusion"},
  { MESSAGE_TYPE_OVERLOAD,                    "Overload (national use)"},
  { MESSAGE_TYPE_CHARGE_INFO,                 "Charge information (national use)"},
  { MESSAGE_TYPE_NETW_RESRC_MGMT,             "Network resource management"},
  { MESSAGE_TYPE_FACILITY,                    "Facility"},
  { MESSAGE_TYPE_USER_PART_TEST,              "User part test"},
  { MESSAGE_TYPE_USER_PART_AVAIL,             "User part available"},
  { MESSAGE_TYPE_IDENT_REQ,                   "Identification request"},
  { MESSAGE_TYPE_IDENT_RSP,                   "Identification response"},
  { MESSAGE_TYPE_SEGMENTATION,                "Segmentation"},
  { MESSAGE_TYPE_LOOP_PREVENTION,             "Loop prevention"},
  { MESSAGE_TYPE_APPLICATION_TRANS,           "Application transport"},
  { MESSAGE_TYPE_PRE_RELEASE_INFO,            "Pre-release information"},
  { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM,          "Subsequent Directory Number (national use)"},
  { ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES_ACK,   "Circuit Reservation Acknowledge"},
  { ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES,       "Circuit Reservation"},
  { ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST_RSP,  "Circuit Validation Test Response"},
  { ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST,      "Circuit Validation Test"},
  { ANSI_ISUP_MESSAGE_TYPE_EXIT,              "Exit"},
  { 0,                                  NULL}};
static value_string_ext ansi_isup_message_type_value_ext = VALUE_STRING_EXT_INIT(ansi_isup_message_type_value);

/* Same as above but in acronym form (for the Info column) */
static const value_string isup_message_type_value_acro[] = {
  { MESSAGE_TYPE_INITIAL_ADDR,                "IAM"},
  { MESSAGE_TYPE_SUBSEQ_ADDR,                 "SAM"},
  { MESSAGE_TYPE_INFO_REQ,                    "INR"},
  { MESSAGE_TYPE_INFO,                        "INF"},
  { MESSAGE_TYPE_CONTINUITY,                  "COT"},
  { MESSAGE_TYPE_ADDR_CMPL,                   "ACM"},
  { MESSAGE_TYPE_CONNECT,                     "CON"},
  { MESSAGE_TYPE_FORW_TRANS,                  "FOT"},
  { MESSAGE_TYPE_ANSWER,                      "ANM"},

  { 10,                                       "Reserved"},
  { 11,                                       "Reserved"},

  { MESSAGE_TYPE_RELEASE,                     "REL"},
  { MESSAGE_TYPE_SUSPEND,                     "SUS"},
  { MESSAGE_TYPE_RESUME,                      "RES"},

  { 15,                                       "Reserved"},

  { MESSAGE_TYPE_REL_CMPL,                    "RLC"},
  { MESSAGE_TYPE_CONT_CHECK_REQ,              "CCR"},
  { MESSAGE_TYPE_RESET_CIRCUIT,               "RSC"},
  { MESSAGE_TYPE_BLOCKING,                    "BLO"},
  { MESSAGE_TYPE_UNBLOCKING,                  "UBL"},
  { MESSAGE_TYPE_BLOCK_ACK,                   "BLA"},
  { MESSAGE_TYPE_UNBLOCK_ACK,                 "UBLA"},
  { MESSAGE_TYPE_CIRC_GRP_RST,                "GRS"},
  { MESSAGE_TYPE_CIRC_GRP_BLCK,               "CGB"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL,               "CGU"},
  { MESSAGE_TYPE_CIRC_GRP_BL_ACK,             "CGBA"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK,           "CGUA"},

  { 28,                                       "Reserved"},
  { 29,                                       "Reserved"},
  { 30,                                       "Reserved"},

  { MESSAGE_TYPE_FACILITY_REQ,                "FAR"},
  { MESSAGE_TYPE_FACILITY_ACC,                "FAA"},
  { MESSAGE_TYPE_FACILITY_REJ,                "FRJ"},

  { 34,                                       "Reserved"},
  { 35,                                       "Reserved"},

  { MESSAGE_TYPE_LOOP_BACK_ACK,               "LPA"},

  { 37,                                       "Reserved"},
  { 38,                                       "Reserved"},
  { 39,                                       "Reserved"},

  { MESSAGE_TYPE_PASS_ALONG,                  "PAM"},
  { MESSAGE_TYPE_CIRC_GRP_RST_ACK,            "GRA"},
  { MESSAGE_TYPE_CIRC_GRP_QRY,                "CQM"},
  { MESSAGE_TYPE_CIRC_GRP_QRY_RSP,            "CQR"},
  { MESSAGE_TYPE_CALL_PROGRSS,                "CPG"},
  { MESSAGE_TYPE_USER2USER_INFO,              "UUI"},
  { MESSAGE_TYPE_UNEQUIPPED_CIC,              "UCIC"},
  { MESSAGE_TYPE_CONFUSION,                   "CFN"},
  { MESSAGE_TYPE_OVERLOAD,                    "OLM"},
  { MESSAGE_TYPE_CHARGE_INFO,                 "CRG"},
  { MESSAGE_TYPE_NETW_RESRC_MGMT,             "NRM"},
  { MESSAGE_TYPE_FACILITY,                    "FAC"},
  { MESSAGE_TYPE_USER_PART_TEST,              "UPT"},
  { MESSAGE_TYPE_USER_PART_AVAIL,             "UPA"},
  { MESSAGE_TYPE_IDENT_REQ,                   "IDR"},
  { MESSAGE_TYPE_IDENT_RSP,                   "IDS"},
  { MESSAGE_TYPE_SEGMENTATION,                "SGM"},

  { 57,                                       "Reserved"},
  { 58,                                       "Reserved"},
  { 59,                                       "Reserved"},
  { 60,                                       "Reserved"},
  { 61,                                       "Reserved"},

  { 62,                                       "Unknown"},
  { 63,                                       "Unknown"},

  { MESSAGE_TYPE_LOOP_PREVENTION,             "LOP"},
  { MESSAGE_TYPE_APPLICATION_TRANS,           "APM"},
  { MESSAGE_TYPE_PRE_RELEASE_INFO,            "PRI"},
  { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM,          "SDN"},
  { 0,                                  NULL}};
value_string_ext isup_message_type_value_acro_ext = VALUE_STRING_EXT_INIT(isup_message_type_value_acro);

static const value_string french_isup_message_type_value_acro[] = {
  { MESSAGE_TYPE_INITIAL_ADDR,                "IAM"},
  { MESSAGE_TYPE_SUBSEQ_ADDR,                 "SAM"},
  { MESSAGE_TYPE_INFO_REQ,                    "INR"},
  { MESSAGE_TYPE_INFO,                        "INF"},
  { MESSAGE_TYPE_CONTINUITY,                  "COT"},
  { MESSAGE_TYPE_ADDR_CMPL,                   "ACM"},
  { MESSAGE_TYPE_CONNECT,                     "CON"},
  { MESSAGE_TYPE_FORW_TRANS,                  "FOT"},
  { MESSAGE_TYPE_ANSWER,                      "ANM"},

  { 10,                                       "Reserved"},
  { 11,                                       "Reserved"},

  { MESSAGE_TYPE_RELEASE,                     "REL"},
  { MESSAGE_TYPE_SUSPEND,                     "SUS"},
  { MESSAGE_TYPE_RESUME,                      "RES"},

  { 15,                                       "Reserved"},

  { MESSAGE_TYPE_REL_CMPL,                    "RLC"},
  { MESSAGE_TYPE_CONT_CHECK_REQ,              "CCR"},
  { MESSAGE_TYPE_RESET_CIRCUIT,               "RSC"},
  { MESSAGE_TYPE_BLOCKING,                    "BLO"},
  { MESSAGE_TYPE_UNBLOCKING,                  "UBL"},
  { MESSAGE_TYPE_BLOCK_ACK,                   "BLA"},
  { MESSAGE_TYPE_UNBLOCK_ACK,                 "UBLA"},
  { MESSAGE_TYPE_CIRC_GRP_RST,                "GRS"},
  { MESSAGE_TYPE_CIRC_GRP_BLCK,               "CGB"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL,               "CGU"},
  { MESSAGE_TYPE_CIRC_GRP_BL_ACK,             "CGBA"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK,           "CGUA"},

  { 28,                                       "Reserved"},
  { 29,                                       "Reserved"},
  { 30,                                       "Reserved"},

  { MESSAGE_TYPE_FACILITY_REQ,                "FAR"},
  { MESSAGE_TYPE_FACILITY_ACC,                "FAA"},
  { MESSAGE_TYPE_FACILITY_REJ,                "FRJ"},

  { 34,                                       "Reserved"},
  { 35,                                       "Reserved"},

  { MESSAGE_TYPE_LOOP_BACK_ACK,               "LPA"},

  { 37,                                       "Reserved"},
  { 38,                                       "Reserved"},
  { 39,                                       "Reserved"},

  { MESSAGE_TYPE_PASS_ALONG,                  "PAM"},
  { MESSAGE_TYPE_CIRC_GRP_RST_ACK,            "GRA"},
  { MESSAGE_TYPE_CIRC_GRP_QRY,                "CQM"},
  { MESSAGE_TYPE_CIRC_GRP_QRY_RSP,            "CQR"},
  { MESSAGE_TYPE_CALL_PROGRSS,                "CPG"},
  { MESSAGE_TYPE_USER2USER_INFO,              "UUI"},
  { MESSAGE_TYPE_UNEQUIPPED_CIC,              "UCIC"},
  { MESSAGE_TYPE_CONFUSION,                   "CFN"},
  { MESSAGE_TYPE_OVERLOAD,                    "OLM"},
  { MESSAGE_TYPE_CHARGE_INFO,                 "CRG"},
  { MESSAGE_TYPE_NETW_RESRC_MGMT,             "NRM"},
  { MESSAGE_TYPE_FACILITY,                    "FAC"},
  { MESSAGE_TYPE_USER_PART_TEST,              "UPT"},
  { MESSAGE_TYPE_USER_PART_AVAIL,             "UPA"},
  { MESSAGE_TYPE_IDENT_REQ,                   "IDR"},
  { MESSAGE_TYPE_IDENT_RSP,                   "IDS"},
  { MESSAGE_TYPE_SEGMENTATION,                "SGM"},

  { 57,                                       "Reserved"},
  { 58,                                       "Reserved"},
  { 59,                                       "Reserved"},
  { 60,                                       "Reserved"},
  { 61,                                       "Reserved"},

  { 62,                                       "Unknown"},
  { 63,                                       "Unknown"},

  { MESSAGE_TYPE_LOOP_PREVENTION,             "LOP"},
  { MESSAGE_TYPE_APPLICATION_TRANS,           "APM"},
  { MESSAGE_TYPE_PRE_RELEASE_INFO,            "PRI"},
  { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM,          "SDN"},
  { FRENCH_CHARGING_PULSE,                    "CHP"},
  { FRENCH_CHARGING_ACK,                      "CHA"},
  { 0,                                  NULL}};
static value_string_ext french_isup_message_type_value_acro_ext = VALUE_STRING_EXT_INIT(french_isup_message_type_value_acro);

static const value_string israeli_isup_message_type_value_acro[] = {
  { MESSAGE_TYPE_INITIAL_ADDR,                "IAM"},
  { MESSAGE_TYPE_SUBSEQ_ADDR,                 "SAM"},
  { MESSAGE_TYPE_INFO_REQ,                    "INR"},
  { MESSAGE_TYPE_INFO,                        "INF"},
  { MESSAGE_TYPE_CONTINUITY,                  "COT"},
  { MESSAGE_TYPE_ADDR_CMPL,                   "ACM"},
  { MESSAGE_TYPE_CONNECT,                     "CON"},
  { MESSAGE_TYPE_FORW_TRANS,                  "FOT"},
  { MESSAGE_TYPE_ANSWER,                      "ANM"},

  { 10,                                       "Reserved"},
  { 11,                                       "Reserved"},

  { MESSAGE_TYPE_RELEASE,                     "REL"},
  { MESSAGE_TYPE_SUSPEND,                     "SUS"},
  { MESSAGE_TYPE_RESUME,                      "RES"},

  { 15,                                       "Reserved"},

  { MESSAGE_TYPE_REL_CMPL,                    "RLC"},
  { MESSAGE_TYPE_CONT_CHECK_REQ,              "CCR"},
  { MESSAGE_TYPE_RESET_CIRCUIT,               "RSC"},
  { MESSAGE_TYPE_BLOCKING,                    "BLO"},
  { MESSAGE_TYPE_UNBLOCKING,                  "UBL"},
  { MESSAGE_TYPE_BLOCK_ACK,                   "BLA"},
  { MESSAGE_TYPE_UNBLOCK_ACK,                 "UBLA"},
  { MESSAGE_TYPE_CIRC_GRP_RST,                "GRS"},
  { MESSAGE_TYPE_CIRC_GRP_BLCK,               "CGB"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL,               "CGU"},
  { MESSAGE_TYPE_CIRC_GRP_BL_ACK,             "CGBA"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK,           "CGUA"},

  { 28,                                       "Reserved"},
  { 29,                                       "Reserved"},
  { 30,                                       "Reserved"},

  { MESSAGE_TYPE_FACILITY_REQ,                "FAR"},
  { MESSAGE_TYPE_FACILITY_ACC,                "FAA"},
  { MESSAGE_TYPE_FACILITY_REJ,                "FRJ"},

  { 34,                                       "Reserved"},
  { 35,                                       "Reserved"},

  { MESSAGE_TYPE_LOOP_BACK_ACK,               "LPA"},

  { 37,                                       "Reserved"},
  { 38,                                       "Reserved"},
  { 39,                                       "Reserved"},

  { MESSAGE_TYPE_PASS_ALONG,                  "PAM"},
  { MESSAGE_TYPE_CIRC_GRP_RST_ACK,            "GRA"},
  { MESSAGE_TYPE_CIRC_GRP_QRY,                "CQM"},
  { MESSAGE_TYPE_CIRC_GRP_QRY_RSP,            "CQR"},
  { MESSAGE_TYPE_CALL_PROGRSS,                "CPG"},
  { MESSAGE_TYPE_USER2USER_INFO,              "UUI"},
  { MESSAGE_TYPE_UNEQUIPPED_CIC,              "UCIC"},
  { MESSAGE_TYPE_CONFUSION,                   "CFN"},
  { MESSAGE_TYPE_OVERLOAD,                    "OLM"},
  { MESSAGE_TYPE_CHARGE_INFO,                 "CRG"},
  { MESSAGE_TYPE_NETW_RESRC_MGMT,             "NRM"},
  { MESSAGE_TYPE_FACILITY,                    "FAC"},
  { MESSAGE_TYPE_USER_PART_TEST,              "UPT"},
  { MESSAGE_TYPE_USER_PART_AVAIL,             "UPA"},
  { MESSAGE_TYPE_IDENT_REQ,                   "IDR"},
  { MESSAGE_TYPE_IDENT_RSP,                   "IDS"},
  { MESSAGE_TYPE_SEGMENTATION,                "SGM"},

  { 57,                                       "Reserved"},
  { 58,                                       "Reserved"},
  { 59,                                       "Reserved"},
  { 60,                                       "Reserved"},
  { 61,                                       "Reserved"},

  { 62,                                       "Unknown"},
  { 63,                                       "Unknown"},

  { MESSAGE_TYPE_LOOP_PREVENTION,             "LOP"},
  { MESSAGE_TYPE_APPLICATION_TRANS,           "APM"},
  { MESSAGE_TYPE_PRE_RELEASE_INFO,            "PRI"},
  { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM,          "SDN"},
  { ISRAELI_BACKWARD_CHARGING,                "BCM"},
  { ISRAELI_TRAFFIC_CHANGE,                   "TCM"},
  { ISRAELI_CHARGE_ACK,                       "CAM"},
  { 0,                                  NULL}};
static value_string_ext israeli_isup_message_type_value_acro_ext = VALUE_STRING_EXT_INIT(israeli_isup_message_type_value_acro);

/* Same as above but in acronym form (for the Info column) */
static const value_string russian_isup_message_type_value_acro[] = {
  { MESSAGE_TYPE_INITIAL_ADDR,                "IAM"},
  { MESSAGE_TYPE_SUBSEQ_ADDR,                 "SAM"},
  { MESSAGE_TYPE_INFO_REQ,                    "INR"},
  { MESSAGE_TYPE_INFO,                        "INF"},
  { MESSAGE_TYPE_CONTINUITY,                  "COT"},
  { MESSAGE_TYPE_ADDR_CMPL,                   "ACM"},
  { MESSAGE_TYPE_CONNECT,                     "CON"},
  { MESSAGE_TYPE_FORW_TRANS,                  "FOT"},
  { MESSAGE_TYPE_ANSWER,                      "ANM"},

  { 10,                                       "Reserved"},
  { 11,                                       "Reserved"},

  { MESSAGE_TYPE_RELEASE,                     "REL"},
  { MESSAGE_TYPE_SUSPEND,                     "SUS"},
  { MESSAGE_TYPE_RESUME,                      "RES"},

  { 15,                                       "Reserved"},

  { MESSAGE_TYPE_REL_CMPL,                    "RLC"},
  { MESSAGE_TYPE_CONT_CHECK_REQ,              "CCR"},
  { MESSAGE_TYPE_RESET_CIRCUIT,               "RSC"},
  { MESSAGE_TYPE_BLOCKING,                    "BLO"},
  { MESSAGE_TYPE_UNBLOCKING,                  "UBL"},
  { MESSAGE_TYPE_BLOCK_ACK,                   "BLA"},
  { MESSAGE_TYPE_UNBLOCK_ACK,                 "UBLA"},
  { MESSAGE_TYPE_CIRC_GRP_RST,                "GRS"},
  { MESSAGE_TYPE_CIRC_GRP_BLCK,               "CGB"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL,               "CGU"},
  { MESSAGE_TYPE_CIRC_GRP_BL_ACK,             "CGBA"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK,           "CGUA"},

  { 28,                                       "Reserved"},
  { 29,                                       "Reserved"},
  { 30,                                       "Reserved"},

  { MESSAGE_TYPE_FACILITY_REQ,                "FAR"},
  { MESSAGE_TYPE_FACILITY_ACC,                "FAA"},
  { MESSAGE_TYPE_FACILITY_REJ,                "FRJ"},

  { 34,                                       "Reserved"},
  { 35,                                       "Reserved"},

  { MESSAGE_TYPE_LOOP_BACK_ACK,               "LPA"},

  { 37,                                       "Reserved"},
  { 38,                                       "Reserved"},
  { 39,                                       "Reserved"},

  { MESSAGE_TYPE_PASS_ALONG,                  "PAM"},
  { MESSAGE_TYPE_CIRC_GRP_RST_ACK,            "GRA"},
  { MESSAGE_TYPE_CIRC_GRP_QRY,                "CQM"},
  { MESSAGE_TYPE_CIRC_GRP_QRY_RSP,            "CQR"},
  { MESSAGE_TYPE_CALL_PROGRSS,                "CPG"},
  { MESSAGE_TYPE_USER2USER_INFO,              "UUI"},
  { MESSAGE_TYPE_UNEQUIPPED_CIC,              "UCIC"},
  { MESSAGE_TYPE_CONFUSION,                   "CFN"},
  { MESSAGE_TYPE_OVERLOAD,                    "OLM"},
  { MESSAGE_TYPE_CHARGE_INFO,                 "CRG"},
  { MESSAGE_TYPE_NETW_RESRC_MGMT,             "NRM"},
  { MESSAGE_TYPE_FACILITY,                    "FAC"},
  { MESSAGE_TYPE_USER_PART_TEST,              "UPT"},
  { MESSAGE_TYPE_USER_PART_AVAIL,             "UPA"},
  { MESSAGE_TYPE_IDENT_REQ,                   "IDR"},
  { MESSAGE_TYPE_IDENT_RSP,                   "IDS"},
  { MESSAGE_TYPE_SEGMENTATION,                "SGM"},

  { 57,                                       "Reserved"},
  { 58,                                       "Reserved"},
  { 59,                                       "Reserved"},
  { 60,                                       "Reserved"},
  { 61,                                       "Reserved"},

  { 62,                                       "Unknown"},
  { 63,                                       "Unknown"},

  { MESSAGE_TYPE_LOOP_PREVENTION,             "LOP"},
  { MESSAGE_TYPE_APPLICATION_TRANS,           "APM"},
  { MESSAGE_TYPE_PRE_RELEASE_INFO,            "PRI"},
  { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM,          "SDN"},
  { RUSSIAN_CLEAR_CALLING_LINE,               "CCL"},  /* 252 */
  { RUSSIAN_RINGING,                          "RNG"},  /* 255 */
  { 0,                                  NULL}};
static value_string_ext russian_isup_message_type_value_acro_ext = VALUE_STRING_EXT_INIT(russian_isup_message_type_value_acro);

static const value_string japan_isup_message_type_value_acro[] = {
  { MESSAGE_TYPE_INITIAL_ADDR,                "IAM"},
  { MESSAGE_TYPE_SUBSEQ_ADDR,                 "SAM"},
  { MESSAGE_TYPE_INFO_REQ,                    "INR"},
  { MESSAGE_TYPE_INFO,                        "INF"},
  { MESSAGE_TYPE_CONTINUITY,                  "COT"},
  { MESSAGE_TYPE_ADDR_CMPL,                   "ACM"},
  { MESSAGE_TYPE_CONNECT,                     "CON"},
  { MESSAGE_TYPE_FORW_TRANS,                  "FOT"},
  { MESSAGE_TYPE_ANSWER,                      "ANM"},

  { 10,                                       "Reserved"},
  { 11,                                       "Reserved"},

  { MESSAGE_TYPE_RELEASE,                     "REL"},
  { MESSAGE_TYPE_SUSPEND,                     "SUS"},
  { MESSAGE_TYPE_RESUME,                      "RES"},

  { 15,                                       "Reserved"},

  { MESSAGE_TYPE_REL_CMPL,                    "RLC"},
  { MESSAGE_TYPE_CONT_CHECK_REQ,              "CCR"},
  { MESSAGE_TYPE_RESET_CIRCUIT,               "RSC"},
  { MESSAGE_TYPE_BLOCKING,                    "BLO"},
  { MESSAGE_TYPE_UNBLOCKING,                  "UBL"},
  { MESSAGE_TYPE_BLOCK_ACK,                   "BLA"},
  { MESSAGE_TYPE_UNBLOCK_ACK,                 "UBLA"},
  { MESSAGE_TYPE_CIRC_GRP_RST,                "GRS"},
  { MESSAGE_TYPE_CIRC_GRP_BLCK,               "CGB"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL,               "CGU"},
  { MESSAGE_TYPE_CIRC_GRP_BL_ACK,             "CGBA"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK,           "CGUA"},

  { 28,                                       "Reserved"},
  { 29,                                       "Reserved"},
  { 30,                                       "Reserved"},

  { MESSAGE_TYPE_FACILITY_REQ,                "FAR"},
  { MESSAGE_TYPE_FACILITY_ACC,                "FAA"},
  { MESSAGE_TYPE_FACILITY_REJ,                "FRJ"},

  { 34,                                       "Reserved"},
  { 35,                                       "Reserved"},

  { MESSAGE_TYPE_LOOP_BACK_ACK,               "LPA"},

  { 37,                                       "Reserved"},
  { 38,                                       "Reserved"},
  { 39,                                       "Reserved"},

  { MESSAGE_TYPE_PASS_ALONG,                  "PAM"},
  { MESSAGE_TYPE_CIRC_GRP_RST_ACK,            "GRA"},
  { MESSAGE_TYPE_CIRC_GRP_QRY,                "CQM"},
  { MESSAGE_TYPE_CIRC_GRP_QRY_RSP,            "CQR"},
  { MESSAGE_TYPE_CALL_PROGRSS,                "CPG"},
  { MESSAGE_TYPE_USER2USER_INFO,              "UUI"},
  { MESSAGE_TYPE_UNEQUIPPED_CIC,              "UCIC"},
  { MESSAGE_TYPE_CONFUSION,                   "CFN"},
  { MESSAGE_TYPE_OVERLOAD,                    "OLM"},
  { MESSAGE_TYPE_CHARGE_INFO,                 "CRG"},
  { MESSAGE_TYPE_NETW_RESRC_MGMT,             "NRM"},
  { MESSAGE_TYPE_FACILITY,                    "FAC"},
  { MESSAGE_TYPE_USER_PART_TEST,              "UPT"},
  { MESSAGE_TYPE_USER_PART_AVAIL,             "UPA"},
  { MESSAGE_TYPE_IDENT_REQ,                   "IDR"},
  { MESSAGE_TYPE_IDENT_RSP,                   "IDS"},
  { MESSAGE_TYPE_SEGMENTATION,                "SGM"},

  { 57,                                       "Reserved"},
  { 58,                                       "Reserved"},
  { 59,                                       "Reserved"},
  { 60,                                       "Reserved"},
  { 61,                                       "Reserved"},

  { 62,                                       "Unknown"},
  { 63,                                       "Unknown"},

  { MESSAGE_TYPE_LOOP_PREVENTION,             "LOP"},
  { MESSAGE_TYPE_APPLICATION_TRANS,           "APM"},
  { MESSAGE_TYPE_PRE_RELEASE_INFO,            "PRI"},
  { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM,          "SDN"},
  { MESSAGE_TYPE_JAPAN_CHARG_INF,             "CHG"},  /* 254 */
  { 0,                                  NULL}};
static value_string_ext japan_isup_message_type_value_acro_ext = VALUE_STRING_EXT_INIT(japan_isup_message_type_value_acro);

  /* Same as above but in acronym form (for the Info column) */
static const value_string ansi_isup_message_type_value_acro[] = {
  { MESSAGE_TYPE_INITIAL_ADDR,                "IAM"},
  { MESSAGE_TYPE_SUBSEQ_ADDR,                 "SAM"},
  { MESSAGE_TYPE_INFO_REQ,                    "INR"},
  { MESSAGE_TYPE_INFO,                        "INF"},
  { MESSAGE_TYPE_CONTINUITY,                  "COT"},
  { MESSAGE_TYPE_ADDR_CMPL,                   "ACM"},
  { MESSAGE_TYPE_CONNECT,                     "CON"},
  { MESSAGE_TYPE_FORW_TRANS,                  "FOT"},
  { MESSAGE_TYPE_ANSWER,                      "ANM"},
  { MESSAGE_TYPE_RELEASE,                     "REL"},
  { MESSAGE_TYPE_SUSPEND,                     "SUS"},
  { MESSAGE_TYPE_RESUME,                      "RES"},
  { MESSAGE_TYPE_REL_CMPL,                    "RLC"},
  { MESSAGE_TYPE_CONT_CHECK_REQ,              "CCR"},
  { MESSAGE_TYPE_RESET_CIRCUIT,               "RSC"},
  { MESSAGE_TYPE_BLOCKING,                    "BLO"},
  { MESSAGE_TYPE_UNBLOCKING,                  "UBL"},
  { MESSAGE_TYPE_BLOCK_ACK,                   "BLA"},
  { MESSAGE_TYPE_UNBLOCK_ACK,                 "UBLA"},
  { MESSAGE_TYPE_CIRC_GRP_RST,                "GRS"},
  { MESSAGE_TYPE_CIRC_GRP_BLCK,               "CGB"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL,               "CGU"},
  { MESSAGE_TYPE_CIRC_GRP_BL_ACK,             "CGBA"},
  { MESSAGE_TYPE_CIRC_GRP_UNBL_ACK,           "CGUA"},
  { MESSAGE_TYPE_FACILITY_REQ,                "FAR"},
  { MESSAGE_TYPE_FACILITY_ACC,                "FAA"},
  { MESSAGE_TYPE_FACILITY_REJ,                "FRJ"},
  { MESSAGE_TYPE_LOOP_BACK_ACK,               "LPA"},
  { MESSAGE_TYPE_PASS_ALONG,                  "PAM"},
  { MESSAGE_TYPE_CIRC_GRP_RST_ACK,            "GRA"},
  { MESSAGE_TYPE_CIRC_GRP_QRY,                "CQM"},
  { MESSAGE_TYPE_CIRC_GRP_QRY_RSP,            "CQR"},
  { MESSAGE_TYPE_CALL_PROGRSS,                "CPG"},
  { MESSAGE_TYPE_USER2USER_INFO,              "UUI"},
  { MESSAGE_TYPE_UNEQUIPPED_CIC,              "UCIC"},
  { MESSAGE_TYPE_CONFUSION,                   "CFN"},
  { MESSAGE_TYPE_OVERLOAD,                    "OLM"},
  { MESSAGE_TYPE_CHARGE_INFO,                 "CRG"},
  { MESSAGE_TYPE_NETW_RESRC_MGMT,             "NRM"},
  { MESSAGE_TYPE_FACILITY,                    "FAC"},
  { MESSAGE_TYPE_USER_PART_TEST,              "UPT"},
  { MESSAGE_TYPE_USER_PART_AVAIL,             "UPA"},
  { MESSAGE_TYPE_IDENT_REQ,                   "IDR"},
  { MESSAGE_TYPE_IDENT_RSP,                   "IDS"},
  { MESSAGE_TYPE_SEGMENTATION,                "SGM"},
  { MESSAGE_TYPE_LOOP_PREVENTION,             "LOP"},
  { MESSAGE_TYPE_APPLICATION_TRANS,           "APM"},
  { MESSAGE_TYPE_PRE_RELEASE_INFO,            "PRI"},
  { MESSAGE_TYPE_SUBSEQUENT_DIR_NUM,          "SDN"},
  { ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES_ACK,   "CRA"},
  { ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES,       "CRM"},
  { ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST_RSP,  "CVR"},
  { ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST,      "CVT"},
  { ANSI_ISUP_MESSAGE_TYPE_EXIT,              "EXIT"},
  { 0,                                  NULL}};
static value_string_ext ansi_isup_message_type_value_acro_ext = VALUE_STRING_EXT_INIT(ansi_isup_message_type_value_acro);

/* Table 5/Q.763 */
const value_string isup_parameter_type_value[] = {
/*   0 */  { PARAM_TYPE_END_OF_OPT_PARAMS,         "End of optional parameters"},
/*   1 */  { PARAM_TYPE_CALL_REF,                  "Call Reference (national use)"},
/*   2 */  { PARAM_TYPE_TRANSM_MEDIUM_REQU,        "Transmission medium requirement"},
/*   3 */  { PARAM_TYPE_ACC_TRANSP,                "Access transport"},
/*   4 */  { PARAM_TYPE_CALLED_PARTY_NR,           "Called party number"},
/*   5 */  { PARAM_TYPE_SUBSQT_NR,                 "Subsequent number"},
/*   6 */  { PARAM_TYPE_NATURE_OF_CONN_IND,        "Nature of connection indicators"},
/*   7 */  { PARAM_TYPE_FORW_CALL_IND,             "Forward call indicators"},
/*   8 */  { PARAM_TYPE_OPT_FORW_CALL_IND,         "Optional forward call indicators"},
/*   9 */  { PARAM_TYPE_CALLING_PRTY_CATEG,        "Calling party's category"},
/*  10 */  { PARAM_TYPE_CALLING_PARTY_NR,          "Calling party number"},
/*  11 */  { PARAM_TYPE_REDIRECTING_NR,            "Redirecting number"},
/*  12 */  { PARAM_TYPE_REDIRECTION_NR,            "Redirection number"},
/*  13 */  { PARAM_TYPE_CONNECTION_REQ,            "Connection request"},
/*  14 */  { PARAM_TYPE_INFO_REQ_IND,              "Information request indicators (national use)"},
/*  15 */  { PARAM_TYPE_INFO_IND,                  "Information indicators (national use)"},
/*  16 */  { PARAM_TYPE_CONTINUITY_IND,            "Continuity request"},
/*  17 */  { PARAM_TYPE_BACKW_CALL_IND,            "Backward call indicators"},
/*  18 */  { PARAM_TYPE_CAUSE_INDICATORS,          "Cause indicators"},
/*  19 */  { PARAM_TYPE_REDIRECTION_INFO,          "Redirection information"},
/*  20 */  { 20,                                   "Not used"},
/*  21 */  { PARAM_TYPE_CIRC_GRP_SV_MSG_TYPE,      "Circuit group supervision message type"},
/*  22 */  { PARAM_TYPE_RANGE_AND_STATUS,          "Range and Status"},
/*  23 */  { 23,                                   "Not used"},
/*  24 */  { PARAM_TYPE_FACILITY_IND,              "Facility indicator"},
/*  25 */  { 25,                                   "Not used"},
/*  26 */  { PARAM_TYPE_CLSD_USR_GRP_ILOCK_CD,     "Closed user group interlock code"},
/*  27 */  { 27,                                   "Not used"},
/*  28 */  { 28,                                   "Not used"},
/*  29 */  { PARAM_TYPE_USER_SERVICE_INFO,         "User service information"},
/*  30 */  { PARAM_TYPE_SIGNALLING_POINT_CODE,     "Signalling point code (national use)"},
/*  31 */  { 31,                                   "Not used"},
/*  32 */  { PARAM_TYPE_USER_TO_USER_INFO,         "User-to-user information"},
/*  33 */  { PARAM_TYPE_CONNECTED_NR,              "Connected number"},
/*  34 */  { PARAM_TYPE_SUSP_RESUME_IND,           "Suspend/Resume indicators"},
/*  35 */  { PARAM_TYPE_TRANSIT_NETW_SELECT,       "Transit network selection (national use)"},
/*  36 */  { PARAM_TYPE_EVENT_INFO,                "Event information"},
/*  37 */  { PARAM_TYPE_CIRC_ASSIGN_MAP,           "Circuit assignment map"},
/*  38 */  { PARAM_TYPE_CIRC_STATE_IND,            "Circuit state indicator (national use)"},
/*  39 */  { PARAM_TYPE_AUTO_CONG_LEVEL,           "Automatic congestion level"},
/*  40 */  { PARAM_TYPE_ORIG_CALLED_NR,            "Original called number"},
/*  41 */  { PARAM_TYPE_OPT_BACKW_CALL_IND,        "Backward call indicators"},
/*  42 */  { PARAM_TYPE_USER_TO_USER_IND,          "User-to-user indicators"},
/*  43 */  { PARAM_TYPE_ORIG_ISC_POINT_CODE,       "Origination ISC point code"},
/*  44 */  { PARAM_TYPE_GENERIC_NOTIF_IND,         "Generic notification indicator"},
/*  45 */  { PARAM_TYPE_CALL_HIST_INFO,            "Call history information"},
/*  46 */  { PARAM_TYPE_ACC_DELIV_INFO,            "Access delivery information"},
/*  47 */  { PARAM_TYPE_NETW_SPECIFIC_FACLTY,      "Network specific facility (national use)"},
/*  48 */  { PARAM_TYPE_USER_SERVICE_INFO_PR,      "User service information prime"},
/*  49 */  { PARAM_TYPE_PROPAG_DELAY_COUNTER,      "Propagation delay counter"},
/*  50 */  { PARAM_TYPE_REMOTE_OPERATIONS,         "Remote operations (national use)"},
/*  51 */  { PARAM_TYPE_SERVICE_ACTIVATION,        "Service activation"},
/*  52 */  { PARAM_TYPE_USER_TELESERV_INFO,        "User teleservice information"},
/*  53 */  { PARAM_TYPE_TRANSM_MEDIUM_USED,        "Transmission medium used"},
/*  54 */  { PARAM_TYPE_CALL_DIV_INFO,             "Call diversion information"},
/*  55 */  { PARAM_TYPE_ECHO_CTRL_INFO,            "Echo control information"},
/*  56 */  { PARAM_TYPE_MSG_COMPAT_INFO,           "Message compatibility information"},
/*  57 */  { PARAM_TYPE_PARAM_COMPAT_INFO,         "Parameter compatibility information"},
/*  58 */  { PARAM_TYPE_MLPP_PRECEDENCE,           "MLPP precedence"},
/*  59 */  { PARAM_TYPE_MCID_REQ_IND,              "MCID request indicators"},
/*  60 */  { PARAM_TYPE_MCID_RSP_IND,              "MCID response indicators"},
/*  61 */  { PARAM_TYPE_HOP_COUNTER,               "Hop counter"},
/*  62 */  { PARAM_TYPE_TRANSM_MEDIUM_RQUR_PR,     "Transmission medium requirement prime"},
/*  63 */  { PARAM_TYPE_LOCATION_NR,               "Location number"},
/*  64 */  { PARAM_TYPE_REDIR_NR_RSTRCT,           "Redirection number restriction"},
/*  65 */  { 65,                                   "Not used"},
/*  66 */  { 66,                                   "Not used"},
/*  67 */  { PARAM_TYPE_CALL_TRANS_REF,            "Call transfer reference"},
/*  68 */  { PARAM_TYPE_LOOP_PREV_IND,             "Loop prevention indicators"},
/*  69 */  { PARAM_TYPE_CALL_TRANS_NR,             "Call transfer number"},
/*  70 */  { 70,                                   "Not used"},
/*  71 */  { 71,                                   "Not used"},
/*  72 */  { 72,                                   "Not used"},
/*  73 */  { 73,                                   "Not used"},
/*  74 */  { 74,                                   "Not used"},
/*  75 */  { PARAM_TYPE_CCSS,                      "CCSS"},
/*  76 */  { PARAM_TYPE_FORW_GVNS,                 "Forward GVNS"},
/*  77 */  { PARAM_TYPE_BACKW_GVNS,                "Backward GVNS"},
/*  78 */  { PARAM_TYPE_REDIRECT_CAPAB,            "Redirect capability (reserved for national use)"},
/*  79 */  { 79,                                   "Not used"},
/*  80 */  { 80,                                   "Not used"},
/*  81 */  { 81,                                   "Not used"},
/*  82 */  { 82,                                   "Not used"},
/*  83 */  { 83,                                   "Not used"},
/*  84 */  { 84,                                   "Not used"},
/*  85 */  { 85,                                   "Not used"},
/*  86 */  { 86,                                   "Not used"},
/*  87 */  { 87,                                   "Not used"},
/*  88 */  { 88,                                   "Not used"},
/*  89 */  { 89,                                   "Not used"},
/*  90 */  { 90,                                   "Not used"},
/*  91 */  { PARAM_TYPE_NETW_MGMT_CTRL,            "Network management controls"},
/*  92 */  { 92,                                   "Not used"},
/*  93 */  { 93,                                   "Not used"},
/*  94 */  { 94,                                   "Not used"},
/*  95 */  { 95,                                   "Not used"},
/*  96 */  { 96,                                   "Not used"},
/*  97 */  { 97,                                   "Not used"},
/*  98 */  { 98,                                   "Not used"},
/*  99 */  { 99,                                   "Not used"},
/* 100 */  { 100,                                  "Not used"},
/* 101 */  { PARAM_TYPE_CORRELATION_ID,            "Correlation id"},
/* 102 */  { PARAM_TYPE_SCF_ID,                    "SCF id"},
/* 103 */  { 103,                                  "Not used"},
/* 104 */  { 104,                                  "Not used"},
/* 105 */  { 105,                                  "Not used"},
/* 106 */  { 106,                                  "Not used"},
/* 107 */  { 107,                                  "Not used"},
/* 108 */  { 108,                                  "Not used"},
/* 109 */  { 109,                                  "Not used"},
/* 110 */  { PARAM_TYPE_CALL_DIV_TREAT_IND,        "Call diversion treatment indicators"},
/* 111 */  { PARAM_TYPE_CALLED_IN_NR,              "Called IN number"},
/* 112 */  { PARAM_TYPE_CALL_OFF_TREAT_IND,        "Call offering treatment indicators"},
/* 113 */  { PARAM_TYPE_CHARGED_PARTY_IDENT,       "Charged party identification (national use)"},
/* 114 */  { PARAM_TYPE_CONF_TREAT_IND,            "Conference treatment indicators"},
/* 115 */  { PARAM_TYPE_DISPLAY_INFO,              "Display information"},
/* 116 */  { PARAM_TYPE_UID_ACTION_IND,            "UID action indicators"},
/* 117 */  { PARAM_TYPE_UID_CAPAB_IND,             "UID capability indicators"},
/* 119 */  { PARAM_TYPE_REDIRECT_COUNTER,          "Redirect counter (reserved for national use)"},
/* 120 */  { PARAM_TYPE_APPLICATON_TRANS,          "Application transport"},
/* 121 */  { PARAM_TYPE_COLLECT_CALL_REQ,          "Collect call request"},
/* 122 */  { 122,                                  "Not used"},
/* 123 */  { 123,                                  "Not used"},
/* 124 */  { 124,                                  "Not used"},
/* 125 */  { 125,                                  "Not used"},
/* 126 */  { 126,                                  "Not used"},
/* 127 */  { 127,                                  "Not used"},
/* 128 */  { 128,                                  "Not used"},
/* 129 */  { 129,                                  "Not used"},
/* 130 */  { 130,                                  "Not used"},
/* 142 */  { 142,                                  "Forward CAT indicators"},   /* Q.763 Amendment 6(10/2009) */
/* 143 */  { 143,                                  "Backward CAT indicators"},  /* Q.763 Amendment 6(10/2009) */
/* 150 */  { 150,                                  "Automatic re-routing" },    /* Q.763 Amendment 3(04/2004) */
/* 166 */  { 166,                                  "IEPS call information" },   /* Q.763 Amendment 4(01/2006) */
/* 168 */  { 168,                                  "VED information" },         /* Q.763 Amendment 5(09/2006) */
/* 192 */  { PARAM_TYPE_GENERIC_NR,                "Generic number"},
/* 193 */  { PARAM_TYPE_GENERIC_DIGITS,            "Generic digits (national use)"},
  { 0,                                 NULL}};
static value_string_ext isup_parameter_type_value_ext = VALUE_STRING_EXT_INIT(isup_parameter_type_value);

#define JAPAN_ISUP_PARAM_CALLED_DIRECTORY_NUMBER         125 /* 7D */
#define JAPAN_ISUP_PARAM_REDIRECT_FORWARD_INF            139 /* 8B */
#define JAPAN_ISUP_PARAM_REDIRECT_BACKWARD_INF           140 /* 8C */
#define JAPAN_ISUP_PARAM_EMERGENCY_CALL_IND              215 /* D7 */
#define JAPAN_ISUP_PARAM_EMERGENCY_CALL_INF_IND          236 /* EC */
#define JAPAN_ISUP_PARAM_NETWORK_POI_CA                  238 /* EE */
#define JAPAN_ISUP_PARAM_TYPE_CARRIER_INFO               241 /* F1 */
#define JAPAN_ISUP_PARAM_CHARGE_INF_DELAY                242 /* F2 */

#define JAPAN_ISUP_PARAM_TYPE_ADDITONAL_USER_CAT         243 /* F3 */
#define JAPAN_ISUP_PARAM_REASON_FOR_CLIP_FAIL            245 /* F5 */
#define JAPAN_ISUP_PARAM_TYPE_CONTRACTOR_NUMBER          249 /* F9 */
#define JAPAN_ISUP_PARAM_TYPE_CHARGE_INF_TYPE            250 /* FA */
#define JAPAN_ISUP_PARAM_TYPE_CHARGE_INF                 251 /* FB */
#define JAPAN_ISUP_PARAM_TYPE_CHARGE_AREA_INFO           253 /* FD */

static const value_string japan_isup_parameter_type_value[] = {
/*   0 */  { PARAM_TYPE_END_OF_OPT_PARAMS,         "End of optional parameters"},
/*   1 */  { PARAM_TYPE_CALL_REF,                  "Call Reference (national use)"},
/*   2 */  { PARAM_TYPE_TRANSM_MEDIUM_REQU,        "Transmission medium requirement"},
/*   3 */  { PARAM_TYPE_ACC_TRANSP,                "Access transport"},
/*   4 */  { PARAM_TYPE_CALLED_PARTY_NR,           "Called party number"},
/*   5 */  { PARAM_TYPE_SUBSQT_NR,                 "Subsequent number"},
/*   6 */  { PARAM_TYPE_NATURE_OF_CONN_IND,        "Nature of connection indicators"},
/*   7 */  { PARAM_TYPE_FORW_CALL_IND,             "Forward call indicators"},
/*   8 */  { PARAM_TYPE_OPT_FORW_CALL_IND,         "Optional forward call indicators"},
/*   9 */  { PARAM_TYPE_CALLING_PRTY_CATEG,        "Calling party's category"},
/*  10 */  { PARAM_TYPE_CALLING_PARTY_NR,          "Calling party number"},
/*  11 */  { PARAM_TYPE_REDIRECTING_NR,            "Redirecting number"},
/*  12 */  { PARAM_TYPE_REDIRECTION_NR,            "Redirection number"},
/*  13 */  { PARAM_TYPE_CONNECTION_REQ,            "Connection request"},
/*  14 */  { PARAM_TYPE_INFO_REQ_IND,              "Information request indicators (national use)"},
/*  15 */  { PARAM_TYPE_INFO_IND,                  "Information indicators (national use)"},
/*  16 */  { PARAM_TYPE_CONTINUITY_IND,            "Continuity request"},
/*  17 */  { PARAM_TYPE_BACKW_CALL_IND,            "Backward call indicators"},
/*  18 */  { PARAM_TYPE_CAUSE_INDICATORS,          "Cause indicators"},
/*  19 */  { PARAM_TYPE_REDIRECTION_INFO,          "Redirection information"},
/*  20 */  { 20,                                   "Not used"},
/*  21 */  { PARAM_TYPE_CIRC_GRP_SV_MSG_TYPE,      "Circuit group supervision message type"},
/*  22 */  { PARAM_TYPE_RANGE_AND_STATUS,          "Range and Status"},
/*  23 */  { 23,                                   "Not used"},
/*  24 */  { PARAM_TYPE_FACILITY_IND,              "Facility indicator"},
/*  25 */  { 25,                                   "Not used"},
/*  26 */  { PARAM_TYPE_CLSD_USR_GRP_ILOCK_CD,     "Closed user group interlock code"},
/*  27 */  { 27,                                   "Not used"},
/*  28 */  { 28,                                   "Not used"},
/*  29 */  { PARAM_TYPE_USER_SERVICE_INFO,         "User service information"},
/*  30 */  { PARAM_TYPE_SIGNALLING_POINT_CODE,     "Signalling point code (national use)"},
/*  31 */  { 31,                                   "Not used"},
/*  32 */  { PARAM_TYPE_USER_TO_USER_INFO,         "User-to-user information"},
/*  33 */  { PARAM_TYPE_CONNECTED_NR,              "Connected number"},
/*  34 */  { PARAM_TYPE_SUSP_RESUME_IND,           "Suspend/Resume indicators"},
/*  35 */  { PARAM_TYPE_TRANSIT_NETW_SELECT,       "Transit network selection (national use)"},
/*  36 */  { PARAM_TYPE_EVENT_INFO,                "Event information"},
/*  37 */  { PARAM_TYPE_CIRC_ASSIGN_MAP,           "Circuit assignment map"},
/*  38 */  { PARAM_TYPE_CIRC_STATE_IND,            "Circuit state indicator (national use)"},
/*  39 */  { PARAM_TYPE_AUTO_CONG_LEVEL,           "Automatic congestion level"},
/*  40 */  { PARAM_TYPE_ORIG_CALLED_NR,            "Original called number"},
/*  41 */  { PARAM_TYPE_OPT_BACKW_CALL_IND,        "Backward call indicators"},
/*  42 */  { PARAM_TYPE_USER_TO_USER_IND,          "User-to-user indicators"},
/*  43 */  { PARAM_TYPE_ORIG_ISC_POINT_CODE,       "Origination ISC point code"},
/*  44 */  { PARAM_TYPE_GENERIC_NOTIF_IND,         "Generic notification indicator"},
/*  45 */  { PARAM_TYPE_CALL_HIST_INFO,            "Call history information"},
/*  46 */  { PARAM_TYPE_ACC_DELIV_INFO,            "Access delivery information"},
/*  47 */  { PARAM_TYPE_NETW_SPECIFIC_FACLTY,      "Network specific facility (national use)"},
/*  48 */  { PARAM_TYPE_USER_SERVICE_INFO_PR,      "User service information prime"},
/*  49 */  { PARAM_TYPE_PROPAG_DELAY_COUNTER,      "Propagation delay counter"},
/*  50 */  { PARAM_TYPE_REMOTE_OPERATIONS,         "Remote operations (national use)"},
/*  51 */  { PARAM_TYPE_SERVICE_ACTIVATION,        "Service activation"},
/*  52 */  { PARAM_TYPE_USER_TELESERV_INFO,        "User teleservice information"},
/*  53 */  { PARAM_TYPE_TRANSM_MEDIUM_USED,        "Transmission medium used"},
/*  54 */  { PARAM_TYPE_CALL_DIV_INFO,             "Call diversion information"},
/*  55 */  { PARAM_TYPE_ECHO_CTRL_INFO,            "Echo control information"},
/*  56 */  { PARAM_TYPE_MSG_COMPAT_INFO,           "Message compatibility information"},
/*  57 */  { PARAM_TYPE_PARAM_COMPAT_INFO,         "Parameter compatibility information"},
/*  58 */  { PARAM_TYPE_MLPP_PRECEDENCE,           "MLPP precedence"},
/*  59 */  { PARAM_TYPE_MCID_REQ_IND,              "MCID request indicators"},
/*  60 */  { PARAM_TYPE_MCID_RSP_IND,              "MCID response indicators"},
/*  61 */  { PARAM_TYPE_HOP_COUNTER,               "Hop counter"},
/*  62 */  { PARAM_TYPE_TRANSM_MEDIUM_RQUR_PR,     "Transmission medium requirement prime"},
/*  63 */  { PARAM_TYPE_LOCATION_NR,               "Location number"},
/*  64 */  { PARAM_TYPE_REDIR_NR_RSTRCT,           "Redirection number restriction"},
/*  65 */  { 65,                                   "Not used"},
/*  66 */  { 66,                                   "Not used"},
/*  67 */  { PARAM_TYPE_CALL_TRANS_REF,            "Call transfer reference"},
/*  68 */  { PARAM_TYPE_LOOP_PREV_IND,             "Loop prevention indicators"},
/*  69 */  { PARAM_TYPE_CALL_TRANS_NR,             "Call transfer number"},
/*  70 */  { 70,                                   "Not used"},
/*  71 */  { 71,                                   "Not used"},
/*  72 */  { 72,                                   "Not used"},
/*  73 */  { 73,                                   "Not used"},
/*  74 */  { 74,                                   "Not used"},
/*  75 */  { PARAM_TYPE_CCSS,                      "CCSS"},
/*  76 */  { PARAM_TYPE_FORW_GVNS,                 "Forward GVNS"},
/*  77 */  { PARAM_TYPE_BACKW_GVNS,                "Backward GVNS"},
/*  78 */  { PARAM_TYPE_REDIRECT_CAPAB,            "Redirect capability (reserved for national use)"},
/*  79 */  { 79,                                   "Not used"},
/*  80 */  { 80,                                   "Not used"},
/*  81 */  { 81,                                   "Not used"},
/*  82 */  { 82,                                   "Not used"},
/*  83 */  { 83,                                   "Not used"},
/*  84 */  { 84,                                   "Not used"},
/*  85 */  { 85,                                   "Not used"},
/*  86 */  { 86,                                   "Not used"},
/*  87 */  { 87,                                   "Not used"},
/*  88 */  { 88,                                   "Not used"},
/*  89 */  { 89,                                   "Not used"},
/*  90 */  { 90,                                   "Not used"},
/* 101 */  { PARAM_TYPE_CORRELATION_ID,            "Correlation id"},
/* 102 */  { PARAM_TYPE_SCF_ID,                    "SCF id"},
/* 103 */  { 103,                                  "Not used"},
/* 104 */  { 104,                                  "Not used"},
/* 105 */  { 105,                                  "Not used"},
/* 106 */  { 106,                                  "Not used"},
/* 107 */  { 107,                                  "Not used"},
/* 108 */  { 108,                                  "Not used"},
/* 109 */  { 109,                                  "Not used"},
/* 110 */  { PARAM_TYPE_CALL_DIV_TREAT_IND,        "Call diversion treatment indicators"},
/* 111 */  { PARAM_TYPE_CALLED_IN_NR,              "Called IN number"},
/* 112 */  { PARAM_TYPE_CALL_OFF_TREAT_IND,        "Call offering treatment indicators"},
/* 113 */  { PARAM_TYPE_CHARGED_PARTY_IDENT,       "Charged party identification (national use)"},
/* 114 */  { PARAM_TYPE_CONF_TREAT_IND,            "Conference treatment indicators"},
/* 115 */  { PARAM_TYPE_DISPLAY_INFO,              "Display information"},
/* 116 */  { PARAM_TYPE_UID_ACTION_IND,            "UID action indicators"},
/* 117 */  { PARAM_TYPE_UID_CAPAB_IND,             "UID capability indicators"},
/* 119 */  { PARAM_TYPE_REDIRECT_COUNTER,          "Redirect counter (reserved for national use)"},
/* 120 */  { PARAM_TYPE_APPLICATON_TRANS,          "Application transport"},
/* 121 */  { PARAM_TYPE_COLLECT_CALL_REQ,          "Collect call request"},
/* 122 */  { 122,                                  "Not used"},
/* 123 */  { 123,                                  "Not used"},
/* 124 */  { 124,                                  "Not used"},
/* 125 */  { JAPAN_ISUP_PARAM_CALLED_DIRECTORY_NUMBER, "Called Directory Number"},     /* 125 7D */
/* 126 */  { 126,                                  "Not used"},
/* 127 */  { 127,                                  "Not used"},
/* 128 */  { 128,                                  "Not used"},
/* 129 */  { 129,                                  "Not used"},
/* 130 */  { 130,                                  "Not used"},
/* 131 */  { 131,                                  "Not used"},
/* 132 */  { 132,                                  "Not used"},
/* 133 */  { 133,                                  "Not used"},
/* 134 */  { 134,                                  "Not used"},
/* 135 */  { 135,                                  "Not used"},
/* 136 */  { 136,                                  "Not used"},
/* 137 */  { 137,                                  "Not used"},
/* 138 */  { 138,                                  "Not used"},
/* 139 */  { JAPAN_ISUP_PARAM_REDIRECT_FORWARD_INF,    "Redirect forward information"},         /* 8B */
/* 140 */  { JAPAN_ISUP_PARAM_REDIRECT_BACKWARD_INF,   "Redirect Backward information"},        /* 8C */

/* 192 */  { PARAM_TYPE_GENERIC_NR,                "Generic number"},
/* 193 */  { PARAM_TYPE_GENERIC_DIGITS,            "Generic digits (national use)"},
  { JAPAN_ISUP_PARAM_EMERGENCY_CALL_IND,      "Emergency Call indicator"},             /* 215 EC */
  { JAPAN_ISUP_PARAM_EMERGENCY_CALL_INF_IND,  "Emergency Call Information indicator"}, /* 236 EC */
  { JAPAN_ISUP_PARAM_NETWORK_POI_CA,          "Network POI-CA"},                       /* 238 EE */
  { JAPAN_ISUP_PARAM_TYPE_CARRIER_INFO,       "Carrier Information transfer"},         /* 241 F1 */
  { JAPAN_ISUP_PARAM_CHARGE_INF_DELAY,        "Charge Information Delay"},             /* 242 F2 */
  { JAPAN_ISUP_PARAM_TYPE_ADDITONAL_USER_CAT, "Additional party's category"},          /* 243 F3 */
  { JAPAN_ISUP_PARAM_REASON_FOR_CLIP_FAIL,    "Reason For CLIP Failure"},              /* 245 F5 */
  { JAPAN_ISUP_PARAM_TYPE_CONTRACTOR_NUMBER,  "Contractor Number"},                    /* 249 F9 */
  { JAPAN_ISUP_PARAM_TYPE_CHARGE_INF_TYPE,    "Charge information type"},              /* 250 FA */
  { JAPAN_ISUP_PARAM_TYPE_CHARGE_INF,         "Charge information"},                   /* 250 FA */
  { JAPAN_ISUP_PARAM_TYPE_CHARGE_AREA_INFO,   "Charge area information"},              /* 253 FD */

  { 0,                                 NULL}};
static value_string_ext japan_isup_parameter_type_value_ext = VALUE_STRING_EXT_INIT(japan_isup_parameter_type_value);

static const value_string ansi_isup_parameter_type_value[] = {
/*   0 */  { PARAM_TYPE_END_OF_OPT_PARAMS,         "End of optional parameters"},
/*   1 */  { PARAM_TYPE_CALL_REF,                  "Call Reference (national use)"},
/*   2 */  { PARAM_TYPE_TRANSM_MEDIUM_REQU,        "Transmission medium requirement"},
/*   3 */  { PARAM_TYPE_ACC_TRANSP,                "Access transport"},
/*   4 */  { PARAM_TYPE_CALLED_PARTY_NR,           "Called party number"},
/*   5 */  { PARAM_TYPE_SUBSQT_NR,                 "Subsequent number"},
/*   6 */  { PARAM_TYPE_NATURE_OF_CONN_IND,        "Nature of connection indicators"},
/*   7 */  { PARAM_TYPE_FORW_CALL_IND,             "Forward call indicators"},
/*   8 */  { PARAM_TYPE_OPT_FORW_CALL_IND,         "Optional forward call indicators"},
/*   9 */  { PARAM_TYPE_CALLING_PRTY_CATEG,        "Calling party's category"},
/*  10 */  { PARAM_TYPE_CALLING_PARTY_NR,          "Calling party number"},
/*  11 */  { PARAM_TYPE_REDIRECTING_NR,            "Redirecting number"},
/*  12 */  { PARAM_TYPE_REDIRECTION_NR,            "Redirection number"},
/*  13 */  { PARAM_TYPE_CONNECTION_REQ,            "Connection request"},
/*  14 */  { PARAM_TYPE_INFO_REQ_IND,              "Information request indicators (national use)"},
/*  15 */  { PARAM_TYPE_INFO_IND,                  "Information indicators (national use)"},
/*  16 */  { PARAM_TYPE_CONTINUITY_IND,            "Continuity request"},
/*  17 */  { PARAM_TYPE_BACKW_CALL_IND,            "Backward call indicators"},
/*  18 */  { PARAM_TYPE_CAUSE_INDICATORS,          "Cause indicators"},
/*  19 */  { PARAM_TYPE_REDIRECTION_INFO,          "Redirection information"},
/*  20 */  { 20,                                   "Not used"},
/*  21 */  { PARAM_TYPE_CIRC_GRP_SV_MSG_TYPE,      "Circuit group supervision message type"},
/*  22 */  { PARAM_TYPE_RANGE_AND_STATUS,          "Range and Status"},
/*  23 */  { 23,                                   "Not used"},
/*  24 */  { PARAM_TYPE_FACILITY_IND,              "Facility indicator"},
/*  25 */  { 25,                                   "Not used"},
/*  26 */  { PARAM_TYPE_CLSD_USR_GRP_ILOCK_CD,     "Closed user group interlock code"},
/*  27 */  { 27,                                   "Not used"},
/*  28 */  { 28,                                   "Not used"},
/*  29 */  { PARAM_TYPE_USER_SERVICE_INFO,         "User service information"},
/*  30 */  { PARAM_TYPE_SIGNALLING_POINT_CODE,     "Signalling point code (national use)"},
/*  31 */  { 31,                                   "Not used"},
/*  32 */  { PARAM_TYPE_USER_TO_USER_INFO,         "User-to-user information"},
/*  33 */  { PARAM_TYPE_CONNECTED_NR,              "Connected number"},
/*  34 */  { PARAM_TYPE_SUSP_RESUME_IND,           "Suspend/Resume indicators"},
/*  35 */  { PARAM_TYPE_TRANSIT_NETW_SELECT,       "Transit network selection (national use)"},
/*  36 */  { PARAM_TYPE_EVENT_INFO,                "Event information"},
/*  37 */  { PARAM_TYPE_CIRC_ASSIGN_MAP,           "Circuit assignment map"},
/*  38 */  { PARAM_TYPE_CIRC_STATE_IND,            "Circuit state indicator (national use)"},
/*  39 */  { PARAM_TYPE_AUTO_CONG_LEVEL,           "Automatic congestion level"},
/*  40 */  { PARAM_TYPE_ORIG_CALLED_NR,            "Original called number"},
/*  41 */  { PARAM_TYPE_OPT_BACKW_CALL_IND,        "Backward call indicators"},
/*  42 */  { PARAM_TYPE_USER_TO_USER_IND,          "User-to-user indicators"},
/*  43 */  { PARAM_TYPE_ORIG_ISC_POINT_CODE,       "Origination ISC point code"},
/*  44 */  { PARAM_TYPE_GENERIC_NOTIF_IND,         "Generic notification indicator"},
/*  45 */  { PARAM_TYPE_CALL_HIST_INFO,            "Call history information"},
/*  46 */  { PARAM_TYPE_ACC_DELIV_INFO,            "Access delivery information"},
/*  47 */  { PARAM_TYPE_NETW_SPECIFIC_FACLTY,      "Network specific facility (national use)"},
/*  48 */  { PARAM_TYPE_USER_SERVICE_INFO_PR,      "User service information prime"},
/*  49 */  { PARAM_TYPE_PROPAG_DELAY_COUNTER,      "Propagation delay counter"},
/*  50 */  { PARAM_TYPE_REMOTE_OPERATIONS,         "Remote operations (national use)"},
/*  51 */  { PARAM_TYPE_SERVICE_ACTIVATION,        "Service activation"},
/*  52 */  { PARAM_TYPE_USER_TELESERV_INFO,        "User teleservice information"},
/*  53 */  { PARAM_TYPE_TRANSM_MEDIUM_USED,        "Transmission medium used"},
/*  54 */  { PARAM_TYPE_CALL_DIV_INFO,             "Call diversion information"},
/*  55 */  { PARAM_TYPE_ECHO_CTRL_INFO,            "Echo control information"},
/*  56 */  { PARAM_TYPE_MSG_COMPAT_INFO,           "Message compatibility information"},
/*  57 */  { PARAM_TYPE_PARAM_COMPAT_INFO,         "Parameter compatibility information"},
/*  58 */  { PARAM_TYPE_MLPP_PRECEDENCE,           "MLPP precedence"},
/*  59 */  { PARAM_TYPE_MCID_REQ_IND,              "MCID request indicators"},
/*  60 */  { PARAM_TYPE_MCID_RSP_IND,              "MCID response indicators"},
/*  61 */  { PARAM_TYPE_HOP_COUNTER,               "Hop counter"},
/*  62 */  { PARAM_TYPE_TRANSM_MEDIUM_RQUR_PR,     "Transmission medium requirement prime"},
/*  63 */  { PARAM_TYPE_LOCATION_NR,               "Location number"},
/*  64 */  { PARAM_TYPE_REDIR_NR_RSTRCT,           "Redirection number restriction"},
/*  65 */  { 65,                                   "Not used"},
/*  66 */  { 66,                                   "Not used"},
/*  67 */  { PARAM_TYPE_CALL_TRANS_REF,            "Call transfer reference"},
/*  68 */  { PARAM_TYPE_LOOP_PREV_IND,             "Loop prevention indicators"},
/*  69 */  { PARAM_TYPE_CALL_TRANS_NR,             "Call transfer number"},
/*  70 */  { 70,                                   "Not used"},
/*  71 */  { 71,                                   "Not used"},
/*  72 */  { 72,                                   "Not used"},
/*  73 */  { 73,                                   "Not used"},
/*  74 */  { 74,                                   "Not used"},
/*  75 */  { PARAM_TYPE_CCSS,                      "CCSS"},
/*  76 */  { PARAM_TYPE_FORW_GVNS,                 "Forward GVNS"},
/*  77 */  { PARAM_TYPE_BACKW_GVNS,                "Backward GVNS"},
/*  78 */  { PARAM_TYPE_REDIRECT_CAPAB,            "Redirect capability (reserved for national use)"},
/*  79 */  { 79,                                   "Not used"},
/*  80 */  { 80,                                   "Not used"},
/*  81 */  { 81,                                   "Not used"},
/*  82 */  { 82,                                   "Not used"},
/*  83 */  { 83,                                   "Not used"},
/*  84 */  { 84,                                   "Not used"},
/*  85 */  { 85,                                   "Not used"},
/*  86 */  { 86,                                   "Not used"},
/*  87 */  { 87,                                   "Not used"},
/*  88 */  { 88,                                   "Not used"},
/*  89 */  { 89,                                   "Not used"},
/*  90 */  { 90,                                   "Not used"},
/* 101 */  { PARAM_TYPE_CORRELATION_ID,            "Correlation id"},
/* 102 */  { PARAM_TYPE_SCF_ID,                    "SCF id"},
/* 103 */  { 103,                                  "Not used"},
/* 104 */  { 104,                                  "Not used"},
/* 105 */  { 105,                                  "Not used"},
/* 106 */  { 106,                                  "Not used"},
/* 107 */  { 107,                                  "Not used"},
/* 108 */  { 108,                                  "Not used"},
/* 109 */  { 109,                                  "Not used"},
/* 110 */  { PARAM_TYPE_CALL_DIV_TREAT_IND,        "Call diversion treatment indicators"},
/* 111 */  { PARAM_TYPE_CALLED_IN_NR,              "Called IN number"},
/* 112 */  { PARAM_TYPE_CALL_OFF_TREAT_IND,        "Call offering treatment indicators"},
/* 113 */  { PARAM_TYPE_CHARGED_PARTY_IDENT,       "Charged party identification (national use)"},
/* 114 */  { PARAM_TYPE_CONF_TREAT_IND,            "Conference treatment indicators"},
/* 115 */  { PARAM_TYPE_DISPLAY_INFO,              "Display information"},
/* 116 */  { PARAM_TYPE_UID_ACTION_IND,            "UID action indicators"},
/* 117 */  { PARAM_TYPE_UID_CAPAB_IND,             "UID capability indicators"},
/* 119 */  { PARAM_TYPE_REDIRECT_COUNTER,          "Redirect counter (reserved for national use)"},
/* 120 */  { PARAM_TYPE_APPLICATON_TRANS,          "Application transport"},
/* 121 */  { PARAM_TYPE_COLLECT_CALL_REQ,          "Collect call request"},
/* 122 */  { 122,                                  "Not used"},
/* 123 */  { 123,                                  "Not used"},
/* 124 */  { 124,                                  "Not used"},
/* 125 */  { 125,                                  "Not used"},
/* 126 */  { 126,                                  "Not used"},
/* 127 */  { 127,                                  "Not used"},
/* 128 */  { 128,                                  "Not used"},
/* 129 */  { PARAM_TYPE_CALLING_GEODETIC_LOCATION, "Calling geodetic location"},
/* 130 */  { 130,                                  "Not used"},

/* 192 */  { PARAM_TYPE_GENERIC_NR,                "Generic number"},
/* 193 */  { PARAM_TYPE_GENERIC_DIGITS,            "Generic digits (national use)"},
#if 0 /* XXX: Dups of below */
  { PARAM_TYPE_JURISDICTION,              "Jurisdiction"},
  { PARAM_TYPE_GENERIC_NAME,              "Generic name"},
  { PARAM_TYPE_ORIG_LINE_INFO,            "Originating line info"},
#endif
/* 194 */  { ANSI_ISUP_PARAM_TYPE_OPER_SERV_INF,   "Operator Services information"},
/* 195 */  { ANSI_ISUP_PARAM_TYPE_EGRESS,          "Egress"},
/* 196 */  { ANSI_ISUP_PARAM_TYPE_JURISDICTION,    "Jurisdiction"},
/* 197 */  { ANSI_ISUP_PARAM_TYPE_CARRIER_ID,      "Carrier identification"},
/* 198 */  { ANSI_ISUP_PARAM_TYPE_BUSINESS_GRP,    "Business group"},
/* 199 */  { ANSI_ISUP_PARAM_TYPE_GENERIC_NAME,    "Generic name"},
/* 225 */  { ANSI_ISUP_PARAM_TYPE_NOTIF_IND,       "Notification indicator"},
  { ANSI_ISUP_PARAM_TYPE_CG_CHAR_IND,     "Circuit group characteristic indicator"},
  { ANSI_ISUP_PARAM_TYPE_CVR_RESP_IND,    "Circuit validation response indicator"},
  { ANSI_ISUP_PARAM_TYPE_OUT_TRK_GRP_NM,  "Outgoing trunk group number"},
  { ANSI_ISUP_PARAM_TYPE_CI_NAME_IND,     "Circuit identification name"},
  { ANSI_ISUP_PARAM_CLLI_CODE,            "COMMON LANGUAGE location identification (CLLI) code"},
  { ANSI_ISUP_PARAM_ORIG_LINE_INF,        "Originating line information"},
  { ANSI_ISUP_PARAM_CHRG_NO,              "Charge number"},
  { ANSI_ISUP_PARAM_SERV_CODE_IND,        "Service code indicator"},
  { ANSI_ISUP_PARAM_SPEC_PROC_REQ,        "Special processing request"},
  { ANSI_ISUP_PARAM_CARRIER_SEL_INF,      "Carrier selection information"},
  { ANSI_ISUP_PARAM_NET_TRANS,            "Network transport"},
  { 0,                                 NULL}};
static value_string_ext ansi_isup_parameter_type_value_ext = VALUE_STRING_EXT_INIT(ansi_isup_parameter_type_value);

#define CIC_LENGTH                             2
#define BICC_CIC_LENGTH                        4
#define MESSAGE_TYPE_LENGTH                    1
#define COMMON_HEADER_LENGTH                   (CIC_LENGTH + MESSAGE_TYPE_LENGTH)
#define BICC_COMMON_HEADER_LENGTH              (BICC_CIC_LENGTH + MESSAGE_TYPE_LENGTH)

#define MAXDIGITS                              32 /* Max number of address digits */
#define MAXGNAME                               15 /* Max number of characters in generic name */

#define PARAMETER_TYPE_LENGTH                  1
#define PARAMETER_POINTER_LENGTH               1
#define PARAMETER_LENGTH_IND_LENGTH            1

/* All following parameter length definitions are WITHOUT the parameter type byte and length indicator for optional parameters*/
#define PARAMETER_NAME_LENGTH                  1
#define PARAMETER_LENGTH_IND_LENGTH            1
#define ACCESS_DELIVERY_INFO_LENGTH            1
#define AUTO_CONGEST_LEVEL_LENGTH              1
#define BACKWARD_CALL_IND_LENGTH               2
#define BACKWARD_GVNS_LENGTH                   1
#define CALL_DIV_INFO_LENGTH                   1
#define CALL_DIV_TREATMENT_IND_LENGTH          1
#define CALL_HISTORY_INFO_LENGTH               2
#define CALL_OFFERING_TREATMENT_IND_LENGTH     1
#define CALL_REFERENCE_LENGTH                  5
#define CALL_TRANSFER_REF_LENGTH               1
#define CALLING_PRTYS_CATEGORY_LENGTH          1
#define CCSS_LENGTH                            1
#define CIRCUIT_ASSIGNMENT_MAP_LENGTH          5
#define CIRC_GRP_SV_MSG_TYPE_LENGTH            1
#define CLOSED_USR_GRP_INTERLOCK_CODE_LENGTH   4
#define COLLECT_CALL_REQUEST_LENGTH            1
#define CONFERENCE_TREATMENT_IND_LENGTH        1
#define CONNECTION_REQUEST_LENGTH              7
#define CONTINUITY_IND_LENGTH                  1
#define ECHO_CONTROL_INFO_LENGTH               1
#define END_OF_OPT_PART_LENGTH                 1
#define EVENT_INFO_LENGTH                      1
#define FACILITY_IND_LENGTH                    1
#define FORWARD_CALL_IND_LENGTH                2
#define GENERIC_NOTIFICATION_IND_LENGTH        1
#define HOP_COUNTER_LENGTH                     1
#define ORIG_LINE_INFO_LENGTH                  1
#define INFO_IND_LENGTH                        2
#define INFO_REQUEST_IND_LENGTH                2
#define LOOP_PREVENTION_IND_LENGTH             1
#define MCID_REQUEST_IND_LENGTH                1
#define MCID_RESPONSE_IND_LENGTH               1
#define MLPP_PRECEDENCE_LENGTH                 1
#define NATURE_OF_CONNECTION_IND_LENGTH        1
#define NETWORK_MANAGEMENT_CONTROLS_LENGTH     1
#define OPTIONAL_BACKWARD_CALL_IND_LENGTH      1
#define OPTIONAL_FORWARD_CALL_IND_LENGTH       1
#define ORIGINAL_ISC_POINT_CODE_LENGTH         2
#define PROPAGATION_DELAY_COUNT_LENGTH         2
#define REDIRECTION_NUMBER_LENGTH              2
#define REDIRECTION_INFO_LENGTH                2
#define REDIRECTION_NUMBER_RESTRICTION_LENGTH  1
#define SIGNALLING_POINT_CODE_LENGTH           2
#define SUSPEND_RESUME_IND_LENGTH              1
#define TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH 1
#define TRANSMISSION_MEDIUM_RQMT_PRIME_LENGTH  1
#define TRANSMISSION_MEDIUM_USED_LENGTH        1
#define UID_ACTION_IND_LENGTH                  1
#define UID_CAPABILITY_IND_LENGTH              1
#define USER_TELESERVICE_INFO_LENGTH           2
#define USER_TO_USER_IND_LENGTH                1
#define RANGE_LENGTH                           1

#define CVR_RESP_IND_LENGTH                    1
#define CG_CHAR_IND_LENGTH                     1
#define CI_NAME_IND                           28
#define CLLI_CODE_LENGTH                      13

#define CALL_ID_LENGTH        3 /* for parameter Call Reference */
#define SPC_LENGTH            2 /* for parameter Call Reference, Connection request */
#define LOCAL_REF_LENGTH      3 /* for parameter Connection request */
#define PROTOCOL_CLASS_LENGTH 1 /* for parameter Connection request */
#define CREDIT_LENGTH         1 /* for parameter Connection request */

#define CIC_OFFSET            0
#define BICC_CIC_OFFSET       0

#define NO_SATELLITE_CIRCUIT_IN_CONNECTION   0
#define ONE_SATELLITE_CIRCUIT_IN_CONNECTION  1
#define TWO_SATELLITE_CIRCUIT_IN_CONNECTION  2
static const value_string isup_satellite_ind_value[] = {
  { NO_SATELLITE_CIRCUIT_IN_CONNECTION,          "No Satellite circuit in connection"},
  { ONE_SATELLITE_CIRCUIT_IN_CONNECTION,         "One Satellite circuit in connection"},
  { TWO_SATELLITE_CIRCUIT_IN_CONNECTION,         "Two Satellite circuits in connection"},
  { 0,                                 NULL}};

#define CONTINUITY_CHECK_NOT_REQUIRED           0
#define CONTINUITY_CHECK_REQUIRED               1
#define CONTINUITY_CHECK_ON_A_PREVIOUS_CIRCUIT  2
#define CONTINUITY_CHECK_SPARE                  3
static const value_string isup_continuity_check_ind_value[] = {
  { CONTINUITY_CHECK_NOT_REQUIRED,               "Continuity check not required"},
  { CONTINUITY_CHECK_REQUIRED,                   "Continuity check required on this circuit"},
  { CONTINUITY_CHECK_ON_A_PREVIOUS_CIRCUIT ,     "Continuity check performed on a previous circuit"},
  { CONTINUITY_CHECK_SPARE ,                     "spare"},
  { 0,                                 NULL}};

static const value_string bicc_continuity_check_ind_value[] = {
  { CONTINUITY_CHECK_NOT_REQUIRED,               "no COT to be expected"},
  { CONTINUITY_CHECK_REQUIRED,                   "reserved"},
  { CONTINUITY_CHECK_ON_A_PREVIOUS_CIRCUIT ,     "COT to be expected"},
  { CONTINUITY_CHECK_SPARE ,                     "spare"},
  { 0,                                 NULL}};

static const true_false_string isup_echo_control_device_ind_value = {
  "Echo control device included",
  "Echo control device not included"
};

static const true_false_string isup_natnl_inatnl_call_ind_value = {
  "Call to be treated as international call",
  "Call to be treated as national call"
};

#define NO_END_TO_END_METHOD_AVAILABLE       0
#define PASS_ALONG_METHOD_AVAILABLE          1
#define SCCP_METHOD_AVAILABLE                2
#define PASS_ALONG_AND_SCCP_METHOD_AVAILABLE 3
static const value_string isup_end_to_end_method_ind_value[] = {
  { NO_END_TO_END_METHOD_AVAILABLE,          "No End-to-end method available (only link-by-link method available)"},
  { PASS_ALONG_METHOD_AVAILABLE,             "Pass-along method available (national use)"},
  { SCCP_METHOD_AVAILABLE,                   "SCCP method available"},
  { PASS_ALONG_AND_SCCP_METHOD_AVAILABLE,    "pass-along and SCCP method available (national use)"},
  { 0,                                 NULL}};

static const value_string bicc_end_to_end_method_ind_value[] = {
  { NO_END_TO_END_METHOD_AVAILABLE,          "No End-to-end method available (only link-by-link method available)"},
  { PASS_ALONG_METHOD_AVAILABLE,             "reserved"},
  { SCCP_METHOD_AVAILABLE,                   "reserved"},
  { PASS_ALONG_AND_SCCP_METHOD_AVAILABLE,    "reserved"},
  { 0,                                 NULL}};

static const true_false_string isup_interworking_ind_value = {
  "interworking encountered",
  "no interworking encountered (No.7 signalling all the way)"
};

static const true_false_string isup_end_to_end_info_ind_value = {
  "end-to-end information available",
  "no end-to-end information available"
};

static const true_false_string bicc_end_to_end_info_ind_value = {
    "reserved",
    "no end-to-end information available"
};

static const true_false_string ansi_isup_iam_seg_ind_value = {
  "Additional information has been received and incorporated into call set-up",
  "No Indication"
};

static const true_false_string isup_ISDN_user_part_ind_value = {
  "ISDN user part used all the way",
  "ISDN user part not used all the way"
};

static const true_false_string bicc_ISDN_user_part_ind_value = {
    "BICC used all the way",
    "BICC not used all the way"
};

#define ISUP_PREFERRED_ALL_THE_WAY              0
#define ISUP_NOT_REQUIRED_ALL_THE_WAY           1
#define ISUP_REQUIRED_ALL_WAY                   2
#define ISUP_ISDN_USER_PART_IND_SPARE           3
static const value_string isup_preferences_ind_value[] = {
  { ISUP_PREFERRED_ALL_THE_WAY,                  "ISDN user part preferred all the way"},
  { ISUP_NOT_REQUIRED_ALL_THE_WAY,               "ISDN user part not required all the way"},
  { ISUP_REQUIRED_ALL_WAY,                       "ISDN user part required all the way"},
  { ISUP_ISDN_USER_PART_IND_SPARE,               "spare"},
  { 0,                                 NULL}};

static const value_string bicc_preferences_ind_value[] = {
    { ISUP_PREFERRED_ALL_THE_WAY,                  "BICC preferred all the way"},
    { ISUP_NOT_REQUIRED_ALL_THE_WAY,               "BICC not required all the way"},
    { ISUP_REQUIRED_ALL_WAY,                       "BICC required all the way"},
    { ISUP_ISDN_USER_PART_IND_SPARE,               "spare"},
    { 0,                                 NULL}};

static const true_false_string isup_ISDN_originating_access_ind_value = {
  "originating access ISDN",
  "originating access non-ISDN"
};

static const true_false_string isup_ISDN_ported_num_trans_ind_value = {
  "number translated",
  "number not translated"
};

static const true_false_string isup_ISDN_qor_attempt_ind_value = {
  "QoR routing attempt in progress",
  "no QoR routing attempt in progress"
};

#define NO_INDICATION                                0
#define CONNECTIONLESS_METHOD_AVAILABLE              1
#define CONNECTION_ORIENTED_METHOD_AVAILABLE         2
#define CONNECTIONLESS_AND_ORIENTED_METHOD_AVAILABLE 3
static const value_string isup_SCCP_method_ind_value[] = {
  { NO_INDICATION,                                  "No indication"},
  { CONNECTIONLESS_METHOD_AVAILABLE,                "Connectionless method available (national use)"},
  { CONNECTION_ORIENTED_METHOD_AVAILABLE,           "Connection oriented method available"},
  { CONNECTIONLESS_AND_ORIENTED_METHOD_AVAILABLE,   "Connectionless and -oriented method available (national use)"},
  { 0,                                 NULL}};

static const value_string bicc_SCCP_method_ind_value[] = {
    { NO_INDICATION,                                  "No indication"},
    { CONNECTIONLESS_METHOD_AVAILABLE,                "reserved"},
    { CONNECTION_ORIENTED_METHOD_AVAILABLE,           "reserved"},
    { CONNECTIONLESS_AND_ORIENTED_METHOD_AVAILABLE,   "reserved"},
    { 0,                                 NULL}};

#define UNKNOWN_AT_THIS_TIME                 0
#define OPERATOR_FRENCH                      1
#define OPERATOR_ENGLISH                     2
#define OPERATOR_GERMAN                      3
#define OPERATOR_RUSSIAN                     4
#define OPERATOR_SPANISH                     5
#define ORDINARY_CALLING_SUBSCRIBER         10
#define CALLING_SUBSCRIBER_WITH_PRIORITY    11
#define DATA_CALL                           12
#define TEST_CALL                           13
#define PAYPHONE                            15
static const value_string isup_calling_partys_category_value[] = {
  { UNKNOWN_AT_THIS_TIME,               "Category unknown at this time (national use)"},
  { OPERATOR_FRENCH,                    "operator, language French"},
  { OPERATOR_ENGLISH,                   "operator, language English"},
  { OPERATOR_GERMAN,                    "operator, language German"},
  { OPERATOR_RUSSIAN,                   "operator, language Russian"},
  { OPERATOR_SPANISH,                   "operator, language Spanish"},

  { 6,                                  "available to Administrations"},
  { 7,                                  "available to Administrations"},
  { 8,                                  "available to Administrations"},
  { 9,                                  "reserved (national use)"},

  { ORDINARY_CALLING_SUBSCRIBER,        "ordinary calling subscriber"},
  { CALLING_SUBSCRIBER_WITH_PRIORITY,   "calling subscriber with priority"},
  { DATA_CALL,                          "data call (voice band data)"},
  { TEST_CALL,                          "test call"},
  /* q.763-200212Amd2 */
  { 14,                                 "IEPS call marking for preferential call set up"},
  { PAYPHONE,                           "payphone"},
  /* q.763-200212Amd3 */
  { 16,                                 "Mobile terminal located in the home PLMN"},
  { 17,                                 "Mobile terminal located in a visited PLMN"},
  { 0,                                 NULL}};
value_string_ext isup_calling_partys_category_value_ext = VALUE_STRING_EXT_INIT(isup_calling_partys_category_value);

static const value_string russian_isup_calling_partys_category_value[] = {
  { UNKNOWN_AT_THIS_TIME,               "Category unknown at this time (national use)"},
  { OPERATOR_FRENCH,                    "operator, language French"},
  { OPERATOR_ENGLISH,                   "operator, language English"},
  { OPERATOR_GERMAN,                    "operator, language German"},
  { OPERATOR_RUSSIAN,                   "operator, language Russian"},
  { OPERATOR_SPANISH,                   "operator, language Spanish"},

  { 6,                                  "Operator, language by mutual agreement by Administration"},
  { 7,                                  "Operator, language by mutual agreement by Administration"},
  { 8,                                  "Operator, language by mutual agreement by Administration"},
  { 9,                                  "National Operator"},

  { ORDINARY_CALLING_SUBSCRIBER,        "ordinary calling subscriber"},
  { CALLING_SUBSCRIBER_WITH_PRIORITY,   "calling subscriber with priority"},
  { DATA_CALL,                          "data call (voice band data)"},
  { TEST_CALL,                          "test call"},
  /* q.763-200212Amd2 */
  { 14,                                 "IEPS call marking for preferential call set up"},
  { PAYPHONE,                           "payphone"},
  /* q.763-200212Amd3 */
  { 16,                                 "Mobile terminal located in the home PLMN"},
  { 17,                                 "Mobile terminal located in a visited PLMN"},

  { 0xe0,                               "Reserved (Sub.Category 0)"},
  { 0xe1,                               "Hotel subscriber"},
  { 0xe2,                               "Charge free subscriber"},
  { 0xe3,                               "Subscriber with special service access"},
  { 0xe4,                               "Local subscriber"},
  { 0xe5,                               "Local coinbox"},
  { 0xf0,                               "Automatic call of category I"},
  { 0xf1,                               "Semiautomatic call of category I"},
  { 0xf2,                               "Automatic call of category II"},
  { 0xf3,                               "Semiautomatic call of category II"},
  { 0xf4,                               "Automatic call of category III"},
  { 0xf5,                               "Semiautomatic call of category III"},
  { 0xf6,                               "Automatic call of category IV"},
  { 0xf7,                               "Semiautomatic call of category IV"},

  { 0,                                 NULL}};
static value_string_ext russian_isup_calling_partys_category_value_ext = VALUE_STRING_EXT_INIT(russian_isup_calling_partys_category_value);

#define CVR_RSP_IND_FAILURE     0
#define CVR_RSP_IND_SUCCESS     1

static const value_string isup_cvr_rsp_ind_value[ ] = {
  { CVR_RSP_IND_FAILURE, "CVR Response Fail" },
  { CVR_RSP_IND_SUCCESS, "CVR Response Success" },
  { 0,                  NULL }
};

#define CVR_CG_IND_DOUBLE_SEIZE_NONE 0
#define CVR_CG_IND_DOUBLE_SEIZE_ODD  1
#define CVR_CG_IND_DOUBLE_SEIZE_EVEN 2
#define CVR_CG_IND_DOUBLE_SEIZE_ALL  3

static const value_string isup_cvr_cg_double_seize_value[ ] = {
  { CVR_CG_IND_DOUBLE_SEIZE_NONE, "Double Seize control NONE" },
  { CVR_CG_IND_DOUBLE_SEIZE_ODD,  "Double Seize control odd circuits"},
  { CVR_CG_IND_DOUBLE_SEIZE_EVEN, "Double Seize control even circuits"},
  { CVR_CG_IND_DOUBLE_SEIZE_ALL,  "Double Seize control all circuits"},
  {0, NULL }
};

#define CVR_CG_IND_CAR_IND_UNKNOWN      0
#define CVR_CG_IND_CAR_IND_ANALOG       1
#define CVR_CG_IND_CAR_IND_DIGITAL      2
#define CVR_CG_IND_CAR_IND_ANALOG_DIG   3

static const value_string isup_cvr_cg_car_ind_value[ ] = {
{ CVR_CG_IND_CAR_IND_UNKNOWN   , "Carrier Type Unknown" },
{ CVR_CG_IND_CAR_IND_ANALOG    , "Carrier Type Analog" },
{ CVR_CG_IND_CAR_IND_DIGITAL   , "Carrier Type Digital"},
{ CVR_CG_IND_CAR_IND_ANALOG_DIG, "Carrier Type Digital And Analog"},
{ 0, NULL }
};

#define CVR_CG_IND_ALARM_CAR_IND_UNKNOWN  0
#define CVR_CG_IND_ALARM_CAR_IND_SOFTWARE 1
#define CVR_CG_IND_ALARM_CAR_IND_HARDWARE 2
#define CVR_CG_IND_ALARM_CAR_IND_SPARE    3

static const value_string isup_cvr_alarm_car_ind_value[ ] = {
  { CVR_CG_IND_ALARM_CAR_IND_UNKNOWN    , "Alarm Carrier Ind Default"},
  { CVR_CG_IND_ALARM_CAR_IND_SOFTWARE   , "Alarm Carrier Ind Software"},
  { CVR_CG_IND_ALARM_CAR_IND_HARDWARE   , "Alarm Carrier Ind Hardware"},
  { CVR_CG_IND_ALARM_CAR_IND_SPARE      , "Alarm Carrier Ind Spare"},
  { 0, NULL }
};

#define CVR_CG_IND_CONT_CHK_UNKNOWN  0
#define CVR_CG_IND_CONT_CHK_NONE     1
#define CVR_CG_IND_CONT_CHK_STAT     2
#define CVR_CG_IND_CONT_CHK_PER_CALL 3

static const value_string isup_cvr_cont_chk_ind_value[ ] = {

  { CVR_CG_IND_CONT_CHK_UNKNOWN  , "Continuity Check Unknown"},
  { CVR_CG_IND_CONT_CHK_NONE     , "Continuity Check NONE"},
  { CVR_CG_IND_CONT_CHK_STAT     , "Continuity Check Statistical"},
  { CVR_CG_IND_CONT_CHK_PER_CALL , "Continuity Check Per Call"},
  { 0, NULL }
};

#define MEDIUM_SPEECH                        0
#define MEDIUM_64KBS                         2
#define MEDIUM_3_1_KHZ_AUDIO                 3
#define MEDIUM_RESERVED_SERVICE2_1           4
#define MEDIUM_RESERVED_SERVICE1_2           5
#define MEDIUM_64KBS_PREFERRED               6
#define MEDIUM_2_64KBS                       7
#define MEDIUM_384KBS                        8
#define MEDIUM_1536KBS                       9
#define MEDIUM_1920KBS                      10

#define MEDIUM_3_64KBS                      16
#define MEDIUM_4_64KBS                      17
#define MEDIUM_5_64KBS                      18

#define MEDIUM_7_64KBS                      20
#define MEDIUM_8_64KBS                      21
#define MEDIUM_9_64KBS                      22
#define MEDIUM_10_64KBS                     23
#define MEDIUM_11_64KBS                     24
#define MEDIUM_12_64KBS                     25
#define MEDIUM_13_64KBS                     26
#define MEDIUM_14_64KBS                     27
#define MEDIUM_15_64KBS                     28
#define MEDIUM_16_64KBS                     29
#define MEDIUM_17_64KBS                     30
#define MEDIUM_18_64KBS                     31
#define MEDIUM_19_64KBS                     32
#define MEDIUM_20_64KBS                     33
#define MEDIUM_21_64KBS                     34
#define MEDIUM_22_64KBS                     35
#define MEDIUM_23_64KBS                     36

#define MEDIUM_25_64KBS                     38
#define MEDIUM_26_64KBS                     39
#define MEDIUM_27_64KBS                     40
#define MEDIUM_28_64KBS                     41
#define MEDIUM_29_64KBS                     42

static const value_string isup_transmission_medium_requirement_value[] = {
  { MEDIUM_SPEECH,                       "speech"},
  { 1,                                   "spare"},
  { MEDIUM_64KBS,                        "64 kbit/s unrestricted"},
  { MEDIUM_3_1_KHZ_AUDIO,                "3.1 kHz audio"},
  { MEDIUM_RESERVED_SERVICE2_1,          "reserved for alternate speech (service 2)/64 kbit/s unrestricted (service 1)"},
  { MEDIUM_RESERVED_SERVICE1_2,          "reserved for alternate 64 kbit/s unrestricted (service 1)/speech (service 2)"},
  { MEDIUM_64KBS_PREFERRED,              "64 kbit/s preferred"},
  { MEDIUM_2_64KBS,                      "2x64 kbit/s unrestricted"},
  { MEDIUM_384KBS,                       "384 kbit/s unrestricted"},
  { MEDIUM_1536KBS,                      "1536 kbit/s unrestricted"},
  { MEDIUM_1920KBS,                      "1920 kbit/s unrestricted"},

  { 11,                                  "spare"},
  { 12,                                  "spare"},
  { 13,                                  "spare"},
  { 14,                                  "spare"},
  { 15,                                  "spare"},

  { MEDIUM_3_64KBS,                      "3x64 kbit/s unrestricted"},
  { MEDIUM_4_64KBS,                      "4x64 kbit/s unrestricted"},
  { MEDIUM_5_64KBS,                      "5x64 kbit/s unrestricted"},

  { 19,                                  "spare"},

  { MEDIUM_7_64KBS,                      "7x64 kbit/s unrestricted"},
  { MEDIUM_8_64KBS,                      "8x64 kbit/s unrestricted"},
  { MEDIUM_9_64KBS,                      "9x64 kbit/s unrestricted"},
  { MEDIUM_10_64KBS,                     "10x64 kbit/s unrestricted"},
  { MEDIUM_11_64KBS,                     "11x64 kbit/s unrestricted"},
  { MEDIUM_12_64KBS,                     "12x64 kbit/s unrestricted"},
  { MEDIUM_13_64KBS,                     "13x64 kbit/s unrestricted"},
  { MEDIUM_14_64KBS,                     "14x64 kbit/s unrestricted"},
  { MEDIUM_15_64KBS,                     "15x64 kbit/s unrestricted"},
  { MEDIUM_16_64KBS,                     "16x64 kbit/s unrestricted"},
  { MEDIUM_17_64KBS,                     "17x64 kbit/s unrestricted"},
  { MEDIUM_18_64KBS,                     "18x64 kbit/s unrestricted"},
  { MEDIUM_19_64KBS,                     "19x64 kbit/s unrestricted"},
  { MEDIUM_20_64KBS,                     "20x64 kbit/s unrestricted"},
  { MEDIUM_21_64KBS,                     "21x64 kbit/s unrestricted"},
  { MEDIUM_22_64KBS,                     "22x64 kbit/s unrestricted"},
  { MEDIUM_23_64KBS,                     "23x64 kbit/s unrestricted"},

  { 37,                                  "spare"},

  { MEDIUM_25_64KBS,                     "25x64 kbit/s unrestricted"},
  { MEDIUM_26_64KBS,                     "26x64 kbit/s unrestricted"},
  { MEDIUM_27_64KBS,                     "27x64 kbit/s unrestricted"},
  { MEDIUM_28_64KBS,                     "28x64 kbit/s unrestricted"},
  { MEDIUM_29_64KBS,                     "29x64 kbit/s unrestricted"},
  { 0,                                 NULL}};
value_string_ext isup_transmission_medium_requirement_value_ext = VALUE_STRING_EXT_INIT(isup_transmission_medium_requirement_value);

static const value_string isup_transmission_medium_requirement_prime_value[] = {
  { MEDIUM_SPEECH,                       "speech"},
  { 1,                                   "spare"},
  { MEDIUM_64KBS,                        "reserved for 64 kbit/s unrestricted"},
  { MEDIUM_3_1_KHZ_AUDIO,                "3.1 kHz audio"},
  { MEDIUM_RESERVED_SERVICE2_1,          "reserved for alternate speech (service 2)/64 kbit/s unrestricted (service 1)"},
  { MEDIUM_RESERVED_SERVICE1_2,          "reserved for alternate 64 kbit/s unrestricted (service 1)/speech (service 2)"},
  { MEDIUM_64KBS_PREFERRED,              "reserved for 64 kbit/s preferred"},
  { MEDIUM_2_64KBS,                      "reserved for 2x64 kbit/s unrestricted"},
  { MEDIUM_384KBS,                       "reserved for 384 kbit/s unrestricted"},
  { MEDIUM_1536KBS,                      "reserved for 1536 kbit/s unrestricted"},
  { MEDIUM_1920KBS,                      "reserved for 1920 kbit/s unrestricted"},
  { 0,                                 NULL}};
static value_string_ext isup_transmission_medium_requirement_prime_value_ext = VALUE_STRING_EXT_INIT(isup_transmission_medium_requirement_prime_value);


/* Definitions for Called and Calling Party number */
#define ISUP_ODD_EVEN_MASK                       0x80
#define ISUP_NATURE_OF_ADDRESS_IND_MASK          0x7F
#define ISUP_INN_MASK                            0x80
#define ISUP_NI_MASK                             0x80
#define ISUP_NUMBERING_PLAN_IND_MASK             0x70
#define ISUP_ADDRESS_PRESENTATION_RESTR_IND_MASK 0x0C
#define ISUP_SCREENING_IND_MASK                  0x03
#define ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK       0x0F
#define ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK      0xF0

static const true_false_string isup_odd_even_ind_value = {
  "odd number of address signals",
  "even number of address signals"
};

#define ISUP_CALLED_PARTY_NATURE_SUBSCRIBER_NR  1
#define ISUP_CALLED_PARTY_NATURE_UNKNOWN        2
#define ISUP_CALLED_PARTY_NATURE_NATIONAL_NR    3
#define ISUP_CALLED_PARTY_NATURE_INTERNATNL_NR  4
#define ISUP_CALLED_PARTY_NATURE_NETW_SPEC_NR   5

#define ISUP_CHARGE_NATURE_ANI_CGPA_SUB_NR      1
#define ISUP_CHARGE_NATURE_ANI_NA               2
#define ISUP_CHARGE_NATURE_ANI_CGPA_NAT_NR      3
#define ISUP_CHARGE_NATURE_ANI_CDPA_SUB_NR      5
#define ISUP_CHARGE_NATURE_ANI_CDPA_NO_NR       6
#define ISUP_CHARGE_NATURE_ANI_CDPA_NAT_NR      7

static const value_string isup_called_party_nature_of_address_ind_value[] = {
  { ISUP_CALLED_PARTY_NATURE_SUBSCRIBER_NR,     "subscriber number (national use)"},
  { ISUP_CALLED_PARTY_NATURE_UNKNOWN,           "unknown (national use)"},
  { ISUP_CALLED_PARTY_NATURE_NATIONAL_NR,       "national (significant) number"},
  { ISUP_CALLED_PARTY_NATURE_INTERNATNL_NR,     "international number"},
  { ISUP_CALLED_PARTY_NATURE_NETW_SPEC_NR,      "network-specific number (national use)"},
  { 0,                                 NULL}};

static const value_string isup_calling_party_nature_of_address_ind_value[] = {
  { ISUP_CALLED_PARTY_NATURE_SUBSCRIBER_NR,     "subscriber number (national use)"},
  { ISUP_CALLED_PARTY_NATURE_UNKNOWN,           "unknown (national use)"},
  { ISUP_CALLED_PARTY_NATURE_NATIONAL_NR,       "national (significant) number"},
  { ISUP_CALLED_PARTY_NATURE_INTERNATNL_NR,     "international number"},
  { 5,                                          "PISN specific number"},
  { 0,                                 NULL}};

static const value_string isup_charge_number_nature_of_address_ind_value[] = {
  { ISUP_CHARGE_NATURE_ANI_CGPA_SUB_NR,  "ANI of the calling party; subscriber number"},
  { ISUP_CHARGE_NATURE_ANI_NA,           "ANI not available or not provided"},
  { ISUP_CHARGE_NATURE_ANI_CGPA_NAT_NR,  "ANI of the calling party; national number"},
  { ISUP_CHARGE_NATURE_ANI_CDPA_SUB_NR,  "ANI of the called party; subscriber number"},
  { ISUP_CHARGE_NATURE_ANI_CDPA_NO_NR,   "ANI of the called party; no number present"},
  { ISUP_CHARGE_NATURE_ANI_CDPA_NAT_NR,  "ANI of the called party; national number"},
  { 0,                                 NULL}};

#define ISUP_GENERIC_NAME_PRESENTATION_ALLOWED          0
#define ISUP_GENERIC_NAME_PRESENTATION_RESTRICT         1
#define ISUP_GENERIC_NAME_PRESENTATION_BLOCK_TOGGLE     2
#define ISUP_GENERIC_NAME_PRESENTATION_NO_INDIC         3
#define ISUP_GENERIC_NAME_TYPE_SPARE                    0
#define ISUP_GENERIC_NAME_TYPE_CALLING                  1
#define ISUP_GENERIC_NAME_TYPE_ORIG_CALLED              2
#define ISUP_GENERIC_NAME_TYPE_REDIRECTING              3
#define ISUP_GENERIC_NAME_TYPE_CONNECTED                4

static const value_string isup_generic_name_presentation_value[] = {
  { ISUP_GENERIC_NAME_PRESENTATION_ALLOWED,             "presentation allowed"},
  { ISUP_GENERIC_NAME_PRESENTATION_RESTRICT,            "presentation restricted"},
  { ISUP_GENERIC_NAME_PRESENTATION_BLOCK_TOGGLE,        "blocking toggle"},
  { ISUP_GENERIC_NAME_PRESENTATION_NO_INDIC,            "no indication"},
  { 0,                                 NULL}};

static const true_false_string isup_generic_name_availability_value = {
  "name not available",
  "name available/unknown"
};

static const value_string isup_generic_name_type_value[] = {
  { ISUP_GENERIC_NAME_TYPE_SPARE,               "spare"},
  { ISUP_GENERIC_NAME_TYPE_CALLING,             "calling name"},
  { ISUP_GENERIC_NAME_TYPE_ORIG_CALLED,         "original called name"},
  { ISUP_GENERIC_NAME_TYPE_REDIRECTING,         "redirecting name"},
  { ISUP_GENERIC_NAME_TYPE_CONNECTED,           "connected name"},
  { 5,                                          "spare"},
  { 6,                                          "spare"},
  { 7,                                          "spare"},
  { 0,                                 NULL}};

static const true_false_string isup_INN_ind_value = {
  "routing to internal network number not allowed",
  "routing to internal network number allowed"
};
static const true_false_string isup_NI_ind_value = {
  "incomplete",
  "complete"
};

static const value_string isup_location_presentation_restricted_ind_value[] = {
  { 0,                                 "presentation allowed"},
  { 1,                                 "presentation restricted"},
  { 2,                                 "location not available"},
  { 3,                                 "spare"},
  { 0,                                 NULL}};

static const value_string isup_location_type_of_shape_value[] = {
  { 0,          "ellipsoid point"},
  { 1,          "ellipsoid point with uncertainty"},
  { 2,          "point with altitude and uncertainty"},
  { 3,          "ellipse on the ellipsoid"},
  { 4,          "ellipsoid circle sector"},
  { 5,          "polygon"},
  { 0,          NULL}};

#define ISDN_NUMBERING_PLAN                     1
#define DATA_NUMBERING_PLAN                     3
#define TELEX_NUMBERING_PLAN                    4
static const value_string isup_numbering_plan_ind_value[] = {
  { 0,                       "Unknown (national use)"},
  { ISDN_NUMBERING_PLAN,     "ISDN (Telephony) numbering plan ITU-T E.164"},
  { DATA_NUMBERING_PLAN,     "Data numbering plan ITU-T X.121(national use)"},
  { TELEX_NUMBERING_PLAN,    "Telex numbering plan ITU-T F.69(national use)"},
  { 5,                       "Private numbering plan (national use)"},
  { 6,                       "Reserved for national use"},
  { 0,                        NULL}};

#define ADDRESS_PRESETATION_ALLOWED      0
#define ADDRESS_PRESETATION_RESTRICTED   1
#define ADDRESS_NOT_AVAILABLE            2
static const value_string isup_address_presentation_restricted_ind_value[] = {
  { ADDRESS_PRESETATION_ALLOWED,     "presentation allowed"},
  { ADDRESS_PRESETATION_RESTRICTED,  "presentation restricted"},
  { ADDRESS_NOT_AVAILABLE,           "address not available (national use)"},
  { 3,                                 "spare"},
  { 0,                                 NULL}};

static const value_string isup_screening_ind_value[] = {
  { 0,     "reserved"},
  { 1,     "user provided, verified and passed"},
  { 2,     "reserved"},
  { 3,     "network provided"},
  { 0,     NULL}};

static const value_string isup_screening_ind_enhanced_value[] = {
  { 0,     "user provided, not verified"},
  { 1,     "user provided, verified and passed"},
  { 2,     "user provided, verified and failed"},
  { 3,     "network provided"},
  { 0,     NULL}};

static const value_string isup_called_party_address_digit_value[] = {
  {  0, "0"},
  {  1, "1"},
  {  2, "2"},
  {  3, "3"},
  {  4, "4"},
  {  5, "5"},
  {  6, "6"},
  {  7, "7"},
  {  8, "8"},
  {  9, "9"},
  { 10, "spare"},
  { 11, "code 11 "},
  { 12, "code 12"},
  { 15, "Stop sending"},
  { 0,  NULL}};
static value_string_ext isup_called_party_address_digit_value_ext = VALUE_STRING_EXT_INIT(isup_called_party_address_digit_value);

static const value_string isup_calling_party_address_digit_value[] = {
  {  0, "0"},
  {  1, "1"},
  {  2, "2"},
  {  3, "3"},
  {  4, "4"},
  {  5, "5"},
  {  6, "6"},
  {  7, "7"},
  {  8, "8"},
  {  9, "9"},
  { 10, "spare"},
  { 11, "code 11 "},
  { 12, "code 12"},
  { 15, "spare"},
  { 0,  NULL}};
static value_string_ext isup_calling_party_address_digit_value_ext = VALUE_STRING_EXT_INIT(isup_calling_party_address_digit_value);

/*End of Called/Calling party address definitions */

 /* Japan ISUP*/
/*******************************/
/*    CARRIER INFORMATION      */
/*******************************/

/*         IEC INDICATOR       */
#define CARRIER_INFO_IEC_NO_TRANSFER                   0
#define CARRIER_INFO_IEC_TRANSFER_FORW                 1
#define CARRIER_INFO_IEC_TRANSFER_BACK                 2
#define CARRIER_INFO_IEC_TRANSFER_BOTH_DIR             3
static const value_string isup_carrier_info_iec_indic_value[] = {
  { CARRIER_INFO_IEC_NO_TRANSFER,       "No transfer"},
  { CARRIER_INFO_IEC_TRANSFER_FORW,     "Transfer in forward direction"},
  { CARRIER_INFO_IEC_TRANSFER_BACK,     "Transfer in backward direction"},
  { CARRIER_INFO_IEC_TRANSFER_BOTH_DIR, "Transfer in both directions"},
  { 0, NULL}};


/*      CATEGORY OF CARRIER    */
#define CARRIER_INFO_CATEGORY_SCPC               0xFA
#define CARRIER_INFO_CATEGORY_OLEC               0xFB
#define CARRIER_INFO_CATEGORY_TLEC               0xFC
#define CARRIER_INFO_CATEGORY_CIEC               0xFD
#define CARRIER_INFO_CATEGORY_IEC                0xFE
#define CARRIER_INFO_CATEGORY_SPARE              0xFF
static const value_string isup_carrier_info_category_value[] = {
  { CARRIER_INFO_CATEGORY_SCPC,  "(Service Control Point Carrier)"},
  { CARRIER_INFO_CATEGORY_OLEC,  "(Originating Local Exchange Carrier)"},
  { CARRIER_INFO_CATEGORY_TLEC,  "(Terminating Local Exchange Carrier)"},
  { CARRIER_INFO_CATEGORY_CIEC,  "(Chosen Inter|Exchange Carrier)"},
  { CARRIER_INFO_CATEGORY_IEC,   "(Inter|Exchange Carrier)"},
  { CARRIER_INFO_CATEGORY_SPARE, "Spare"},
  { 0, NULL}};
static value_string_ext isup_carrier_info_category_vals_ext = VALUE_STRING_EXT_INIT(isup_carrier_info_category_value);

/* TYPE OF CARRIER INFORMATION */
#define CARRIER_INFO_TYPE_OF_CARRIER_POIHIE      0xFC
#define CARRIER_INFO_TYPE_OF_CARRIER_POICA       0xFD
#define CARRIER_INFO_TYPE_OF_CARRIER_CARID       0xFE
#define CARRIER_INFO_TYPE_OF_CARRIER_SPARE       0xFF
static const value_string isup_carrier_info_type_of_carrier_value[] = {
  { CARRIER_INFO_TYPE_OF_CARRIER_POIHIE, "POI Hierarchy information"},
  { CARRIER_INFO_TYPE_OF_CARRIER_POICA,  "POI|CA information (Charge Area)"},
  { CARRIER_INFO_TYPE_OF_CARRIER_CARID,  "Carrier identification (ID) code"},
  { CARRIER_INFO_TYPE_OF_CARRIER_SPARE,  "Spare"},
  { 0, NULL}};
static value_string_ext isup_carrier_info_type_of_carrier_vals_ext = VALUE_STRING_EXT_INIT(isup_carrier_info_type_of_carrier_value);

/* POI/HIE */
#define CARRIER_INFO_POIHIE_NOINDIC              0
#define CARRIER_INFO_POIHIE_HIE1                 1
#define CARRIER_INFO_POIHIE_HIE2                 2
static const value_string isup_carrier_info_poihie_value[] = {
  { CARRIER_INFO_POIHIE_NOINDIC, "No indication"},
  { CARRIER_INFO_POIHIE_HIE1,    "Hierarchy level 1"},
  { CARRIER_INFO_POIHIE_HIE2,    "Hierarchy level 2"},
  { 0, NULL}};

#if 0
/* POICA */
/* ODD/EVEN */
#define CARRIER_INFO_CA_OE_0                  0
#define CARRIER_INFO_CA_OE_1                  1
static const value_string isup_carrier_info_poica_oe_value[] = {
  { CARRIER_INFO_CA_OE_0, "Reserved"},
  { CARRIER_INFO_CA_OE_1, "Odd number of charge area digits"},
  { 0, NULL}};
#endif

#if 0
/* CARID */
/* ODD/EVEN */
#define CARRIER_INFO_CARID_OE_0                  0
#define CARRIER_INFO_CARID_OE_1                  1
static const value_string isup_carrier_info_carid_oe_value[] = {
  { CARRIER_INFO_CARID_OE_0, "Even number of ID code digits"},
  { CARRIER_INFO_CARID_OE_1, "Odd number of ID code digits"},
  { 0, NULL}};
#endif

/* CARRIER INFORMATION DIGITS */
#define CARRIER_INFO_DIGIT_0                  0
#define CARRIER_INFO_DIGIT_1                  1
#define CARRIER_INFO_DIGIT_2                  2
#define CARRIER_INFO_DIGIT_3                  3
#define CARRIER_INFO_DIGIT_4                  4
#define CARRIER_INFO_DIGIT_5                  5
#define CARRIER_INFO_DIGIT_6                  6
#define CARRIER_INFO_DIGIT_7                  7
#define CARRIER_INFO_DIGIT_8                  8
#define CARRIER_INFO_DIGIT_9                  9
static const value_string isup_carrier_info_digits_value[] = {
  { CARRIER_INFO_DIGIT_0, "Digit 0"},
  { CARRIER_INFO_DIGIT_1, "Digit 1"},
  { CARRIER_INFO_DIGIT_2, "Digit 2"},
  { CARRIER_INFO_DIGIT_3, "Digit 3"},
  { CARRIER_INFO_DIGIT_4, "Digit 4"},
  { CARRIER_INFO_DIGIT_5, "Digit 5"},
  { CARRIER_INFO_DIGIT_6, "Digit 6"},
  { CARRIER_INFO_DIGIT_7, "Digit 7"},
  { CARRIER_INFO_DIGIT_8, "Digit 8"},
  { CARRIER_INFO_DIGIT_9, "Digit 9"},
  { 0, NULL}};

/*******************************/
/*    CHARGE AREA INFORMATION  */
/*******************************/
#if 0
/* ODD/EVEN */
#define CHARGE_AREA_INFO_OE_0                  0
#define CHARGE_AREA_INFO_OE_1                  1
static const value_string isup_charge_area_info_oe_value[] = {
  { CHARGE_AREA_INFO_OE_0, "Even number of Charge Area digits"},
  { CHARGE_AREA_INFO_OE_1, "Odd number of Charge Area code digits"},
  { 0, NULL}};
#endif

#define CHARGE_AREA_NAT_INFO_MA                0
#define CHARGE_AREA_NAT_INFO_CA                1
static const value_string isup_charge_area_info_nat_of_info_value[] = {
  { CHARGE_AREA_NAT_INFO_MA, "MA code (and optionally NC)"},
  { CHARGE_AREA_NAT_INFO_CA, "CA code"},
  { 0, NULL}};

static const true_false_string isup_calling_party_address_request_ind_value = {
  "calling party address requested",
  "calling party address not requested"
};
static const true_false_string isup_holding_ind_value = {
  "holding requested/(ANSI)holding required (No procedure specified for U.S. networks)",
  "holding not requested/(ANSI)holding not required"
};
static const true_false_string isup_calling_partys_category_request_ind_value = {
  "Calling Party's category requested",
  "Calling Party's category not requested",
};
static const true_false_string isup_charge_information_request_ind_value = {
  "Charge Information requested",
  "Charge Information not requested"
};
static const true_false_string isup_malicious_call_identification_request_ind_value = {
  "Malicious call identification requested",
  "Malicious call identification not requested"
};

#define CALLING_PARTY_ADDRESS_NOT_INCLUDED             0
#define CALLING_PARTY_ADDRESS_NOT_AVAILABLE            1
#define CALLING_PARTY_ADDRESS_INCLUDED                 3
static const value_string isup_calling_party_address_response_ind_value[] = {
  { CALLING_PARTY_ADDRESS_NOT_INCLUDED,  "Calling party address not included"},
  { CALLING_PARTY_ADDRESS_NOT_AVAILABLE, "Calling party address not available"},
  { 4,                                   "spare"},
  { CALLING_PARTY_ADDRESS_INCLUDED,      "Calling party address included"},
  { 0,                                 NULL}};

static const true_false_string isup_hold_provided_ind_value = {
  "hold provided",
  "hold not provided"
};
static const true_false_string isup_calling_partys_category_response_ind_value = {
  "Calling Party's category included",
  "Calling Party's category not included",
};
static const true_false_string isup_charge_information_response_ind_value = {
  "Charge Information included",
  "Charge Information not included"
};
static const true_false_string isup_solicited_information_ind_value = {
  "unsolicited",
  "solicited"
};

static const true_false_string isup_continuity_ind_value = {
  "Continuity check successful",
  "Continuity check failed"
};

#define CHARGE_NO_IND       0
#define CHARGE_NO_CHARGE    1
#define CHARGE_CHARGE       2
static const value_string isup_charge_ind_value[] = {
  { CHARGE_NO_IND,    "No indication"},
  { CHARGE_NO_CHARGE, "No charge"},
  { CHARGE_CHARGE,    "Charge"},
  { 3,                "spare"},
  { 0,                NULL}};

#define CALLED_PARTYS_STATUS_NO_IND            0
#define CALLED_PARTYS_STATUS_SUBSCR_FREE       1
#define CALLED_PARTYS_STATUS_CONNECT_WHEN_FREE 2
static const value_string isup_called_partys_status_ind_value[] = {
  { CALLED_PARTYS_STATUS_NO_IND,            "No indication"},
  { CALLED_PARTYS_STATUS_SUBSCR_FREE,       "Subscriber free"},
  { CALLED_PARTYS_STATUS_CONNECT_WHEN_FREE, "Connect when free (national use)"},
  { 3,                                      "spare"},
  { 0,                NULL}};

#define CALLED_PARTYS_CATEGORY_NO_IND            0
#define CALLED_PARTYS_CATEGORY_ORDINARY_SUBSCR   1
#define CALLED_PARTYS_CATEGORY_PAYPHONE          2
static const value_string isup_called_partys_category_ind_value[] = {
  { CALLED_PARTYS_CATEGORY_NO_IND,             "No indication"},
  { CALLED_PARTYS_CATEGORY_ORDINARY_SUBSCR,    "Ordinary subscriber"},
  { CALLED_PARTYS_CATEGORY_PAYPHONE,           "Payphone"},
  { 3,                                         "spare"},
  { 0,                NULL}};

static const true_false_string isup_ISDN_terminating_access_ind_value = {
  "terminating access ISDN",
  "terminating access non-ISDN"
};

static const true_false_string isup_suspend_resume_ind_value = {
  "network initiated",
  "ISDN subscriber initiated"
};
#define MAINTENANCE            0
#define HARDWARE_FAILURE       1
#define RES_FOR_NATNL_USE      2
static const value_string isup_cgs_message_type_value[] = {
  { MAINTENANCE,            "maintenance oriented"},
  { HARDWARE_FAILURE,       "hardware failure oriented"},
  { RES_FOR_NATNL_USE,      "reserved for national use (ISUP'84)"},
  { 3,                      "spare"},
  { 0,                NULL}};

#define USER_TO_USER_SERVICE      2
static const value_string isup_facility_ind_value[] = {
  { USER_TO_USER_SERVICE,     "user-to-user service"},
  { 0,                NULL}};

#define MTC_BLCK_STATE_TRANSIENT  0
#define MTC_BLCK_STATE_UNEQUIPPED 3
static const value_string isup_mtc_blocking_state_DC00_value[] = {
  {  MTC_BLCK_STATE_TRANSIENT,  "transient"},
  { 1,                          "spare"},
  { 2,                          "spare"},
  {  MTC_BLCK_STATE_UNEQUIPPED, "unequipped"},
  { 0,                NULL}};

#define MTC_BLCK_NO_BLOCKING      0
#define MTC_LOCALLY_BLOCKED       1
#define MTC_REMOTELY_BLOCKED      2
#define MTC_LOCAL_REMOTE_BLOCKED  3
static const value_string isup_mtc_blocking_state_DCnot00_value[] = {
  {  MTC_BLCK_NO_BLOCKING,     "no blocking (active)"},
  {  MTC_LOCALLY_BLOCKED,      "locally blocked"},
  {  MTC_REMOTELY_BLOCKED,     "remotely blocked"},
  {  MTC_LOCAL_REMOTE_BLOCKED, "locally and remotely blocked"},
  {  0,                NULL}};

#define CALL_PROC_INCOMING_BUSY 1
#define CALL_PROC_OUTGOING_BUSY 2
#define CALL_PROC_IDLE          3
static const value_string isup_call_processing_state_value[] = {
  {  CALL_PROC_INCOMING_BUSY,     "circuit incoming busy"},
  {  CALL_PROC_OUTGOING_BUSY,     "circuit outgoing busy"},
  {  CALL_PROC_IDLE,              "idle"},
  {  0,                NULL}};

#define HW_BLCK_NO_BLOCKING          0
#define HW_LOCALLY_BLOCKED           1
#define HW_REMOTELY_BLOCKED          2
#define HW_LOCAL_REMOTE_BLOCKED      3
static const value_string isup_HW_blocking_state_value[] = {
  {  HW_BLCK_NO_BLOCKING,     "no blocking (active)"},
  {  HW_LOCALLY_BLOCKED,      "locally blocked"},
  {  HW_REMOTELY_BLOCKED,     "remotely blocked"},
  {  HW_LOCAL_REMOTE_BLOCKED, "locally and remotely blocked"},
  {  0,                NULL}};

#define EVENT_ALERTING      1
#define EVENT_PROGRESS      2
#define EVENT_INBAND_INFO   3
#define EVENT_ON_BUSY       4
#define EVENT_ON_NO_REPLY   5
#define EVENT_UNCONDITIONAL 6
static const value_string isup_event_ind_value[] = {
  /* according 3.21/Q.763 */
  {  EVENT_ALERTING,      "ALERTING"},
  {  EVENT_PROGRESS,      "PROGRESS"},
  {  EVENT_INBAND_INFO,   "in-band information or an appropriate pattern is now available"},
  {  EVENT_ON_BUSY,       "call forwarded on busy (national use)"},
  {  EVENT_ON_NO_REPLY,   "call forwarded on no reply (national use)"},
  {  EVENT_UNCONDITIONAL, "call forwarded unconditional (national use)"},
  {  0,                NULL}};

static const true_false_string isup_event_presentation_restricted_ind_value = {
  /* according 3.21/Q.763 */
  "presentation restricted",
  "no indication"
};
#define CUG_NON_CUG_CALL                      0
#define CUG_CALL_OUTGOING_ACCESS_ALLOWED      2
#define CUG_CALL_OUTGOING_ACCESS_NOT_ALLOWED  3
static const value_string isup_CUG_call_ind_value[] = {
  /* according 3.38/Q.763 */
  {  CUG_NON_CUG_CALL,                     "non-CUG call"},
  {  1,                                    "spare"},
  {  CUG_CALL_OUTGOING_ACCESS_ALLOWED,     "closed user group call, outgoing access allowed"},
  {  CUG_CALL_OUTGOING_ACCESS_NOT_ALLOWED, "closed user group call, outgoing access not allowed"},
  {  0,                NULL}};


static const true_false_string isup_simple_segmentation_ind_value = {
  /* according 3.38/Q.763 */
  "additional information will be sent in a segmentation message",
  "no additional information will be sent"
};

static const value_string isup_redirecting_ind_value[] = {
  /* according 3.45/Q.763 */
  {  0,  "no redirection (national use)"},
  {  1,  "call rerouted (national use)"},
  {  2,  "call rerouted, all redirection information presentation restricted (national use)"},
  {  3,  "call diverted"},
  {  4,  "call diverted, all redirection information presentation restricted"},
  {  5,  "call rerouted, redirection number presentation restricted (national use)"},
  {  6,  "call diversion, redirection number presentation restricted (national use)"},
  {  7,  "spare"},
  {  0,  NULL}};

static const value_string isup_original_redirection_reason_value[] = {
  /* according 3.45/Q.763 */
  {  0,  "unknown/not available"},
  {  1,  "user busy (national use)"},
  {  2,  "no reply (national use)"},
  {  3,  "unconditional (national use)"},
  {  0,  NULL}};

static const value_string isup_redirection_reason_value[] = {
  /* according 3.45/Q.763 */
  {  0,  "unknown/not available"},
  {  1,  "user busy (national use)"},
  {  2,  "no reply (national use)"},
  {  3,  "unconditional (national use)"},
  {  4,  "deflection during alerting"},
  {  5,  "deflection immediate response"},
  {  6,  "mobile subscriber not reachable"},
  {  0,  NULL}};

static const value_string isup_type_of_network_identification_value[] = {
  /* according 3.53/Q.763 */
  {  0,  "CCITT/ITU-T-standardized identification"},
  {  2,  "national network identification"},
  {  0,  NULL}};

static const value_string isup_network_identification_plan_value[] = {
  /* according 3.53/Q.763 */
  {  0,  "if CCITT/ITU-T id - unknown"},
  {  3,  "if CCITT/ITU-T id - public data network id code (X.121)"},
  {  6,  "if CCITT/ITU-T id - public land Mobile Network id code (E.211)"},
  {  0,  NULL}};

static const value_string isup_map_type_value[] = {
  /* according 3.69/Q.763 */
  {  1,  "1544 kbit/s digital path map format (64 kbit/s base rate"},
  {  2,  "2048 kbit/s digital path map format (64 kbit/s base rate"},
  {  0,  NULL}};

static const value_string isup_auto_congestion_level_value[] = {
  /* according 3.4/Q.763 */
  {  1,  "Congestion level 1 exceeded"},
  {  2,  "Congestion level 2 exceeded"},
  {  0,  NULL}};

static const true_false_string isup_inband_information_ind_value = {
  /* according 3.37/Q.763 */
  "in-band information or an appropriate pattern is now available",
  "no indication"
};
static const true_false_string isup_call_diversion_may_occur_ind_value = {
  /* according 3.37/Q.763 */
  "call diversion may occur",
  "no indication"
};
static const true_false_string isup_MLPP_user_ind_value = {
  /* according 3.37/Q.763 */
  "MLPP user",
  "no indication"
};

static const true_false_string isup_access_delivery_ind_value = {
  /* according 3.2/Q.763 */
  "No set-up message generated",
  "Set-up message generated"
};

static const value_string isup_loop_prevention_response_ind_value[] = {
  /* according 3.67/Q.763 */
  {  0,  "insufficient information"},
  {  1,  "no loop exists"},
  {  2,  "simultaneous transfer"},
  {  0,  NULL}};

static const true_false_string isup_temporary_alternative_routing_ind_value = {
  /* according 3.68/Q.763 */
  "TAR controlled call",
  "no indication"
};
static const true_false_string isup_extension_ind_value = {
  /* according 3.68/Q.763 */
  "last octet",
  "information continues through the next octet"
};



static const value_string isup_call_to_be_diverted_ind_value[] = {
  /* according 3.72/Q.763 */
  {  0,  "no indication"},
  {  1,  "call diversion allowed"},
  {  2,  "call diversion not allowed"},
  {  3,  "spare"},
  {  0,  NULL}};

static const value_string isup_call_to_be_offered_ind_value[] = {
  /* according 3.72/Q.763 */
  {  0,  "no indication"},
  {  1,  "call offering not allowed"},
  {  2,  "call offering allowed"},
  {  3,  "spare"},
  {  0,  NULL}};

static const value_string isup_conference_acceptance_ind_value[] = {
  /* according 3.76/Q.763 */
  {  0,  "no indication"},
  {  1,  "accept conference request"},
  {  2,  "reject conference request"},
  {  3,  "spare"},
  {  0,  NULL}};

static const value_string isup_application_transport_parameter_value[] = {
  /* according 3.82/Q.763 */
  {  0,  "Unidentified Context and Error Handling (UCEH) ASE"},
  {  1,  "PSS1 ASE (VPN)"},
  {  2,  "spare"},
  {  3,  "Charging ASE"},
  {  4,  "GAT"},
  {  5,  "BAT ASE"},
  {  6,  "Enhanced Unidentified Context and Error Handling ASE (EUCEH ASE)"},
  {  0,  NULL}};

static const true_false_string isup_Release_call_indicator_value = {
  "release call",
  "do not release call"
};

static const true_false_string isup_Send_notification_ind_value = {
  "send notification",
  "do not send notification"
};
static const value_string isup_APM_segmentation_ind_value[] = {

  {  0x00,  "final segment"},
  {  0x01,  "number of following segments"},
  {  0x02,  "number of following segments"},
  {  0x03,  "number of following segments"},
  {  0x04,  "number of following segments"},
  {  0x05,  "number of following segments"},
  {  0x06,  "number of following segments"},
  {  0x07,  "number of following segments"},
  {  0x08,  "number of following segments"},
  {  0x09,  "number of following segments"},
  {  0,     NULL}};

static const true_false_string isup_Sequence_ind_value = {
  "new sequence",
  "subsequent segment to first segment"
};


/* Generalized bit masks for 8 and 16 bits fields */
#define A_8BIT_MASK       0x01
#define B_8BIT_MASK       0x02
#define C_8BIT_MASK       0x04
#define D_8BIT_MASK       0x08
#define E_8BIT_MASK       0x10
#define F_8BIT_MASK       0x20
#define G_8BIT_MASK       0x40
#define H_8BIT_MASK       0x80

#define BA_8BIT_MASK      0x03
#define CB_8BIT_MASK      0x06
#define DC_8BIT_MASK      0x0C
#define ED_8BIT_MASK      0x18
#define FE_8BIT_MASK      0x30
#define GF_8BIT_MASK      0x60
#define HG_8BIT_MASK      0xC0
#define GFE_8BIT_MASK     0x70
#define HGF_8BIT_MASK     0xE0
#define DCBA_8BIT_MASK    0x0F
#define EDCBA_8BIT_MASK   0x1F
#define HGFE_8BIT_MASK    0xF0
#define GFEDCBA_8BIT_MASK 0x7F
#define FEDCBA_8BIT_MASK  0x3F

#define A_16BIT_MASK    0x0100
#define B_16BIT_MASK    0x0200
#define C_16BIT_MASK    0x0400
#define D_16BIT_MASK    0x0800
#define E_16BIT_MASK    0x1000
#define F_16BIT_MASK    0x2000
#define G_16BIT_MASK    0x4000
#define H_16BIT_MASK    0x8000
#define I_16BIT_MASK    0x0001
#define J_16BIT_MASK    0x0002
#define K_16BIT_MASK    0x0004
#define L_16BIT_MASK    0x0008
#define M_16BIT_MASK    0x0010
#define N_16BIT_MASK    0x0020
#define O_16BIT_MASK    0x0040
#define P_16BIT_MASK    0x0080

#define BA_16BIT_MASK   0x0300
#define CB_16BIT_MASK   0x0600
#define DC_16BIT_MASK   0x0C00
#define FE_16BIT_MASK   0x3000
#define HG_16BIT_MASK   0xC000
#define KJ_16BIT_MASK   0x0006
#define PO_16BIT_MASK   0x00C0

#define CBA_16BIT_MASK  0x0700
#define KJI_16BIT_MASK  0x0007
#define HGFE_16BIT_MASK 0xF000
#define PONM_16BIT_MASK 0x00F0

/* Initialize the protocol and registered fields */
static int proto_isup;
static int proto_bicc;

static bool isup_show_cic_in_info = true;

static int hf_isup_called;
static int hf_isup_calling;
static int hf_isup_redirecting;
static int hf_isup_redirection_number;
static int hf_isup_subsequent_number;
static int hf_isup_connected_number;
static int hf_isup_transit_network_selection;
static int hf_isup_original_called_number;
static int hf_isup_location_number;
static int hf_isup_call_transfer_number;
static int hf_isup_called_in_number;
static int hf_isup_generic_number;
static int hf_isup_jurisdiction;
static int hf_isup_charge_number;

static int hf_isup_cic;
static int hf_bicc_cic;

static int isup_tap;

static int hf_isup_message_type;
static int hf_isup_parameter_type;
static int hf_isup_parameter_value;
static int hf_isup_mand_parameter_type;
static int hf_isup_opt_parameter_type;
static int hf_isup_parameter_length;
static int hf_isup_mandatory_variable_parameter_pointer;
static int hf_isup_pointer_to_start_of_optional_part;

static int hf_isup_cvr_rsp_ind;
static int hf_isup_cvr_cg_car_ind;
static int hf_isup_cvr_cg_double_seize;
static int hf_isup_cvr_cg_alarm_car_ind;
static int hf_isup_cvr_cont_chk_ind;

static int hf_isup_satellite_indicator;
static int hf_isup_continuity_check_indicator;
static int hf_bicc_continuity_check_indicator;
static int hf_isup_echo_control_device_indicator;

static int hf_isup_forw_call_natnl_inatnl_call_indicator;
static int hf_isup_forw_call_end_to_end_method_indicator;
static int hf_bicc_forw_call_end_to_end_method_indicator;
static int hf_isup_forw_call_interworking_indicator;
static int hf_isup_forw_call_end_to_end_info_indicator;
static int hf_bicc_forw_call_end_to_end_info_indicator;
static int hf_isup_forw_call_isdn_user_part_indicator;
static int hf_bicc_forw_call_isdn_user_part_indicator;
static int hf_isup_forw_call_preferences_indicator;
static int hf_bicc_forw_call_preferences_indicator;
static int hf_isup_forw_call_isdn_access_indicator;
static int hf_isup_forw_call_ported_num_trans_indicator;
static int hf_isup_forw_call_qor_attempt_indicator;
static int hf_isup_forw_call_sccp_method_indicator;
static int hf_bicc_forw_call_sccp_method_indicator;

static int hf_isup_calling_partys_category;
static int hf_russian_isup_calling_partys_category;

static int hf_isup_transmission_medium_requirement;

static int hf_isup_odd_even_indicator;
static int hf_isup_called_party_nature_of_address_indicator;
static int hf_isup_calling_party_nature_of_address_indicator;
static int hf_isup_inn_indicator;
static int hf_isup_ni_indicator;
static int hf_isup_numbering_plan_indicator;
static int hf_isup_address_presentation_restricted_indicator;
static int hf_isup_screening_indicator;
static int hf_isup_screening_indicator_enhanced;
static int hf_isup_called_party_odd_address_signal_digit;
static int hf_isup_calling_party_odd_address_signal_digit;
static int hf_isup_called_party_even_address_signal_digit;
static int hf_isup_calling_party_even_address_signal_digit;

static int hf_isup_generic_name_presentation;
static int hf_isup_generic_name_availability;
static int hf_isup_generic_name_type;
static int hf_isup_generic_name_ia5;

static int hf_isup_OECD_inf_ind;
static int hf_isup_IECD_inf_ind;
static int hf_isup_OECD_req_ind;
static int hf_isup_IECD_req_ind;

static int hf_isup_calling_party_address_request_indicator;
static int hf_isup_info_req_holding_indicator;
static int hf_isup_calling_partys_category_request_indicator;
static int hf_isup_charge_information_request_indicator;
static int hf_isup_charge_number_nature_of_address_indicator;
static int hf_isup_malicious_call_identification_request_indicator;

static int hf_isup_calling_party_address_response_indicator;
static int hf_isup_hold_provided_indicator;
static int hf_isup_calling_partys_category_response_indicator;
static int hf_isup_charge_information_response_indicator;
static int hf_isup_solicited_indicator;

static int hf_isup_continuity_indicator;

static int hf_isup_backw_call_charge_ind;
static int hf_isup_backw_call_called_partys_status_ind;
static int hf_isup_backw_call_called_partys_category_ind;
static int hf_isup_backw_call_end_to_end_method_ind;
static int hf_bicc_backw_call_end_to_end_method_ind;
static int hf_isup_backw_call_interworking_ind;
static int hf_isup_backw_call_end_to_end_info_ind;
static int hf_bicc_backw_call_end_to_end_info_ind;
static int hf_isup_backw_call_iam_seg_ind;
static int hf_isup_backw_call_isdn_user_part_ind;
static int hf_bicc_backw_call_isdn_user_part_ind;
static int hf_isup_backw_call_holding_ind;
static int hf_isup_backw_call_isdn_access_ind;
static int hf_isup_backw_call_echo_control_device_ind;
static int hf_isup_backw_call_sccp_method_ind;
static int hf_bicc_backw_call_sccp_method_ind;

static int hf_isup_cause_indicator;
static int hf_ansi_isup_cause_indicator;

static int hf_isup_suspend_resume_indicator;

static int hf_isup_range_indicator;
static int hf_isup_bitbucket;
static int hf_isup_cgs_message_type;

static int hf_isup_mtc_blocking_state1;
static int hf_isup_mtc_blocking_state2;
static int hf_isup_call_proc_state;
static int hf_isup_hw_blocking_state;

static int hf_isup_event_ind;
static int hf_isup_event_presentation_restricted_ind;

static int hf_isup_cug_call_ind;
static int hf_isup_simple_segmentation_ind;
static int hf_isup_connected_line_identity_request_ind;

static int hf_isup_redirecting_ind;
static int hf_isup_original_redirection_reason;
static int hf_isup_redirection_counter;
static int hf_isup_redirection_reason;

static int hf_isup_type_of_network_identification;
static int hf_isup_network_identification_plan;

static int hf_isup_map_type;

static int hf_isup_automatic_congestion_level;

static int hf_isup_inband_information_ind;
static int hf_isup_call_diversion_may_occur_ind;
static int hf_isup_mlpp_user_ind;

static int hf_isup_UUI_type;
static int hf_isup_UUI_req_service1;
static int hf_isup_UUI_req_service2;
static int hf_isup_UUI_req_service3;
static int hf_isup_UUI_res_service1;
static int hf_isup_UUI_res_service2;
static int hf_isup_UUI_res_service3;
static int hf_isup_notification_indicator;
static int hf_isup_UUI_network_discard_ind;
static int hf_isup_access_delivery_ind;

static int hf_isup_transmission_medium_requirement_prime;

static int hf_isup_loop_prevention_response_ind;

static int hf_isup_temporary_alternative_routing_ind;
static int hf_isup_extension_ind;

static int hf_isup_call_to_be_diverted_ind;

static int hf_isup_call_to_be_offered_ind;

static int hf_isup_conference_acceptance_ind;

static int hf_isup_transit_at_intermediate_exchange_ind;
static int hf_isup_Release_call_ind;
static int hf_isup_Send_notification_ind;
static int hf_isup_Discard_message_ind_value;
static int hf_isup_Discard_parameter_ind;
static int hf_isup_Pass_on_not_possible_indicator;
static int hf_isup_pass_on_not_possible_indicator2;
static int hf_isup_Broadband_narrowband_interworking_ind;
static int hf_isup_Broadband_narrowband_interworking_ind2;

static int hf_isup_app_cont_ident;
static int hf_isup_app_Send_notification_ind;
static int hf_isup_apm_segmentation_ind;
static int hf_isup_apm_si_ind;
static int hf_isup_apm_slr;
static int hf_isup_orig_addr_len;
static int hf_isup_dest_addr_len;
static int hf_isup_app_Release_call_ind;
static int hf_isup_cause_location;

static int hf_ansi_isup_coding_standard;
static int hf_ansi_isup_spare_b7;
static int hf_ansi_isup_type_of_nw_id;
static int hf_ansi_isup_nw_id_plan;
static int hf_ansi_isup_tns_nw_id_plan;
static int hf_ansi_isup_nw_id;
static int hf_ansi_isup_circuit_code;

static int hf_length_indicator;
static int hf_afi;
static int hf_bicc_nsap_dsp;
static int hf_bicc_nsap_dsp_length;
static int hf_bat_ase_identifier;

static int hf_Action_Indicator;

static int hf_Instruction_ind_for_general_action;

static int hf_Send_notification_ind_for_general_action;

static int hf_Instruction_ind_for_pass_on_not_possible;

static int hf_Send_notification_ind_for_pass_on_not_possible;
static int hf_BCTP_Version_Indicator;
static int hf_Tunnelled_Protocol_Indicator;
static int hf_TPEI;
static int hf_BVEI;
static int hf_bncid;
static int hf_bat_ase_biwfa;
static int hf_characteristics;

static int hf_Organization_Identifier;
static int hf_codec_type;
static int hf_etsi_codec_type;
static int hf_active_code_set;
static int hf_active_code_set_12_2;
static int hf_active_code_set_10_2;
static int hf_active_code_set_7_95;
static int hf_active_code_set_7_40;
static int hf_active_code_set_6_70;
static int hf_active_code_set_5_90;
static int hf_active_code_set_5_15;
static int hf_active_code_set_4_75;
static int hf_supported_code_set;
static int hf_supported_code_set_12_2;
static int hf_supported_code_set_10_2;
static int hf_supported_code_set_7_95;
static int hf_supported_code_set_7_40;
static int hf_supported_code_set_6_70;
static int hf_supported_code_set_5_90;
static int hf_supported_code_set_5_15;
static int hf_supported_code_set_4_75;
static int hf_optimisation_mode;
static int hf_max_codec_modes;
static int hf_bearer_control_tunneling;
static int hf_Local_BCU_ID;
static int hf_late_cut_through_cap_ind;
static int hf_bat_ase_signal;
static int hf_bat_ase_duration;
static int hf_bat_ase_bearer_redir_ind;
static int hf_bat_ase_default;
static int hf_BAT_ASE_Comp_Report_Reason;
static int hf_BAT_ASE_Comp_Report_ident;
static int hf_BAT_ASE_Comp_Report_diagnostic;
static int hf_nsap_ipv4_addr;
static int hf_nsap_ipv6_addr;
static int hf_iana_icp;

static int hf_isup_geo_loc_presentation_restricted_ind;
static int hf_isup_geo_loc_screening_ind;

static int hf_isup_apm_msg_fragments;
static int hf_isup_apm_msg_fragment;
static int hf_isup_apm_msg_fragment_overlap;
static int hf_isup_apm_msg_fragment_overlap_conflicts;
static int hf_isup_apm_msg_fragment_multiple_tails;
static int hf_isup_apm_msg_fragment_too_long_fragment;
static int hf_isup_apm_msg_fragment_error;
static int hf_isup_apm_msg_fragment_count;
static int hf_isup_apm_msg_reassembled_in;
static int hf_isup_apm_msg_reassembled_length;

/* national parameters */
static int hf_isup_french_coll_field;
static int hf_isup_french_msg_num;

static int hf_isup_israeli_charging_message_indicators_current;
static int hf_isup_israeli_charging_message_indicators_next;
static int hf_isup_israeli_current_rate;
static int hf_isup_israeli_time_indicator;
static int hf_isup_israeli_next_rate;

static int hf_japan_isup_redirect_capability;
static int hf_japan_isup_redirect_counter;
static int hf_japan_isup_rfi_info_type;
static int hf_japan_isup_rfi_info_len;
static int hf_japan_isup_perf_redir_reason;
static int hf_japan_isup_redir_pos_ind;
static int hf_japan_isup_inv_redir_reason;
static int hf_japan_isup_bwd_info_type;
static int hf_japan_isup_tag_len;
static int hf_japan_isup_hold_at_emerg_call_disc_ind;
static int hf_japan_isup_emerg_call_type;
static int hf_japan_isup_add_user_cat_type;
static int hf_japan_isup_type_1_add_fixed_serv_inf;
static int hf_japan_isup_type_1_add_mobile_serv_inf;
static int hf_japan_isup_type_2_add_mobile_serv_inf;
static int hf_japan_isup_type_3_add_mobile_serv_inf;
static int hf_japan_isup_reason_for_clip_fail;
static int hf_japan_isup_contractor_number;

static int hf_isup_carrier_info_iec;
/*static int hf_isup_carrier_info_cat_of_carrier;*/
/*static int hf_isup_carrier_info_type_of_carrier_info;*/
static int hf_japan_isup_carrier_info_length;
static int hf_isup_carrier_info_odd_no_digits;
static int hf_isup_carrier_info_even_no_digits;
static int hf_isup_carrier_info_ca_odd_no_digits;
static int hf_isup_carrier_info_ca_even_no_digits;
static int hf_isup_carrier_info_poi_entry_HEI;
static int hf_isup_carrier_info_poi_exit_HEI;

static int hf_japan_isup_charge_delay_type;
static int hf_japan_isup_charge_info_type;
static int hf_japan_isup_sig_elem_type;
static int hf_japan_isup_activation_id;
static int hf_japan_isup_op_cls;
static int hf_japan_isup_op_type;
static int hf_japan_isup_charging_party_type;
static int hf_japan_isup_utp;
static int hf_japan_isup_crci1;
static int hf_japan_isup_crci2;
static int hf_japan_isup_crci1_len;
static int hf_japan_isup_iu;
static int hf_japan_isup_dcr;
static int hf_japan_isup_ecr;
static int hf_japan_isup_ncr;
static int hf_japan_isup_scr;
static int hf_japan_isup_collecting_method;
static int hf_japan_isup_tariff_rate_pres;

static int hf_japan_isup_charge_area_nat_of_info_value;
static int hf_japan_isup_charging_info_nc_odd_digits;
static int hf_japan_isup_charging_info_nc_even_digits;
static int hf_isup_charging_info_maca_odd_digits;
static int hf_isup_charging_info_maca_even_digits;

/* Generated from convert_proto_tree_add_text.pl */
static int hf_isup_protocol_class;
static int hf_isup_geo_loc_shape_description;
static int hf_isup_geo_loc_shape;
static int hf_isup_ccss_call_indicator;
static int hf_isup_charged_party_identification;
static int hf_isup_forward_gvns;
static int hf_isup_idi;
static int hf_isup_precedence_level;
static int hf_isup_configuration_data;
static int hf_isup_redirect_capability;
static int hf_isup_credit;
static int hf_isup_idp;
static int hf_isup_apm_seg_indicator;
static int hf_isup_user_service_information;
static int hf_isup_tunnelled_protocol_data;
static int hf_isup_mlpp_service_domain;
static int hf_isup_uid_capability_indicators;
static int hf_isup_call_identity;
static int hf_isup_scf_id;
static int hf_isup_call_diversion_information;
static int hf_isup_display_information;
static int hf_isup_call_history_info;
static int hf_isup_remote_operations;
static int hf_isup_user_to_user_info;
static int hf_isup_address_digits;
static int hf_isup_network_id;
static int hf_isup_uid_action_indicators;
static int hf_isup_dsp;
static int hf_isup_instruction_indicators;
static int hf_isup_circuit_assignment_map;
static int hf_isup_collect_call_request_indicator;
static int hf_isup_hop_counter;
static int hf_isup_user_service_information_prime;
static int hf_isup_message_compatibility_information;
static int hf_isup_app_transport_param_field8;
static int hf_isup_app_transport_param_field16;
static int hf_isup_binary_code;
static int hf_isup_local_reference;
static int hf_isup_cause_indicators;
static int hf_isup_backward_gvns;
static int hf_isup_presentation_indicator;
static int hf_isup_mcid_request_indicators;
static int hf_isup_origination_isc_point_code;
static int hf_isup_upgraded_parameter;
static int hf_isup_generic_digits;
static int hf_isup_diagnostic;
static int hf_isup_network_specific_facility;
static int hf_isup_app_transport_instruction_indicator;
static int hf_isup_look_forward_busy;
static int hf_isup_redirect_counter;
static int hf_isup_correlation_id;
static int hf_isup_network_identity;
static int hf_isup_user_teleservice_information;
static int hf_isup_mcid_response_indicators;
static int hf_isup_apm_user_info_field;
static int hf_isup_feature_code;
static int hf_isup_number_qualifier_indicator;
static int hf_isup_echo_control_information;
static int hf_isup_network_id_length_indicator;
static int hf_isup_unknown_organisation_identifier;
static int hf_isup_originating_line_info;
static int hf_isup_loop_prevention_indicator_type;
static int hf_isup_signalling_point_code;
static int hf_isup_call_transfer_identity;
static int hf_isup_access_transport_parameter_field;
static int hf_isup_propagation_delay_counter;
static int hf_isup_number_different_meaning;

/* Initialize the subtree pointers */
static int ett_isup;
static int ett_isup_parameter;
static int ett_isup_address_digits;
static int ett_isup_carrier_info;
static int ett_isup_pass_along_message;
static int ett_isup_circuit_state_ind;
static int ett_bat_ase;
static int ett_bicc;
static int ett_bat_ase_element;
static int ett_bat_ase_iwfa;
static int ett_acs;
static int ett_scs;

static int ett_isup_apm_msg_fragment;
static int ett_isup_apm_msg_fragments;
static int ett_isup_range;
static int ett_app_transport_fields;
static int ett_app_transport;
static int ett_apm_seg_indicator;
static int ett_echo_control_information;
static int ett_instruction_indicators;
static int ett_message_compatibility_information;

static expert_field ei_isup_format_national_matter;
static expert_field ei_isup_message_type_unknown;
static expert_field ei_isup_not_dissected_yet;
static expert_field ei_isup_message_type_no_optional_parameters;
static expert_field ei_isup_status_subfield_not_present;
static expert_field ei_isup_empty_number;
static expert_field ei_isup_too_many_digits;
static expert_field ei_isup_opt_par_length_err;

static dissector_handle_t bicc_handle;

static dissector_handle_t sdp_handle;
static dissector_handle_t q931_ie_handle;

/* Declarations to desegment APM Messages */
static bool isup_apm_desegment = true;

static const fragment_items isup_apm_msg_frag_items = {
  /* Fragment subtrees */
  &ett_isup_apm_msg_fragment,
  &ett_isup_apm_msg_fragments,
  /* Fragment fields */
  &hf_isup_apm_msg_fragments,
  &hf_isup_apm_msg_fragment,
  &hf_isup_apm_msg_fragment_overlap,
  &hf_isup_apm_msg_fragment_overlap_conflicts,
  &hf_isup_apm_msg_fragment_multiple_tails,
  &hf_isup_apm_msg_fragment_too_long_fragment,
  &hf_isup_apm_msg_fragment_error,
  &hf_isup_apm_msg_fragment_count,
  /* Reassembled in field */
  &hf_isup_apm_msg_reassembled_in,
  /* Reassembled length field */
  &hf_isup_apm_msg_reassembled_length,
  /* Reassembled data field */
  NULL,
  /* Tag */
  "ISUP APM Message fragments"
};

static reassembly_table isup_apm_msg_reassembly_table;

/* Info for the tap that must be passed between procedures */
static char *tap_called_number;
static char *tap_calling_number;
static uint8_t tap_cause_value;

/* ------------------------------------------------------------------
  Mapping number to ASCII-character
 ------------------------------------------------------------------ */
static char number_to_char(int number)
{
  if (number < 10)
    return ((char) number + ASCII_NUMBER_DELTA);
  else
    return ((char) number + ASCII_LETTER_DELTA);
}

/* ------------------------------------------------------------------ */
/* Dissectors for all used parameter types                            */
/* ------------------------------------------------------------------ */
/* argument tvbuff_t contains only parameter-specific length          */
/* length indicator is already dissected in dissect_isup_message() or */
/* dissect_isup_optional_parameter()                                  */
/* ------------------------------------------------------------------ */
/* ------------------------------------------------------------------
 Dissector Parameter circuit validation response indicator
 */

static void
dissect_isup_cvr_response_ind_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t cvr_response_ind;

  cvr_response_ind = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint(parameter_tree, hf_isup_cvr_rsp_ind, parameter_tvb, 0, CVR_RESP_IND_LENGTH, cvr_response_ind);
  proto_item_append_text(parameter_item, " : 0x%x", cvr_response_ind);

}

/* ------------------------------------------------------------------
   Dissector Parameter circuit validation response - circuit group
   characters
*/
static void
dissect_isup_circuit_group_char_ind_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t cvr_cg_char_ind;

  cvr_cg_char_ind = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint(parameter_tree, hf_isup_cvr_cg_car_ind, parameter_tvb, 0, CG_CHAR_IND_LENGTH, cvr_cg_char_ind);
  proto_tree_add_uint(parameter_tree, hf_isup_cvr_cg_double_seize, parameter_tvb, 0, CG_CHAR_IND_LENGTH, cvr_cg_char_ind);
  proto_tree_add_uint(parameter_tree, hf_isup_cvr_cg_alarm_car_ind, parameter_tvb, 0, CG_CHAR_IND_LENGTH, cvr_cg_char_ind);
  proto_tree_add_uint(parameter_tree, hf_isup_cvr_cont_chk_ind, parameter_tvb, 0, CG_CHAR_IND_LENGTH, cvr_cg_char_ind);

  proto_item_append_text(parameter_item, " : 0x%x", cvr_cg_char_ind);
}

/* ------------------------------------------------------------------
 Dissector Parameter nature of connection flags
 */
static void
dissect_isup_nature_of_connection_indicators_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t nature_of_connection_ind;
  static int * const isup_indicators[] = {
    &hf_isup_satellite_indicator,
    &hf_isup_continuity_check_indicator,
    &hf_isup_echo_control_device_indicator,
    NULL
  };

  static int * const bicc_indicators[] = {
    &hf_isup_satellite_indicator,
    &hf_bicc_continuity_check_indicator,
    &hf_isup_echo_control_device_indicator,
    NULL
  };

  nature_of_connection_ind = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, NATURE_OF_CONNECTION_IND_LENGTH,
                              g_str_equal(pinfo -> current_proto, "ISUP") ? isup_indicators : bicc_indicators, ENC_BIG_ENDIAN);

  proto_item_append_text(parameter_item, " : 0x%x", nature_of_connection_ind);
}

/* ------------------------------------------------------------------
 Dissector Parameter Forward Call Indicators
 */
static void
dissect_isup_forward_call_indicators_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_item *parameter_item, proto_tree *parameter_tree)
{
  uint16_t forward_call_ind = tvb_get_ntohs(parameter_tvb, 0);
  static int * const isup_indicators[] = {
    &hf_isup_forw_call_natnl_inatnl_call_indicator,
    &hf_isup_forw_call_end_to_end_method_indicator,
    &hf_isup_forw_call_interworking_indicator,
    &hf_isup_forw_call_end_to_end_info_indicator,
    &hf_isup_forw_call_isdn_user_part_indicator,
    &hf_isup_forw_call_preferences_indicator,
    &hf_isup_forw_call_isdn_access_indicator,
    &hf_isup_forw_call_sccp_method_indicator,
    &hf_isup_forw_call_ported_num_trans_indicator,
    &hf_isup_forw_call_qor_attempt_indicator,
    NULL
  };

  static int * const bicc_indicators[] = {
    &hf_isup_forw_call_natnl_inatnl_call_indicator,
    &hf_bicc_forw_call_end_to_end_method_indicator,
    &hf_isup_forw_call_interworking_indicator,
    &hf_bicc_forw_call_end_to_end_info_indicator,
    &hf_bicc_forw_call_isdn_user_part_indicator,
    &hf_bicc_forw_call_preferences_indicator,
    &hf_isup_forw_call_isdn_access_indicator,
    &hf_bicc_forw_call_sccp_method_indicator,
    &hf_isup_forw_call_ported_num_trans_indicator,
    &hf_isup_forw_call_qor_attempt_indicator,
    NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, FORWARD_CALL_IND_LENGTH,
                              g_str_equal(pinfo -> current_proto, "ISUP") ? isup_indicators : bicc_indicators, ENC_BIG_ENDIAN);

  proto_item_append_text(parameter_item, " : 0x%x", forward_call_ind);
}

/* ------------------------------------------------------------------
 Dissector Parameter Calling Party's Category
 */
static void
dissect_isup_calling_partys_category_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item, uint8_t itu_isup_variant)
{
  uint8_t calling_partys_category;

  calling_partys_category = tvb_get_uint8(parameter_tvb, 0);

  if (itu_isup_variant == ISUP_RUSSIAN_VARIANT) {
      proto_tree_add_uint(parameter_tree, hf_russian_isup_calling_partys_category,
                          parameter_tvb, 0, CALLING_PRTYS_CATEGORY_LENGTH, calling_partys_category);

      proto_item_append_text(parameter_item, " : 0x%x (%s)",
          calling_partys_category,
          val_to_str_ext_const(calling_partys_category,
          &russian_isup_calling_partys_category_value_ext,
          "reserved/spare"));

  } else {
      proto_tree_add_uint(parameter_tree, hf_isup_calling_partys_category,
                          parameter_tvb, 0, CALLING_PRTYS_CATEGORY_LENGTH, calling_partys_category);

      proto_item_append_text(parameter_item, " : 0x%x (%s)",
                          calling_partys_category,
                          val_to_str_ext_const(calling_partys_category,
                                               &isup_calling_partys_category_value_ext,
                                               "reserved/spare"));
  }
}


/* ------------------------------------------------------------------
  Dissector Parameter Transmission medium requirement
 */
static void
dissect_isup_transmission_medium_requirement_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t transmission_medium_requirement;

  transmission_medium_requirement = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint(parameter_tree, hf_isup_transmission_medium_requirement,
                      parameter_tvb, 0, TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH, transmission_medium_requirement);

  proto_item_append_text(parameter_item, " : %u (%s)", transmission_medium_requirement,
                      val_to_str_ext_const(transmission_medium_requirement, &isup_transmission_medium_requirement_value_ext, "spare"));
}

static char *
dissect_isup_digits_common(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, proto_item *item,
                           int hf_number, int hf_odd_digit, int hf_even_digit,
                           bool even_indicator, e164_number_type_t number_type, unsigned nature_of_address)
{
  int            i = 0;
  int            reported_length, captured_length;
  proto_item    *digits_item;
  proto_tree    *digits_tree;
  uint8_t        digit_pair = 0;
  wmem_strbuf_t *strbuf_number;
  char          *number;
  e164_info_t    e164_info;
  int            start_offset = offset;

  reported_length = tvb_reported_length_remaining(tvb, offset);
  if (reported_length == 0) {
    expert_add_info(pinfo, item, &ei_isup_empty_number);
    proto_item_append_text(item, ": (empty)");
    return NULL;
  }

  strbuf_number = wmem_strbuf_new_sized(pinfo->pool, MAXDIGITS+1);

  /* Make the digit string, looping on captured length (in case a snaplen was set) */
  captured_length = tvb_captured_length_remaining(tvb, offset);
  while (captured_length > 0) {
    if (++i > MAXDIGITS) {
      break;
    }
    digit_pair = tvb_get_uint8(tvb, offset);
    wmem_strbuf_append_c(strbuf_number, number_to_char(digit_pair & ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK));

    if ((captured_length - 1) > 0) {
      if (++i > MAXDIGITS) {
        break;
      }
      wmem_strbuf_append_c(strbuf_number, number_to_char((digit_pair & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
    }

    offset += 1;
    captured_length -= 1;
  }

  if  (even_indicator && (tvb_captured_length(tvb) > 0) && (++i < MAXDIGITS)) {
    /* Even Indicator set -> last (even) digit is valid and has be displayed */
    wmem_strbuf_append_c(strbuf_number, number_to_char((digit_pair & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
  }

  number = wmem_strbuf_finalize(strbuf_number);

  /* Now make the tree */
  offset = start_offset;
  i = 0;
  digits_item = proto_tree_add_string(tree, hf_number, tvb, offset, -1, number);
  digits_tree = proto_item_add_subtree(digits_item, ett_isup_address_digits);

  while (reported_length > 0) {
    if (++i > MAXDIGITS) {
      expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
      break;
    }
    proto_tree_add_item(digits_tree, hf_odd_digit, tvb, offset, 1, ENC_NA);

    if ((reported_length - 1) > 0) {
      if (++i > MAXDIGITS) {
        expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
        break;
      }
      proto_tree_add_item(digits_tree, hf_even_digit, tvb, offset, 1, ENC_NA);
    }

    offset += 1;
    reported_length -= 1;
  }

  if  (even_indicator && (tvb_reported_length(tvb) > 0)) {
    if (++i < MAXDIGITS) {
      /* Even Indicator set -> last (even) digit is valid and has be displayed */
      proto_tree_add_item(digits_tree, hf_even_digit, tvb, offset - 1, 1, ENC_NA);
    } else {
      expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
    }
  }

  if (number_type != NONE) {
    e164_info.e164_number_type = number_type;
    e164_info.nature_of_address = nature_of_address;
    e164_info.E164_number_str = number;
    e164_info.E164_number_length = i - 1;
    dissect_e164_number(tvb, digits_tree, 2, (offset - 2), e164_info);
  }

  proto_item_append_text(item, ": %s", number);

  return number;
}

/* ------------------------------------------------------------------
  Dissector Parameter Called party number
 */
void
dissect_isup_called_party_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t      indicators1, indicators2;
  int          offset = 0;
  int          number_plan;
  static int * const indicators1_flags[] = {
    &hf_isup_odd_even_indicator,
    &hf_isup_called_party_nature_of_address_indicator,
    NULL
  };

  static int * const indicators2_flags[] = {
    &hf_isup_inn_indicator,
    &hf_isup_numbering_plan_indicator,
    NULL
  };

  indicators1 = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_flags, ENC_NA);
  indicators2 = tvb_get_uint8(parameter_tvb, 1);
  number_plan = (indicators2 & 0x70)>> 4;
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_flags, ENC_NA);
  offset = 2;

  tap_called_number = dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
                             hf_isup_called, hf_isup_called_party_odd_address_signal_digit,
                             hf_isup_called_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
                             number_plan == 1 ? CALLED_PARTY_NUMBER : NONE,
                             (indicators1 & 0x7f));
}

/* ------------------------------------------------------------------
  Dissector Parameter  Subsequent number
 */
static void
dissect_isup_subsequent_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t     indicators1;
  int         offset = 0;

  indicators1 = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_boolean(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, indicators1);
  offset = 1;

  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
                             hf_isup_subsequent_number, hf_isup_called_party_odd_address_signal_digit,
                             hf_isup_called_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
                             NONE, 0);
}
/* ------------------------------------------------------------------
  Dissector Parameter Information Request Indicators
 */
static void
dissect_isup_information_request_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  static int * const indicators[] = {
    &hf_isup_calling_party_address_request_indicator,
    &hf_isup_info_req_holding_indicator,
    &hf_isup_calling_partys_category_request_indicator,
    &hf_isup_charge_information_request_indicator,
    &hf_isup_malicious_call_identification_request_indicator,
    NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, INFO_REQUEST_IND_LENGTH, indicators, ENC_BIG_ENDIAN);

  proto_item_append_text(parameter_item, " : 0x%x", tvb_get_ntohs(parameter_tvb, 0));
}
/* ------------------------------------------------------------------
  Dissector Parameter Information Indicators
 */
static void
dissect_isup_information_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  static int * const indicators[] = {
    &hf_isup_calling_party_address_response_indicator,
    &hf_isup_hold_provided_indicator,
    &hf_isup_calling_partys_category_response_indicator,
    &hf_isup_charge_information_response_indicator,
    &hf_isup_solicited_indicator,
    NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, INFO_IND_LENGTH, indicators, ENC_BIG_ENDIAN);

  proto_item_append_text(parameter_item, " : 0x%x", tvb_get_ntohs(parameter_tvb, 0));
}
/* ------------------------------------------------------------------
  Dissector Parameter Continuity Indicators
 */
static void
dissect_isup_continuity_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t continuity_indicators;

  continuity_indicators = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_boolean(parameter_tree, hf_isup_continuity_indicator, parameter_tvb, 0, CONTINUITY_IND_LENGTH,  continuity_indicators);

  proto_item_append_text(parameter_item, " : 0x%x", continuity_indicators);
}
/* ------------------------------------------------------------------
 Dissector Parameter Backward Call Indicators
 */
static void
dissect_isup_backward_call_indicators_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  static int * const isup_indicators[] = {
    &hf_isup_backw_call_charge_ind,
    &hf_isup_backw_call_called_partys_status_ind,
    &hf_isup_backw_call_called_partys_category_ind,
    &hf_isup_backw_call_end_to_end_method_ind,
    &hf_isup_backw_call_interworking_ind,
    &hf_isup_backw_call_end_to_end_info_ind,
    &hf_isup_backw_call_isdn_user_part_ind,
    &hf_isup_backw_call_holding_ind,
    &hf_isup_backw_call_isdn_access_ind,
    &hf_isup_backw_call_echo_control_device_ind,
    &hf_isup_backw_call_sccp_method_ind,
    NULL
  };

  static int * const bicc_indicators[] = {
      &hf_isup_backw_call_charge_ind,
      &hf_isup_backw_call_called_partys_status_ind,
      &hf_isup_backw_call_called_partys_category_ind,
      &hf_bicc_backw_call_end_to_end_method_ind,
      &hf_isup_backw_call_interworking_ind,
      &hf_bicc_backw_call_end_to_end_info_ind,
      &hf_bicc_backw_call_isdn_user_part_ind,
      &hf_isup_backw_call_holding_ind,
      &hf_isup_backw_call_isdn_access_ind,
      &hf_isup_backw_call_echo_control_device_ind,
      &hf_bicc_backw_call_sccp_method_ind,
      NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, BACKWARD_CALL_IND_LENGTH,
                              g_str_equal(pinfo -> current_proto, "ISUP") ? isup_indicators : bicc_indicators,
                              ENC_BIG_ENDIAN);
  proto_item_append_text(parameter_item, " : 0x%x", tvb_get_ntohs(parameter_tvb, 0));
}

static void
dissect_ansi_isup_backward_call_indicators_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  static int * const isup_indicators[] = {
    &hf_isup_backw_call_charge_ind,
    &hf_isup_backw_call_called_partys_status_ind,
    &hf_isup_backw_call_called_partys_category_ind,
    &hf_isup_backw_call_end_to_end_method_ind,
    &hf_isup_backw_call_interworking_ind,
    &hf_isup_backw_call_iam_seg_ind,
    &hf_isup_backw_call_isdn_user_part_ind,
    &hf_isup_backw_call_holding_ind,
    &hf_isup_backw_call_isdn_access_ind,
    &hf_isup_backw_call_echo_control_device_ind,
    &hf_isup_backw_call_sccp_method_ind,
    NULL
  };

  static int * const bicc_indicators[] = {
      &hf_isup_backw_call_charge_ind,
      &hf_isup_backw_call_called_partys_status_ind,
      &hf_isup_backw_call_called_partys_category_ind,
      &hf_bicc_backw_call_end_to_end_method_ind,
      &hf_isup_backw_call_interworking_ind,
      &hf_isup_backw_call_iam_seg_ind,
      &hf_bicc_backw_call_isdn_user_part_ind,
      &hf_isup_backw_call_holding_ind,
      &hf_isup_backw_call_isdn_access_ind,
      &hf_isup_backw_call_echo_control_device_ind,
      &hf_bicc_backw_call_sccp_method_ind,
      NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, BACKWARD_CALL_IND_LENGTH,
                              g_str_equal(pinfo -> current_proto, "ISUP") ? isup_indicators : bicc_indicators, ENC_BIG_ENDIAN);
  proto_item_append_text(parameter_item, " : 0x%x", tvb_get_ntohs(parameter_tvb, 0));
}
/* ------------------------------------------------------------------
  Dissector Parameter Cause Indicators - no detailed dissection since defined in Rec. Q.850
 */

/*
 * Cause codes for Cause.
 * The decoding of cause indicators parameter field are defined in ITU-T
 * Recommendation Q.850; those are different from the ones in the Q.931
 * dissector, as that has some values not specified by the standard but
 * that appear to be used for purposes other than the ones in Q.850.
 */
  /* The table is "filled" with "unassigned" to make full use of value_string_ext */
static const value_string q850_cause_code_vals[] = {
  { 0x00,  "Valid cause code not yet received" },
  { 0x01,  "Unallocated (unassigned) number" },
  { 0x02,  "No route to specified transit network" },
  { 0x03,  "No route to destination" },
  { 0x04,  "Send special information tone" },
  { 0x05,  "Misdialled trunk prefix" },
  { 0x06,  "Channel unacceptable" },
  { 0x07,  "Call awarded and being delivered in an established channel" },
  { 0x08,  "Preemption" },
  { 0x09,  "Preemption - circuit reserved for reuse" },
  { 0x0A,  "Unassigned" },
  { 0x0B,  "Unassigned" },
  { 0x0C,  "Unassigned" },
  { 0x0D,  "Unassigned" },
  { 0x0E,  "QoR: ported number" },
  { 0x0F,  "Unassigned" },
  { 0x10,  "Normal call clearing" },
  { 0x11,  "User busy" },
  { 0x12,  "No user responding" },
  { 0x13,  "No answer from user (user alerted)" },
  { 0x14,  "Subscriber absent" },
  { 0x15,  "Call rejected" },
  { 0x16,  "Number changed" },
  { 0x17,  "Redirection to new destination" },
  { 0x18,  "Call rejected due to feature at the destination" },
  { 0x19,  "Exchange routing error" },
  { 0x1A,  "Non-selected user clearing" },
  { 0x1B,  "Destination out of order" },
  { 0x1C,  "Invalid number format (address incomplete)" },
  { 0x1D,  "Facility rejected" },
  { 0x1E,  "Response to STATUS ENQUIRY" },
  { 0x1F,  "Normal unspecified" },
  { 0x20,  "Unassigned" },
  { 0x21,  "Circuit out of order" },
  { 0x22,  "No circuit/channel available" },
  { 0x23,  "Unassigned" },
  { 0x24,  "Unassigned" },
  { 0x25,  "Unassigned" },
  { 0x26,  "Network out of order" },
  { 0x27,  "Permanent frame mode connection out of service" },
  { 0x28,  "Permanent frame mode connection operational" },
  { 0x29,  "Temporary failure" },
  { 0x2A,  "Switching equipment congestion" },
  { 0x2B,  "Access information discarded" },
  { 0x2C,  "Requested circuit/channel not available" },
  { 0x2D,  "Unassigned" },
  { 0x2E,  "Precedence call blocked" },
  { 0x2F,  "Resources unavailable, unspecified" },
  { 0x30,  "Unassigned" },
  { 0x31,  "Quality of service unavailable" },
  { 0x32,  "Requested facility not subscribed" },
  { 0x33,  "Unassigned" },
  { 0x34,  "Unassigned" },
  { 0x35,  "Outgoing calls barred within CUG" },
  { 0x36,  "Unassigned" },
  { 0x37,  "Incoming calls barred within CUG" },
  { 0x38,  "Call waiting not subscribed" },
  { 0x39,  "Bearer capability not authorized" },
  { 0x3A,  "Bearer capability not presently available" },
  { 0x3B,  "Unassigned" },
  { 0x3C,  "Unassigned" },
  { 0x3D,  "Unassigned" },
  { 0x3E,  "Inconsistency in designated outgoing access information and subscriber class" },
  { 0x3F,  "Service or option not available, unspecified" },
  { 0x40,  "Unassigned" },
  { 0x41,  "Bearer capability not implemented" },
  { 0x42,  "Channel type not implemented" },
  { 0x43,  "Unassigned" },
  { 0x44,  "Unassigned" },
  { 0x45,  "Requested facility not implemented" },
  { 0x46,  "Only restricted digital information bearer capability is available" },
  { 0x47,  "Unassigned" },
  { 0x48,  "Unassigned" },
  { 0x49,  "Unassigned" },
  { 0x4A,  "Unassigned" },
  { 0x4B,  "Unassigned" },
  { 0x4C,  "Unassigned" },
  { 0x4D,  "Unassigned" },
  { 0x4E,  "Unassigned" },
  { 0x4F,  "Service or option not implemented, unspecified" },
  { 0x50,  "Unassigned" },
  { 0x51,  "Invalid call reference value" },
  { 0x52,  "Identified channel does not exist" },
  { 0x53,  "Call identity does not exist for suspended call" },
  { 0x54,  "Call identity in use" },
  { 0x55,  "No call suspended" },
  { 0x56,  "Call having the requested call identity has been cleared" },
  { 0x57,  "Called user not member of CUG" },
  { 0x58,  "Incompatible destination" },
  { 0x59,  "Unassigned" },
  { 0x5A,  "Non-existing CUG" },
  { 0x5B,  "Invalid transit network selection (national use)" },
  { 0x5C,  "Unassigned" },
  { 0x5D,  "Unassigned" },
  { 0x5E,  "Unassigned" },
  { 0x5F,  "Invalid message, unspecified" },
  { 0x60,  "Mandatory information element is missing" },
  { 0x61,  "Message type non-existent or not implemented" },
  { 0x62,  "Message not compatible with call state or message type non-existent or not implemented" },
  { 0x63,  "Information element nonexistent or not implemented" },
  { 0x64,  "Invalid information element contents" },
  { 0x65,  "Message not compatible with call state" },
  { 0x66,  "Recovery on timer expiry" },
  { 0x67,  "Parameter non-existent or not implemented - passed on" },
  { 0x68,  "Unassigned" },
  { 0x69,  "Unassigned" },
  { 0x6A,  "Unassigned" },
  { 0x6B,  "Unassigned" },
  { 0x6C,  "Unassigned" },
  { 0x6D,  "Unassigned" },
  { 0x6E,  "Message with unrecognized parameter discarded" },
  { 0x6F,  "Protocol error, unspecified" },
  { 0x70,  "Unassigned" },
  { 0x71,  "Unassigned" },
  { 0x72,  "Unassigned" },
  { 0x73,  "Unassigned" },
  { 0x74,  "Unassigned" },
  { 0x75,  "Unassigned" },
  { 0x76,  "Unassigned" },
  { 0x77,  "Unassigned" },
  { 0x78,  "Unassigned" },
  { 0x79,  "Unassigned" },
  { 0x7A,  "Unassigned" },
  { 0x7B,  "Unassigned" },
  { 0x7C,  "Unassigned" },
  { 0x7D,  "Unassigned" },
  { 0x7E,  "Unassigned" },
  { 0x7F,  "Interworking, unspecified" },
  { 0,  NULL }
};
value_string_ext q850_cause_code_vals_ext = VALUE_STRING_EXT_INIT(q850_cause_code_vals);

static const value_string ansi_isup_cause_code_vals[] = {
  { 0x00,  "Valid cause code not yet received" },
  { 0x01,  "Unallocated (unassigned) number" },
  { 0x02,  "No route to specified transit network" },
  { 0x03,  "No route to destination" },
  { 0x04,  "Send special information tone" },
  { 0x05,  "Misdialled trunk prefix" },
  { 0x06,  "Channel unacceptable" },
  { 0x07,  "Call awarded and being delivered in an established channel" },
  { 0x08,  "Preemption" },
  { 0x09,  "Preemption - circuit reserved for reuse" },
  { 0x0A,  "Unassigned" },
  { 0x0B,  "Unassigned" },
  { 0x0C,  "Unassigned" },
  { 0x0D,  "Unassigned" },
  { 0x0E,  "QoR: ported number" },
  { 0x0F,  "Unassigned" },
  { 0x10,  "Normal call clearing" },
  { 0x11,  "User busy" },
  { 0x12,  "No user responding" },
  { 0x13,  "No answer from user (user alerted)" },
  { 0x14,  "Subscriber absent" },
  { 0x15,  "Call rejected" },
  { 0x16,  "Number changed" },
  { 0x17,  "Unallocated destination number" },
  { 0X18,  "Undefined business group" },
  { 0x19,  "Exchange routing error" },
  { 0x1A,  "Non-selected user clearing" },
  { 0x1B,  "Destination out of order" },
  { 0x1C,  "Invalid number format (address incomplete)" },
  { 0x1D,  "Facility rejected" },
  { 0x1E,  "Response to STATUS ENQUIRY" },
  { 0x1F,  "Normal unspecified" },
  { 0x20,  "Unassigned" },
  { 0x21,  "Circuit out of order" },
  { 0x22,  "No circuit/channel available" },
  { 0x23,  "Unassigned" },
  { 0x24,  "Unassigned" },
  { 0x25,  "Unassigned" },
  { 0x26,  "Network out of order" },
  { 0x27,  "Permanent frame mode connection out of service" },
  { 0x28,  "Permanent frame mode connection operational" },
  { 0x29,  "Temporary failure" },
  { 0x2A,  "Switching equipment congestion" },
  { 0x2B,  "Access information discarded" },
  { 0x2C,  "Requested circuit/channel not available" },
  { 0x2D,  "Preemption" },
  { 0x2E,  "Precedence call blocked" },
  { 0x2F,  "Resources unavailable, unspecified" },
  { 0x30,  "Unassigned" },
  { 0x31,  "Quality of service unavailable" },
  { 0x32,  "Requested facility not subscribed" },
  { 0x33,  "Call type incompatible with service request" },
  { 0x34,  "Unassigned" },
  { 0x35,  "Outgoing calls barred within CUG" },
  { 0x36,  "Call blocked due to group restriction" },
  { 0x37,  "Incoming calls barred within CUG" },
  { 0x38,  "Call waiting not subscribed" },
  { 0x39,  "Bearer capability not authorized" },
  { 0x3A,  "Bearer capability not presently available" },
  { 0x3B,  "Unassigned" },
  { 0x3C,  "Unassigned" },
  { 0x3D,  "Unassigned" },
  { 0x3E,  "Inconsistency in designated outgoing access information and subscriber class" },
  { 0x3F,  "Service or option not available, unspecified" },
  { 0x40,  "Unassigned" },
  { 0x41,  "Bearer capability not implemented" },
  { 0x42,  "Channel type not implemented" },
  { 0x43,  "Unassigned" },
  { 0x44,  "Unassigned" },
  { 0x45,  "Requested facility not implemented" },
  { 0x46,  "Only restricted digital information bearer capability is available" },
  { 0x47,  "Unassigned" },
  { 0x48,  "Unassigned" },
  { 0x49,  "Unassigned" },
  { 0x4A,  "Unassigned" },
  { 0x4B,  "Unassigned" },
  { 0x4C,  "Unassigned" },
  { 0x4D,  "Unassigned" },
  { 0x4E,  "Unassigned" },
  { 0x4F,  "Service or option not implemented, unspecified" },
  { 0x50,  "Unassigned" },
  { 0x51,  "Invalid call reference value" },
  { 0x52,  "Identified channel does not exist" },
  { 0x53,  "Call identity does not exist for suspended call" },
  { 0x54,  "Call identity in use" },
  { 0x55,  "No call suspended" },
  { 0x56,  "Call having the requested call identity has been cleared" },
  { 0x57,  "Called user not member of CUG" },
  { 0x58,  "Incompatible destination" },
  { 0x59,  "Unassigned" },
  { 0x5A,  "Non-existing CUG" },
  { 0x5B,  "Invalid transit network selection (national use)" },
  { 0x5C,  "Unassigned" },
  { 0x5D,  "Unassigned" },
  { 0x5E,  "Unassigned" },
  { 0x5F,  "Invalid message, unspecified" },
  { 0x60,  "Mandatory information element is missing" },
  { 0x61,  "Message type non-existent or not implemented" },
  { 0x62,  "Message not compatible with call state or message type non-existent or not implemented" },
  { 0x63,  "Information element nonexistent or not implemented" },
  { 0x64,  "Invalid information element contents" },
  { 0x65,  "Message not compatible with call state" },
  { 0x66,  "Recovery on timer expiry" },
  { 0x67,  "Parameter non-existent or not implemented - passed on" },
  { 0x68,  "Unassigned" },
  { 0x69,  "Unassigned" },
  { 0x6A,  "Unassigned" },
  { 0x6B,  "Unassigned" },
  { 0x6C,  "Unassigned" },
  { 0x6D,  "Unassigned" },
  { 0x6E,  "Message with unrecognized parameter discarded" },
  { 0x6F,  "Protocol error, unspecified" },
  { 0x70,  "Unassigned" },
  { 0x71,  "Unassigned" },
  { 0x72,  "Unassigned" },
  { 0x73,  "Unassigned" },
  { 0x74,  "Unassigned" },
  { 0x75,  "Unassigned" },
  { 0x76,  "Unassigned" },
  { 0x77,  "Unassigned" },
  { 0x78,  "Unassigned" },
  { 0x79,  "Unassigned" },
  { 0x7A,  "Unassigned" },
  { 0x7B,  "Unassigned" },
  { 0x7C,  "Unassigned" },
  { 0x7D,  "Unassigned" },
  { 0x7E,  "Unassigned" },
  { 0x7F,  "Internetworking, unspecified" },
  { 0,  NULL }
};
static value_string_ext ansi_isup_cause_code_vals_ext = VALUE_STRING_EXT_INIT(ansi_isup_cause_code_vals);

static const value_string ansi_isup_coding_standard_vals[] = {
  { 0, "CCITT Standard" },
  { 1, "Reserved for other international standards" },
  { 2, "ANSI Standard" },
  { 3, "Reserved" },
  { 0,  NULL }
};
void
dissect_isup_cause_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{ unsigned length = tvb_reported_length(parameter_tvb);
  proto_tree_add_item(parameter_tree, hf_isup_cause_indicators, parameter_tvb, 0, -1, ENC_NA);
  dissect_q931_cause_ie(parameter_tvb, 0, length,
                        parameter_tree,
                        hf_isup_cause_indicator, &tap_cause_value, isup_parameter_type_value);
}

static void
dissect_ansi_isup_cause_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t coding_standard;
  uint8_t cause_value;
  int offset = 0;
  unsigned length = tvb_reported_length(parameter_tvb);

  coding_standard = (tvb_get_uint8(parameter_tvb, offset)&0x60)>>5;

  switch (coding_standard) {
    case 0:
      /*CCITT*/
      proto_tree_add_item(parameter_tree, hf_isup_cause_location, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      proto_tree_add_item(parameter_tree, hf_ansi_isup_coding_standard, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      offset += 1;
      length -= 1;
      if (length == 0)
        return;
      proto_tree_add_item(parameter_tree, hf_isup_cause_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      cause_value = tvb_get_uint8(parameter_tvb, offset)&0x7f;
      offset += 1;
      length -= 1;
      proto_item_append_text(parameter_item, " : %s (%u)",
                          val_to_str_ext_const(cause_value, &q850_cause_code_vals_ext, "spare"), cause_value);
      if (length == 0) {
        return;
      }
      proto_tree_add_item(parameter_tree, hf_isup_diagnostic, parameter_tvb, offset, length, ENC_NA);
      return;
    case 2:
      /*ANSI*/
      proto_tree_add_item(parameter_tree, hf_isup_cause_location, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      proto_tree_add_item(parameter_tree, hf_ansi_isup_coding_standard, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      offset += 1;
      length -= 1;
      if (length == 0)
        return;
      proto_tree_add_item(parameter_tree, hf_ansi_isup_cause_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      cause_value = tvb_get_uint8(parameter_tvb, offset)&0x7f;
      proto_item_append_text(parameter_item, " : %s (%u)",
                          val_to_str_ext_const(cause_value, &ansi_isup_cause_code_vals_ext, "spare"),
                          cause_value);
      offset += 1;
      length -= 1;
      if (length == 0) {
        return;
      }
      proto_tree_add_item(parameter_tree, hf_isup_diagnostic, parameter_tvb, offset, length, ENC_NA);
      return;
    default:
      proto_tree_add_item(parameter_tree, hf_ansi_isup_coding_standard, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      break;
  }
}

/* ------------------------------------------------------------------
  Dissector ANSI Transit network selection
 */

static const value_string ansi_isup_tns_nw_id_plan_vals[] = {
    { 0x00, "Unknown" },
    { 0x01, "3-digit carrier id with circuit code" },
    { 0x02, "4-digit carrier id with circuit code" },
    {    0, NULL } };

static void
dissect_ansi_isup_transit_network_selection_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo _U_, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  int         offset = 0;

  static int * const indicators_fields[] = {
    &hf_ansi_isup_spare_b7,
    &hf_isup_type_of_network_identification,
    &hf_ansi_isup_tns_nw_id_plan,
    NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators_fields, ENC_NA);
  offset = 1;

  proto_tree_add_item(parameter_tree, hf_ansi_isup_nw_id, parameter_tvb, offset, 2, ENC_BCD_DIGITS_0_9|ENC_LITTLE_ENDIAN);
  offset += 2;
  proto_tree_add_item(parameter_tree, hf_ansi_isup_circuit_code, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);

}

static const value_string ansi_isup_type_of_nw_id_vals[] = {
    { 0x00, "Spare" },
    { 0x01, "Spare" },
    { 0x02, "National network identification" },
    { 0x03, "Spare" },
    { 0x04, "Spare" },
    { 0x05, "Spare" },
    { 0x06, "Spare" },
    { 0x07, "Spare" },
    {    0, NULL } };

static const value_string ansi_isup_nw_id_plan_vals[] = {
    { 0x00, "Unknown" },
    { 0x01, "3-digit carrier id" },
    { 0x02, "4-digit carrier id" },
    {    0, NULL } };

static void
dissect_ansi_isup_param_carrier_id(tvbuff_t *parameter_tvb, packet_info *pinfo _U_, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  int offset = 0;

  static int * const flags[] = {
    &hf_ansi_isup_spare_b7,
    &hf_ansi_isup_type_of_nw_id,
    &hf_ansi_isup_nw_id_plan,
    NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, offset, 1, flags, ENC_BIG_ENDIAN);
  offset++;

  proto_tree_add_item(parameter_tree, hf_ansi_isup_nw_id, parameter_tvb, offset, 2, ENC_BCD_DIGITS_0_9|ENC_LITTLE_ENDIAN);

}

/* ------------------------------------------------------------------
  Dissector Parameter Suspend/Resume Indicators
 */
static void
dissect_isup_suspend_resume_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t indicators;

  indicators = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_boolean(parameter_tree, hf_isup_suspend_resume_indicator, parameter_tvb, 0, SUSPEND_RESUME_IND_LENGTH,  indicators);

  proto_item_append_text(parameter_item, " : 0x%x", indicators);
}
/* ------------------------------------------------------------------
  Dissector Parameter Range and Status Indicators
 */
static void
dissect_isup_range_and_status_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  proto_tree *range_tree;
  int offset = 0;
  uint8_t range, actual_status_length;

  range = tvb_get_uint8(parameter_tvb, 0) + 1;
  proto_tree_add_uint_format(parameter_tree, hf_isup_range_indicator, parameter_tvb, offset, RANGE_LENGTH, range, "Range: %u", range);
  offset = offset + RANGE_LENGTH;

  actual_status_length = tvb_reported_length_remaining(parameter_tvb, offset);
  if (actual_status_length > 0) {
    range_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1, ett_isup_range, NULL, "Status subfield");
    if (range<9) {
      proto_tree_add_uint_bits_format_value(range_tree, hf_isup_bitbucket, parameter_tvb, (offset*8)+(8-range), range,
                          tvb_get_uint8(parameter_tvb, offset), ENC_BIG_ENDIAN, "%u bit 1", range);
    }
  } else {
    expert_add_info(pinfo, parameter_item, &ei_isup_status_subfield_not_present);
  }

  proto_item_append_text(parameter_item, ": Range (%u) and status", range);
}
/* ------------------------------------------------------------------
  Dissector Parameter Circuit group supervision message type
 */
static void
dissect_isup_circuit_group_supervision_message_type_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t cgs_message_type;

  cgs_message_type = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint(parameter_tree, hf_isup_cgs_message_type, parameter_tvb, 0, CIRC_GRP_SV_MSG_TYPE_LENGTH, cgs_message_type);

  proto_item_append_text(parameter_item, " : %s (%u)",
                      val_to_str_const(cgs_message_type, isup_cgs_message_type_value, "unknown"), cgs_message_type);
}
/* ------------------------------------------------------------------
  Dissector Parameter Facility indicator parameter
 */
static void
dissect_isup_facility_ind_parameter(tvbuff_t *parameter_tvb, proto_item *parameter_item)
{
  uint8_t indicator;

  indicator = tvb_get_uint8(parameter_tvb, 0);

  proto_item_append_text(parameter_item, " : %s (%u)"  , val_to_str_const(indicator, isup_facility_ind_value, "spare"), indicator);
}
/* ------------------------------------------------------------------
  Dissector Parameter Circuit state indicator
 */
static void
dissect_isup_circuit_state_ind_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  proto_item *circuit_state_item;
  proto_tree *circuit_state_tree;
  uint8_t     circuit_state;
  int         offset = 0;
  int         i      = 0;

  while (tvb_reported_length_remaining(parameter_tvb, offset) > 0) {
    circuit_state_tree = proto_tree_add_subtree_format(parameter_tree, parameter_tvb, offset, -1,
                                             ett_isup_circuit_state_ind, &circuit_state_item,
                                             "Circuit# CIC+%u state", i);
    circuit_state = tvb_get_uint8(parameter_tvb, offset);
    if ((circuit_state & DC_8BIT_MASK) == 0) {
      proto_tree_add_uint(circuit_state_tree, hf_isup_mtc_blocking_state1, parameter_tvb, offset, 1, circuit_state);
      proto_item_append_text(circuit_state_item, ": %s",
                          val_to_str_const(circuit_state&BA_8BIT_MASK, isup_mtc_blocking_state_DC00_value, "unknown"));
    }
    else {
      proto_tree_add_uint(circuit_state_tree, hf_isup_mtc_blocking_state2, parameter_tvb, offset, 1, circuit_state);
      proto_tree_add_uint(circuit_state_tree, hf_isup_call_proc_state, parameter_tvb, offset, 1, circuit_state);
      proto_tree_add_uint(circuit_state_tree, hf_isup_hw_blocking_state, parameter_tvb, offset, 1, circuit_state);
      proto_item_append_text(circuit_state_item, ": %s", val_to_str_const(circuit_state&BA_8BIT_MASK, isup_mtc_blocking_state_DCnot00_value, "unknown"));
    }
    i++;
    offset += 1;
  }
  proto_item_append_text(parameter_item, " (national use)");
}
/* ------------------------------------------------------------------
  Dissector Parameter Event information
 */
static void
dissect_isup_event_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t indicators;

  indicators = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_event_ind, parameter_tvb, 0, EVENT_INFO_LENGTH, indicators,
                             "%s (%u)",
                             val_to_str_const(indicators & GFEDCBA_8BIT_MASK, isup_event_ind_value, "spare"),
                             indicators & GFEDCBA_8BIT_MASK);
  proto_tree_add_boolean(parameter_tree, hf_isup_event_presentation_restricted_ind, parameter_tvb, 0, EVENT_INFO_LENGTH, indicators);

  proto_item_append_text(parameter_item, " : %s (%u)", val_to_str_const(indicators & GFEDCBA_8BIT_MASK, isup_event_ind_value, "spare"), indicators);
}
/* ------------------------------------------------------------------
  Dissector Parameter User-to-user information- no detailed dissection since defined in Rec. Q.931
 */
static void
dissect_isup_user_to_user_information_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{ unsigned length = tvb_reported_length(parameter_tvb);
  proto_tree_add_item(parameter_tree, hf_isup_user_to_user_info, parameter_tvb, 0, -1, ENC_NA);
  dissect_q931_user_user_ie(parameter_tvb, pinfo, 0, length,
    parameter_tree);
}
/* ------------------------------------------------------------------
  Dissector Parameter Call Reference
 */
static void
dissect_isup_call_reference_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint32_t call_id;
  uint16_t spc;

  call_id = tvb_get_ntoh24(parameter_tvb, 0);
  spc = tvb_get_letohs(parameter_tvb, CALL_ID_LENGTH) & 0x3FFF; /*since 1st 2 bits spare */
  proto_tree_add_item(parameter_tree, hf_isup_call_identity, parameter_tvb, 0, CALL_ID_LENGTH, ENC_BIG_ENDIAN);
  proto_tree_add_item(parameter_tree, hf_isup_signalling_point_code, parameter_tvb, CALL_ID_LENGTH, SPC_LENGTH, ENC_BIG_ENDIAN);

  proto_item_append_text(parameter_item, " : Call ID = %u, SPC = %u", call_id, spc);
}
/* ------------------------------------------------------------------
  Dissector Parameter Access Transport - no detailed dissection since defined in Rec. Q.931
 */
static void
dissect_isup_access_transport_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree,
                                        proto_item *parameter_item _U_, packet_info *pinfo)
{

  proto_tree_add_item(parameter_tree, hf_isup_access_transport_parameter_field, parameter_tvb, 0, -1, ENC_NA);

  if (q931_ie_handle)
    call_dissector(q931_ie_handle, parameter_tvb, pinfo, parameter_tree);
}

/* dissect x.213 NSAP coded Address */

static const value_string x213_afi_value[] = {
  { NSAP_IDI_IANA_ICP_DEC,              "IANA ICP, decimal"},
  { NSAP_IDI_IANA_ICP_BIN,              "IANA ICP, binary"},
  { NSAP_IDI_X_121_DEC_FSD_NZ,          "X.121, decimal, first significant digit non-zero"},
  { NSAP_IDI_X_121_BIN_FSD_NZ,          "X.121, binary, first significant digit non-zero"},
  { NSAP_IDI_ISO_DCC_DEC,               "ISO DCC, decimal"},
  { NSAP_IDI_ISO_DCC_BIN,               "ISO DCC, binary"},
  { NSAP_IDI_F_69_DEC_FSD_NZ,           "F.69, decimal, first significant digit non-zero"},
  { NSAP_IDI_F_69_BIN_FSD_NZ,           "F.69, binary, first significant digit non-zero"},
  { NSAP_IDI_E_163_DEC_FSD_NZ,          "E.163, decimal, first significant digit non-zero"},
  { NSAP_IDI_E_163_BIN_FSD_NZ,          "E.163, binary, first significant digit non-zero"},
  { NSAP_IDI_E_164_DEC_FSD_NZ,          "E.164, decimal, first significant digit non-zero"},
  { NSAP_IDI_E_164_BIN_FSD_NZ,          "E.164, binary, first significant digit non-zero"},
  { NSAP_IDI_ISO_6523_ICD_DEC,          "ISO 6523-ICD, decimal"},
  { NSAP_IDI_ISO_6523_ICD_BIN,          "ISO 6523-ICD, binary"},
  { NSAP_IDI_LOCAL_DEC,                 "Local, decimal"},
  { NSAP_IDI_LOCAL_BIN,                 "Local, binary"},
  { NSAP_IDI_LOCAL_ISO_646_CHAR,        "Local, ISO/IEC 646 character"},
  { NSAP_IDI_LOCAL_NATIONAL_CHAR,       "Local, National character"},
  { NSAP_IDI_X_121_DEC_FSD_Z,           "X.121, decimal, first significant digit zero"},
  { NSAP_IDI_X_121_BIN_FSD_Z,           "X.121, binary, first significant digit zero"},
  { NSAP_IDI_F_69_DEC_FSD_Z,            "F.69, decimal, first significant digit zero"},
  { NSAP_IDI_F_69_BIN_FSD_Z,            "F.69, binary, first significant digit zero"},
  { NSAP_IDI_E_163_DEC_FSD_Z,           "E.163, decimal, first significant digit zero"},
  { NSAP_IDI_E_163_BIN_FSD_Z,           "E.163, binary, first significant digit zero"},
  { NSAP_IDI_E_164_DEC_FSD_Z,           "E.164, decimal, first significant digit zero"},
  { NSAP_IDI_E_164_BIN_FSD_Z,           "E.164, binary, first significant digit zero"},

  { NSAP_IDI_ITU_T_IND_DEC,             "ITU-T IND, decimal"},
  { NSAP_IDI_ITU_T_IND_BIN,             "ITU-T IND, binary"},

  { NSAP_IDI_IANA_ICP_DEC_GROUP,        "IANA ICP Group no, decimal"},
  { NSAP_IDI_IANA_ICP_BIN_GROUP,        "IANA ICP Group no, binary"},
  { NSAP_IDI_X_121_DEC_FSD_NZ_GROUP,    "X.121 Group no, decimal, first significant digit non-zero"},
  { NSAP_IDI_X_121_BIN_FSD_NZ_GROUP,    "X.121 Group no, binary, first significant digit non-zero"},
  { NSAP_IDI_ISO_DCC_DEC_GROUP,         "ISO DCC Group no, decimal"},
  { NSAP_IDI_ISO_DCC_BIN_GROUP,         "ISO DCC Group no, binary"},
  { NSAP_IDI_F_69_DEC_FSD_NZ_GROUP,     "F.69 Group no, decimal, first significant digit non-zero"},
  { NSAP_IDI_F_69_BIN_FSD_NZ_GROUP,     "F.69 Group no, binary, first significant digit non-zero"},
  { NSAP_IDI_E_163_DEC_FSD_NZ_GROUP,    "E.163 Group no, decimal, first significant digit non-zero"},
  { NSAP_IDI_E_163_BIN_FSD_NZ_GROUP,    "E.163 Group no, binary, first significant digit non-zero"},
  { NSAP_IDI_E_164_DEC_FSD_NZ_GROUP,    "E.164 Group no, decimal, first significant digit non-zero"},
  { NSAP_IDI_E_164_BIN_FSD_NZ_GROUP,    "E.164 Group no, binary, first significant digit non-zero"},
  { NSAP_IDI_ISO_6523_ICD_DEC_GROUP,    "ISO 6523-ICD Group no, decimal"},
  { NSAP_IDI_ISO_6523_ICD_BIN_GROUP,    "ISO 6523-ICD Group no, binary"},
  { NSAP_IDI_LOCAL_DEC_GROUP,           "Local Group no, decimal"},
  { NSAP_IDI_LOCAL_BIN_GROUP,           "Local Group no, binary"},
  { NSAP_IDI_LOCAL_ISO_646_CHAR_GROUP,  "Local Group no, ISO/IEC 646 character"},
  { NSAP_IDI_LOCAL_NATIONAL_CHAR_GROUP, "Local Group no, national character"},
  { NSAP_IDI_X_121_DEC_FSD_Z_GROUP,     "X.121 Group no, decimal, first significant digit zero"},
  { NSAP_IDI_X_121_BIN_FSD_Z_GROUP,     "X.121 Group no, binary, first significant digit zero"},
  { NSAP_IDI_F_69_DEC_FSD_Z_GROUP,      "F.69 Group no, decimal, first significant digit zero"},
  { NSAP_IDI_F_69_BIN_FSD_Z_GROUP,      "F.69 Group no, binary, first significant digit zero"},
  { NSAP_IDI_E_163_DEC_FSD_Z_GROUP,     "E.163 Group no, decimal, first significant digit zero"},
  { NSAP_IDI_E_163_BIN_FSD_Z_GROUP,     "E.163 Group no, binary, first significant digit zero"},
  { NSAP_IDI_E_164_DEC_FSD_Z_GROUP,     "E.164 Group no, decimal, first significant digit zero"},
  { NSAP_IDI_E_164_BIN_FSD_Z_GROUP,     "E.163 Group no, binary, first significant digit zero"},

  { NSAP_IDI_ITU_T_IND_DEC_GROUP,       "ITU-T IND Group no, decimal"},
  { NSAP_IDI_ITU_T_IND_BIN_GROUP,       "ITU-T IND Group no, binary"},
  { 0,  NULL }
};
value_string_ext x213_afi_value_ext = VALUE_STRING_EXT_INIT(x213_afi_value);


/* Up-to-date information on the allocated ICP values can be found in   */
/* RFC 4548 at                                                          */
/* https://tools.ietf.org/html/rfc4548                                  */
static const value_string iana_icp_values[] = {
  { 0x0, "IP Version 6 Address"},
  { 0x1, "IP Version 4 Address"},
  { 0,  NULL }
};

/*
 * XXX - shouldn't there be a centralized routine for dissecting NSAPs?
 * See also "dissect_atm_nsap()" in epan/dissectors/packet-arp.c and
 * "print_nsap_net()" in epan/osi_utils.c.
 */
void
dissect_nsap(tvbuff_t *parameter_tvb, int offset, int len, proto_tree *parameter_tree)
{
  uint8_t afi;
  unsigned  icp;

  afi = tvb_get_uint8(parameter_tvb, offset);

  switch (afi) {
    case NSAP_IDI_IANA_ICP_BIN:  /* IANA ICP Binary format*/
      proto_tree_add_item(parameter_tree, hf_isup_idp, parameter_tvb, offset, 3, ENC_NA);

      proto_tree_add_uint(parameter_tree, hf_afi, parameter_tvb, offset, 1, afi);
      offset = offset + 1;
      icp = tvb_get_ntohs(parameter_tvb, offset);
      proto_tree_add_uint(parameter_tree, hf_iana_icp, parameter_tvb, offset, 1, icp);
      if (icp == 0) { /* IPv6 addr */
        proto_tree_add_item(parameter_tree, hf_isup_dsp, parameter_tvb, offset + 2, 17, ENC_NA);
        proto_tree_add_item(parameter_tree, hf_nsap_ipv6_addr, parameter_tvb, offset + 2,
                            16, ENC_NA);

      }
      else { /* IPv4 addr */
        /* XXX - this is really only for ICP 1 */
        proto_tree_add_item(parameter_tree, hf_isup_dsp, parameter_tvb, offset + 2, 17, ENC_NA);
        proto_tree_add_item(parameter_tree, hf_nsap_ipv4_addr, parameter_tvb, offset + 2, 4, ENC_BIG_ENDIAN);
      }

      break;
    case NSAP_IDI_E_164_BIN_FSD_NZ:       /* E.164 ATM format */
    case NSAP_IDI_E_164_BIN_FSD_NZ_GROUP: /* E.164 ATM group format */
      proto_tree_add_item(parameter_tree, hf_isup_idp, parameter_tvb, offset, 9, ENC_NA);

      proto_tree_add_uint(parameter_tree, hf_afi, parameter_tvb, offset, 1, afi);

      proto_tree_add_item(parameter_tree, hf_isup_idi, parameter_tvb, offset + 1, 8, ENC_NA);
      offset = offset +1;
      /* Dissect country code */
      dissect_e164_cc(parameter_tvb, parameter_tree, offset, E164_ENC_BCD);

      proto_tree_add_uint_format_value(parameter_tree, hf_bicc_nsap_dsp_length, parameter_tvb, offset, 0,
          (len-9), "%u (len %u -9)", (len-9), len);

      proto_tree_add_item(parameter_tree, hf_bicc_nsap_dsp, parameter_tvb, offset + 8, (len - 9), ENC_NA);

      break;
    default:
      proto_tree_add_uint(parameter_tree, hf_afi, parameter_tvb, offset, len, afi);
  }/* end switch afi */

}


#define  ACTION_INDICATOR                               0x01
#define  BACKBONE_NETWORK_CONNECTION_IDENTIFIER         0x02
#define  INTERWORKING_FUNCTION_ADDRESS                  0x03
#define  CODEC_LIST                                     0x04
#define  CODEC                                          0x05
#define  BAT_COMPATIBILITY_REPORT                       0x06
#define  BEARER_NETWORK_CONNECTION_CHARACTERISTICS      0x07
#define  BEARER_CONTROL_INFORMATION                     0x08
#define  BEARER_CONTROL_TUNNELLING                      0x09
#define  BEARER_CONTROL_UNIT_IDENTIFIER                 0x0A
#define  SIGNAL                                         0x0B
#define  BEARER_REDIRECTION_CAPABILITY                  0x0C
#define  BEARER_REDIRECTION_INDICATORS                  0x0D
#define  SIGNAL_TYPE                                    0x0E
#define  DURATION                                       0x0F


static const value_string bat_ase_list_of_Identifiers_vals[] = {

  { 0x00                                        ,   "spare" },
  { ACTION_INDICATOR                            ,   "Action Indicator" },
  { BACKBONE_NETWORK_CONNECTION_IDENTIFIER      ,   "Backbone Network Connection Identifier" },
  { INTERWORKING_FUNCTION_ADDRESS               ,   "Interworking Function Address" },
  { CODEC_LIST                                  ,   "Codec List" },
  { CODEC                                       ,   "Codec" },
  { BAT_COMPATIBILITY_REPORT                    ,   "BAT Compatibility Report" },
  { BEARER_NETWORK_CONNECTION_CHARACTERISTICS   ,   "Bearer Network Connection Characteristics" },
  { BEARER_CONTROL_INFORMATION                  ,   "Bearer Control Information"},
  { BEARER_CONTROL_TUNNELLING                   ,   "Bearer Control Tunnelling"},
  { BEARER_CONTROL_UNIT_IDENTIFIER              ,   "Bearer Control Unit Identifier" },
  { SIGNAL                                      ,   "Signal"},
  { BEARER_REDIRECTION_CAPABILITY               ,   "Bearer Redirection Capability"},
  { BEARER_REDIRECTION_INDICATORS               ,   "Bearer Redirection Indicators"},
  { SIGNAL_TYPE                                 ,   "Signal Type"},
  { DURATION                                    ,   "Duration" },
  { 0,  NULL }
};
static value_string_ext bat_ase_list_of_Identifiers_vals_ext = VALUE_STRING_EXT_INIT(bat_ase_list_of_Identifiers_vals);

/*ITU-T Q.765.5 (06/2000) 13*/
static const value_string Instruction_indicator_for_general_action_vals[] =
{
  { 0,  "Pass on information element"},
  { 1,  "Discard information element"},
  { 2,  "Discard BICC data"},
  { 3,  "Release call"},
  { 0,  NULL}};

static const value_string Instruction_indicator_for_pass_on_not_possible_vals[] = {
  { 0,  "Release call"},
  { 1,  "Discard information element"},
  { 2,  "Discard BICC data"},
  { 3,  "reserved (interpreted as 00)"},
  { 0,  NULL}};

static const value_string bat_ase_action_indicator_field_vals[] = {

  { 0x00,  "no indication"},
  { 0x01,  "connect backward"},
  { 0x02,  "connect forward"},
  { 0x03,  "connect forward, no notification"},
  { 0x04,  "connect forward, plus notification"},
  { 0x05,  "connect forward, no notification + selected codec"},
  { 0x06,  "connect forward, plus notification + selected codec"},
  { 0x07,  "use idle"},
  { 0x08,  "connected"},
  { 0x09,  "switched"},
  { 0x0a,  "selected codec"},
  { 0x0b,  "modify codec"},
  { 0x0c,  "successful codec modification"},
  { 0x0d,  "codec modification failure"},
  { 0x0e,  "mid-call codec negotiation"},
  { 0x0f,  "modify to selected codec information"},
  { 0x10,  "mid-call codec negotiation failure"},
  { 0x11,  "start signal, notify"},
  { 0x12,  "start signal, no notify"},
  { 0x13,  "stop signal, notify"},
  { 0x14,  "stop signal, no notify"},
  { 0x15,  "start signal acknowledge"},
  { 0x16,  "start signal reject"},
  { 0x17,  "stop signal acknowledge"},
  { 0x18,  "bearer redirect"},
  { 0,     NULL }
};
static value_string_ext bat_ase_action_indicator_field_vals_ext = VALUE_STRING_EXT_INIT(bat_ase_action_indicator_field_vals);

static const true_false_string BCTP_BVEI_value  = {
  "Version Error Indication, BCTP version not supported",
  "No indication"
};

static const value_string BCTP_Tunnelled_Protocol_Indicator_vals[] = {

  { 0x20,  "IPBCP (text encoded)"},
  { 0x21,  "spare (text encoded protocol)"},
  { 0x22,  "not used"},
  { 0,  NULL }
};

static const true_false_string BCTP_TPEI_value  = {
  "Protocol Error Indication, Bearer Control Protocol not supported",
  "No indication"
};


#define  ITU_T  0x01
#define  ETSI   0x02

static const value_string bat_ase_organization_identifier_subfield_vals[] = {

  { 0x00,   "no indication"},
  { 0x01,   "ITU-T"},
  { 0x02,   "ETSI (refer to TS 26.103)"},
  { 0,  NULL }
};

#define G_711_64_A            0x01
#define G_711_64_U            0x02
#define G_711_56_A            0x03
#define G_711_56_U            0x04
#define G_722_SB_ADPCM        0x05
#define G_723_1               0x06
#define G_723_1_Annex_A       0x07
#define G_726_ADPCM           0x08
#define G_727_Embedded_ADPCM  0x09
#define G_728                 0x0a
#define G_729_CS_ACELP        0x0b
#define G_729_Annex_B         0x0c

static const value_string ITU_T_codec_type_subfield_vals[] = {

  { 0x00,                  "no indication"},
  { G_711_64_A,            "G.711 64 kbit/s A-law"},
  { G_711_64_U,            "G.711 64 kbit/s -law"},
  { G_711_56_A,            "G.711 56 kbit/s A-law"},
  { G_711_56_U,            "G.711 56 kbit/s -law"},
  { G_722_SB_ADPCM,        "G.722 (SB-ADPCM)"},
  { G_723_1,               "G.723.1"},
  { G_723_1_Annex_A,       "G.723.1 Annex A (silence suppression)"},
  { G_726_ADPCM,           "G.726 (ADPCM)"},
  { G_727_Embedded_ADPCM,  "G.727 (Embedded ADPCM)"},
  { G_728,                 "G.728"},
  { G_729_CS_ACELP,        "G.729 (CS-ACELP)"},
  { G_729_Annex_B,         "G.729 Annex B (silence suppression)"},
  { 0,  NULL }
};
static value_string_ext ITU_T_codec_type_subfield_vals_ext = VALUE_STRING_EXT_INIT(ITU_T_codec_type_subfield_vals);

static const value_string ETSI_codec_type_subfield_vals[] = {

  { 0x00, "GSM Full Rate (13.0 kBit/s)(GSM FR)"},
  { 0x01, "GSM Half Rate (5.6 kBit/s) (GSM HR)"},
  { 0x02, "GSM Enhanced Full Rate (12.2 kBit/s)(GSM EFR)"},
  { 0x03, "Full Rate Adaptive Multi-Rate (FR AMR)"},
  { 0x04, "Half Rate Adaptive Multi-Rate (HR AMR)"},
  { 0x05, "UMTS Adaptive Multi-Rate (UMTS AMR)"},
  { 0x06, "UMTS Adaptive Multi-Rate 2 (UMTS AMR 2)"},
  { 0x07, "TDMA Enhanced Full Rate (7.4 kBit/s) (TDMA EFR)"},
  { 0x08, "PDC Enhanced Full Rate (6.7 kBit/s) (PDC EFR)"},
  { 0x09, "Full Rate Adaptive Multi-Rate WideBand (FR AMR-WB)"},
  { 0x0a, "UMTS Adaptive Multi-Rate WideBand (UMTS AMR-WB)"},
  { 0x0b, "8PSK Half Rate Adaptive Multi-Rate (OHR AMR)"},
  { 0x0c, "8PSK Full Rate Adaptive Multi-Rate WideBand  (OFR AMR-WB)"},
  { 0x0d, "8PSK Half Rate Adaptive Multi-Rate WideBand (OHR AMR-WB)"},
  { 0xfe, "Reserved for future use."},
  { 0xff, "Reserved for MuMe dummy Codec Type (MuMe)"},
  { 0,  NULL }
};
static value_string_ext ETSI_codec_type_subfield_vals_ext = VALUE_STRING_EXT_INIT(ETSI_codec_type_subfield_vals);

#if 0
static const value_string bat_initial_codec_mode_vals[] = {
  {0x7, "12.2 kbps"},
  {0x6, "10.2 kbps"},
  {0x5, "7.95 kbps"},
  {0x4, "7.40 kbps"},
  {0x3, "6.70 kbps"},
  {0x2, "5.90 kbps"},
  {0x1, "5.15 kbps"},
  {0x0, "4.75 kbps"},
  {0, NULL}
};
#endif

static const value_string optimisation_mode_vals[] = {
  { 0,  "Optimisation of the ACS not supported,"},
  { 1,  "Optimisation of the ACS supported,"},
  { 0,  NULL }
};

static const value_string bearer_network_connection_characteristics_vals[] = {

  { 0x00,   "no indication"},
  { 0x01,   "AAL type 1"},
  { 0x02,   "AAL type 2"},
  { 0x03,   "Structured AAL type 1"},
  { 0x04,   "IP/RTP"},
  { 0x05,   "TDM (reserved for use by ITU-T Rec. Q.1950)"},
  { 0,  NULL }
};
value_string_ext bearer_network_connection_characteristics_vals_ext = VALUE_STRING_EXT_INIT(bearer_network_connection_characteristics_vals);

static const true_false_string Bearer_Control_Tunnelling_ind_value  = {
  "Tunnelling to be used",
  "No indication"
};

static const true_false_string late_cut_through_cap_ind_value  = {
  "Late Cut-through supported",
  "Late Cut-through not supported"
};
/*  ITU-T Rec. Q.765.5/Amd.1 (07/2001) */
static const value_string Bearer_Redirection_Indicator_vals[] = {
  { 0x00,  " no indication"},
  { 0x01,  "late cut-through request"},
  { 0x02,  "redirect temporary reject"},
  { 0x03,  "redirect backwards request"},
  { 0x04,  "redirect forwards request"},
  { 0x05,  "redirect bearer release request"},
  { 0x06,  "redirect bearer release proceed"},
  { 0x07,  "redirect bearer release complete"},
  { 0x08,  "redirect cut-through request"},
  { 0x09,  "redirect bearer connected indication"},
  { 0x0a,  "redirect failure"},
  { 0x0b,  "new connection identifier"},
  { 0,  NULL }
};
static value_string_ext Bearer_Redirection_Indicator_vals_ext = VALUE_STRING_EXT_INIT(Bearer_Redirection_Indicator_vals);

/*26/Q.765.5 - Signal Type */
static const value_string BAT_ASE_Signal_Type_vals[] = {
  { 0x00,  "DTMF 0"},
  { 0x01,  "DTMF 1"},
  { 0x02,  "DTMF 2"},
  { 0x03,  "DTMF 3"},
  { 0x04,  "DTMF 4"},
  { 0x05,  "DTMF 5"},
  { 0x06,  "DTMF 6"},
  { 0x07,  "DTMF 7"},
  { 0x08,  "DTMF 8"},
  { 0x09,  "DTMF 9"},
  { 0x0a,  "DTMF *"},
  { 0x0b,  "DTMF #"},
  { 0x0c,  "DTMF A"},
  { 0x0d,  "DTMF B"},
  { 0x0e,  "DTMF C"},
  { 0x0f,  "DTMF D"},
  /* 0001 0000
   * to
   * 0011 1111
   * Spare
   */
  { 0x10,  "Spare"},
  { 0x11,  "Spare"},
  { 0x12,  "Spare"},
  { 0x13,  "Spare"},
  { 0x14,  "Spare"},
  { 0x15,  "Spare"},
  { 0x16,  "Spare"},
  { 0x17,  "Spare"},
  { 0x18,  "Spare"},
  { 0x19,  "Spare"},
  { 0x1a,  "Spare"},
  { 0x1b,  "Spare"},
  { 0x1c,  "Spare"},
  { 0x1d,  "Spare"},
  { 0x1e,  "Spare"},
  { 0x1f,  "Spare"},
  { 0x20,  "Spare"},
  { 0x21,  "Spare"},
  { 0x22,  "Spare"},
  { 0x23,  "Spare"},
  { 0x24,  "Spare"},
  { 0x25,  "Spare"},
  { 0x26,  "Spare"},
  { 0x27,  "Spare"},
  { 0x28,  "Spare"},
  { 0x29,  "Spare"},
  { 0x2a,  "Spare"},
  { 0x2b,  "Spare"},
  { 0x2c,  "Spare"},
  { 0x2d,  "Spare"},
  { 0x2e,  "Spare"},
  { 0x2f,  "Spare"},
  { 0x30,  "Spare"},
  { 0x31,  "Spare"},
  { 0x32,  "Spare"},
  { 0x33,  "Spare"},
  { 0x34,  "Spare"},
  { 0x35,  "Spare"},
  { 0x36,  "Spare"},
  { 0x37,  "Spare"},
  { 0x38,  "Spare"},
  { 0x39,  "Spare"},
  { 0x3a,  "Spare"},
  { 0x3b,  "Spare"},
  { 0x3c,  "Spare"},
  { 0x3d,  "Spare"},
  { 0x3e,  "Spare"},
  { 0x3f,  "Spare"},

  { 0x40,  "dial tone"},
  { 0x41,  "PABX internal dial tone"},
  { 0x42,  "special dial tone"},
  { 0x43,  "second dial tone"},
  { 0x44,  "ringing tone"},
  { 0x45,  "special ringing tone"},
  { 0x46,  "busy tone"},
  { 0x47,  "congestion tone"},
  { 0x48,  "special information tone"},
  { 0x49,  "warning tone"},
  { 0x4a,  "intrusion tone"},
  { 0x4b,  "call waiting tone"},
  { 0x4c,  "pay tone"},
  { 0x4d,  "payphone recognition tone"},
  { 0x4e,  "comfort tone"},
  { 0x4f,  "tone on hold"},
  { 0x50,  "record tone"},
  { 0x51,  "Caller waiting tone"},
  { 0x52,  "positive indication tone"},
  { 0x53,  "negative indication tone"},
  { 0,  NULL }
};
static value_string_ext BAT_ASE_Signal_Type_vals_ext = VALUE_STRING_EXT_INIT(BAT_ASE_Signal_Type_vals);

static const value_string BAT_ASE_Report_Reason_vals[] = {

  { 0x00,   "no indication"},
  { 0x01,   "information element non-existent or not implemented"},
  { 0x02,   "BICC data with unrecognized information element, discarded"},
  { 0,  NULL }
};
/* This routine should be called with offset at Organization_Identifier not the lengh indicator
 * because of use from other disectors.
 */
extern int dissect_codec_mode(proto_tree *tree, tvbuff_t *tvb, int offset, int len) {
  uint8_t tempdata;
  static int * const active_code_sets[] = {
    &hf_active_code_set_12_2,
    &hf_active_code_set_10_2,
    &hf_active_code_set_7_95,
    &hf_active_code_set_7_40,
    &hf_active_code_set_6_70,
    &hf_active_code_set_5_90,
    &hf_active_code_set_5_15,
    &hf_active_code_set_4_75,
    NULL
  };

  static int * const supported_code_sets[] = {
    &hf_supported_code_set_12_2,
    &hf_supported_code_set_10_2,
    &hf_supported_code_set_7_95,
    &hf_supported_code_set_7_40,
    &hf_supported_code_set_6_70,
    &hf_supported_code_set_5_90,
    &hf_supported_code_set_5_15,
    &hf_supported_code_set_4_75,
    NULL
  };

  tempdata = tvb_get_uint8(tvb, offset);
  proto_tree_add_uint(tree, hf_Organization_Identifier , tvb, offset, 1, tempdata);
  switch (tempdata) {
    case ITU_T :
      offset = offset + 1;
      tempdata = tvb_get_uint8(tvb, offset);
      proto_tree_add_uint(tree, hf_codec_type , tvb, offset, 1, tempdata);
      offset = offset + 1;
      switch (tempdata) {
        case G_711_64_A :
        case G_711_64_U :
        case G_711_56_A :
        case G_711_56_U :
        case G_722_SB_ADPCM :
        case G_723_1 :
        case G_723_1_Annex_A :
          /* These codecs have no configuration data */
          break;
        case G_726_ADPCM :
        case G_727_Embedded_ADPCM :
          /* four bit config data, TODO decode config */
          if (len > 2) {
            proto_tree_add_item(tree, hf_isup_configuration_data, tvb, offset, 1, ENC_NA);
            offset = offset + 1;
          }
          break;
        case G_728 :
        case G_729_CS_ACELP :
        case G_729_Annex_B :
          /* three bit config data, TODO decode config */
          if (len > 2) {
            proto_tree_add_item(tree, hf_isup_configuration_data, tvb, offset, 1, ENC_NA);
            offset = offset + 1;
          }
          break;
        default:
          break;

      }
      break;
    case ETSI:
      offset = offset + 1;
      tempdata = tvb_get_uint8(tvb, offset);
      proto_tree_add_uint(tree, hf_etsi_codec_type , tvb, offset, 1, tempdata);
      if (len > 2) {
        offset = offset + 1;

        proto_tree_add_bitmask_with_flags(tree, tvb, offset, hf_active_code_set,
                           ett_acs, active_code_sets, ENC_LITTLE_ENDIAN, BMT_NO_APPEND);
      }
      if (len > 3) {
        offset = offset + 1;

        proto_tree_add_bitmask_with_flags(tree, tvb, offset, hf_supported_code_set,
                           ett_acs, supported_code_sets, ENC_LITTLE_ENDIAN, BMT_NO_APPEND);
      }
      if (len > 4) {
        offset = offset + 1;
        proto_tree_add_item(tree, hf_optimisation_mode, tvb, offset, 1, ENC_LITTLE_ENDIAN);
        proto_tree_add_item(tree, hf_max_codec_modes, tvb, offset, 1, ENC_LITTLE_ENDIAN);
      }
      offset = offset + 1;
      break;
    default:
      offset = offset + 1;
      proto_tree_add_item(tree, hf_isup_unknown_organisation_identifier, tvb, offset, len, ENC_NA);
      offset = offset + len - 1;
      break;
  }
  /* switch OID */

  return offset;
}

static int
dissect_codec(tvbuff_t *parameter_tvb, proto_tree *bat_ase_element_tree, int length_indicator, int offset, int identifier)
{
/* offset is at length indicator e.g 1 step past identifier */
  static int * const compatibility_info[] = {
    &hf_Instruction_ind_for_general_action,
    &hf_Send_notification_ind_for_general_action,
    &hf_Instruction_ind_for_pass_on_not_possible,
    &hf_Send_notification_ind_for_pass_on_not_possible,
    &hf_isup_extension_ind,
    NULL
  };

  proto_tree_add_uint(bat_ase_element_tree , hf_bat_ase_identifier , parameter_tvb, offset - 1, 1, identifier);
  proto_tree_add_uint(bat_ase_element_tree , hf_length_indicator  , parameter_tvb, offset, 1, length_indicator);
  offset = offset + 1;

  proto_tree_add_bitmask_list(bat_ase_element_tree, parameter_tvb, offset, 1, compatibility_info, ENC_NA);

  offset = dissect_codec_mode(bat_ase_element_tree, parameter_tvb, offset+1, length_indicator-1);
  return offset;
}

/* Dissect BAT ASE message according to Q.765.5 200006 and Amendment 1 200107
 * Layout of message        Length          Octet
 *  Element name
 *  Identifier                  1           1
 *  Length indicator            1           2
 *  Compatibility information   1           3
 *  Contents                    1           4
 *  Identifier                  n           m
 *  Length indicator            n
 *  Compatibility information   n
 *  Contents                    n           p
 */

static void
dissect_bat_ase_Encapsulated_Application_Information(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, int offset)
{
  int         list_end;
  tvbuff_t   *next_tvb;
  proto_tree *bat_ase_tree, *bat_ase_element_tree, *bat_ase_iwfa_tree;
  proto_item *bat_ase_element_item, *bat_ase_iwfa_item;
  uint8_t     identifier, content, BCTP_Indicator_field_1, BCTP_Indicator_field_2;
  uint8_t     tempdata, element_no, number_of_indicators;
  uint16_t    sdp_length;
  uint8_t     diagnostic_len;
  uint8_t     length_ind_len;
  unsigned    tempdata16;
  unsigned    content_len, length_indicator;
  unsigned    duration;
  unsigned    diagnostic;
  uint32_t    bncid;

  element_no = 0;

  bat_ase_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1, ett_bat_ase, NULL,
                                     "Bearer Association Transport (BAT) Application Service Element (ASE) Encapsulated Application Information:");

  while (tvb_reported_length_remaining(parameter_tvb, offset) > 0) {
    element_no = element_no + 1;
    identifier = tvb_get_uint8(parameter_tvb, offset);

    /* length indicator may be 11 bits long */
    offset = offset + 1;
    proto_tree_add_item(bat_ase_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
    tempdata = tvb_get_uint8(parameter_tvb, offset);
    if (tempdata & 0x80) {
      length_indicator = tempdata & 0x7f;
      length_ind_len = 1;
    }
    else {
      offset = offset + 1;
      tempdata16 = (tempdata & 0x7f);
      length_indicator = tvb_get_uint8(parameter_tvb, offset)& 0x0f;
      length_indicator = length_indicator << 7;
      length_indicator = length_indicator + tempdata16;
      length_ind_len = 2;
    }

    bat_ase_element_tree = proto_tree_add_subtree_format(bat_ase_tree, parameter_tvb,
                                               (offset - length_ind_len), (length_indicator + 2),
                                               ett_bat_ase_element, &bat_ase_element_item,
                                               "BAT ASE Element %u, Identifier: %s", element_no,
                                               val_to_str_ext(identifier, &bat_ase_list_of_Identifiers_vals_ext, "unknown (%u)"));

    if (identifier != CODEC) {
      /* identifier, length indicator and compatibility info must be printed inside CODEC */
      /* dissection in order to use dissect_codec routine for codec list */
      proto_tree_add_uint(bat_ase_element_tree , hf_bat_ase_identifier , parameter_tvb,
                          offset - length_ind_len, 1, identifier);
      proto_tree_add_uint(bat_ase_element_tree , hf_length_indicator  , parameter_tvb,
                          offset - length_ind_len + 1, length_ind_len, length_indicator);

      offset = offset + 1;
      proto_tree_add_item(bat_ase_element_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      proto_tree_add_item(bat_ase_element_tree, hf_Send_notification_ind_for_pass_on_not_possible, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      proto_tree_add_item(bat_ase_element_tree, hf_Instruction_ind_for_pass_on_not_possible, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      proto_tree_add_item(bat_ase_element_tree, hf_Send_notification_ind_for_general_action, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      proto_tree_add_item(bat_ase_element_tree, hf_Instruction_ind_for_general_action, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      offset = offset + 1;
    }
    content_len = length_indicator - 1 ; /* exclude the treated Compatibility information */

    /* content will be different depending on identifier */
    switch (identifier) {

      case ACTION_INDICATOR :

        content = tvb_get_uint8(parameter_tvb, offset);
        proto_tree_add_uint(bat_ase_element_tree, hf_Action_Indicator , parameter_tvb, offset, 1, content);
        proto_item_append_text(bat_ase_element_item, " - %s",
                               val_to_str_ext(content, &bat_ase_action_indicator_field_vals_ext, "unknown (%u)"));
        offset = offset + 1;
        break;
      case BACKBONE_NETWORK_CONNECTION_IDENTIFIER :

        bncid = tvb_get_ntohl(parameter_tvb, offset);
        switch (content_len) {
          case 1:
            bncid = bncid & 0x000000ff;
            break;
          case 2:
            bncid = bncid & 0x0000ffff;
            break;
          case 3:
            bncid = bncid & 0x00ffffff;
            break;
          case 4:;
          default:;
        }
        proto_tree_add_uint_format(bat_ase_element_tree, hf_bncid, parameter_tvb, offset, content_len, bncid, "BNCId: 0x%08x", bncid);
        proto_item_append_text(bat_ase_element_item, " - 0x%08x", bncid);
        offset = offset + content_len;

        break;
      case INTERWORKING_FUNCTION_ADDRESS :
        bat_ase_iwfa_item = proto_tree_add_item(bat_ase_element_tree, hf_bat_ase_biwfa, parameter_tvb, offset, content_len,
                                                ENC_NA);
        bat_ase_iwfa_tree = proto_item_add_subtree(bat_ase_iwfa_item , ett_bat_ase_iwfa);
        dissect_nsap(parameter_tvb, offset, content_len, bat_ase_iwfa_tree);

        offset = offset + content_len;
        break;
      case CODEC_LIST :
        list_end = offset + content_len;
        while (offset < (list_end - 1)) {
          identifier = tvb_get_uint8(parameter_tvb, offset);
          offset = offset + 1;
          tempdata = tvb_get_uint8(parameter_tvb, offset);
          if (tempdata & 0x80) {
            length_indicator = tempdata & 0x7f;
          }
          else {
            offset = offset +1;
            length_indicator = tvb_get_uint8(parameter_tvb, offset);
            length_indicator = length_indicator << 7;
            length_indicator = length_indicator & (tempdata & 0x7f);
          }
          offset = dissect_codec(parameter_tvb, bat_ase_element_tree, length_indicator , offset, identifier);
        }
        break;
      case CODEC :
        /* offset is at length indicator in this case */
        offset = dissect_codec(parameter_tvb, bat_ase_element_tree, length_indicator , offset, identifier);
        break;/* case codec */
      case BAT_COMPATIBILITY_REPORT :
        tempdata = tvb_get_uint8(parameter_tvb, offset);
        proto_tree_add_uint(bat_ase_element_tree, hf_BAT_ASE_Comp_Report_Reason, parameter_tvb, offset, 1, tempdata);
        offset = offset + 1;

        diagnostic_len = content_len - 1;
        while (diagnostic_len > 0) {
          tempdata = tvb_get_uint8(parameter_tvb, offset);
          proto_tree_add_uint(bat_ase_element_tree, hf_BAT_ASE_Comp_Report_ident, parameter_tvb, offset, 1, tempdata);
          offset = offset + 1;
          diagnostic = tvb_get_letohs(parameter_tvb, offset);
          proto_tree_add_uint(bat_ase_element_tree, hf_BAT_ASE_Comp_Report_diagnostic, parameter_tvb, offset, 2, diagnostic);
          offset = offset + 2;
          diagnostic_len = diagnostic_len - 3;
        }
        break;
      case BEARER_NETWORK_CONNECTION_CHARACTERISTICS :
        tempdata = tvb_get_uint8(parameter_tvb, offset);
        proto_tree_add_uint(bat_ase_element_tree, hf_characteristics , parameter_tvb,
                            offset, 1, tempdata);
        proto_item_append_text(bat_ase_element_item, " - %s",
                               val_to_str_ext(tempdata, &bearer_network_connection_characteristics_vals_ext, "unknown (%u)"));

        offset = offset + content_len;
        break;
/* The Bearer Control Information information element contains the bearer control tunnelling protocol */
/* ITU-T Q.1990 (2001), BICC bearer control tunnelling protocol. */

      case BEARER_CONTROL_INFORMATION :
        BCTP_Indicator_field_1 = tvb_get_uint8(parameter_tvb, offset);
        proto_tree_add_uint(bat_ase_element_tree, hf_BCTP_Version_Indicator,
                            parameter_tvb, offset, 1, BCTP_Indicator_field_1);

        proto_tree_add_boolean(bat_ase_element_tree, hf_BVEI,
                               parameter_tvb, offset, 1, BCTP_Indicator_field_1);
        offset = offset + 1;

        BCTP_Indicator_field_2 = tvb_get_uint8(parameter_tvb, offset);

        proto_tree_add_uint(bat_ase_element_tree, hf_Tunnelled_Protocol_Indicator ,
                            parameter_tvb, offset, 1, BCTP_Indicator_field_2);

        proto_tree_add_boolean(bat_ase_element_tree, hf_TPEI,
                               parameter_tvb, offset, 1, BCTP_Indicator_field_2);
        offset = offset + 1;

        sdp_length = (length_indicator) - 3;

        if (sdp_length > tvb_reported_length_remaining(parameter_tvb, offset)) {
          /* If this is a segmented message we may not have all the data */
          next_tvb = tvb_new_subset_remaining(parameter_tvb, offset);
        } else {
          next_tvb = tvb_new_subset_length(parameter_tvb, offset, sdp_length);
        }
        if (BCTP_Indicator_field_2==0x20) {
          /* IPBCP (text encoded) */
          call_dissector(sdp_handle, next_tvb, pinfo, bat_ase_element_tree);
        } else {
          proto_tree_add_item(bat_ase_element_tree, hf_isup_tunnelled_protocol_data, next_tvb, 0, -1, ENC_NA);
        }
        offset = offset + sdp_length;
        break;
      case BEARER_CONTROL_TUNNELLING :

        tempdata = tvb_get_uint8(parameter_tvb, offset);
        proto_tree_add_boolean(bat_ase_element_tree, hf_bearer_control_tunneling , parameter_tvb, offset, 1, (tempdata & 0x01));
        if (tempdata & 0x01)
          proto_item_append_text(bat_ase_element_item, " - Tunnelling to be used ");

        offset = offset + content_len;
        break;
      case BEARER_CONTROL_UNIT_IDENTIFIER :
        tempdata = tvb_get_uint8(parameter_tvb, offset);
        proto_tree_add_item(bat_ase_element_tree, hf_isup_network_id_length_indicator, parameter_tvb, offset, 1, ENC_NA);
        offset = offset + 1;
        if (tempdata > 0) {

/* Q.765.5 amd 1
   Network ID
   The coding of the Network ID field is identical to the coding of the Network ID field in the
   Global Call Reference parameter as specified in clause 6/Q.1902.3 (see [3]).
   NOTE .When used inside a network domain, the Network ID may be omitted by setting the
   Network ID Length indicator to the value "0".
   Q.1902.3
   The following codes are used in the subfields of the global call reference parameter field:
   a) Network ID
   The Network ID contains the value field (coded according to ASN.1 BER) of an object
   identifier identifying the network. This means that the tag and length fields are omitted.
   An example of such an object identifier can be the following:
   .{itu-t (0) administration (2) national regulatory authority (x) network (y)}
   The value for x is the value of the national regulatory authority (one of the Data Country
   Codes associated to the country as specified in ITU-T X.121 shall be used for "national
   regulatory authority"), the value for y is under the control of the national regulatory
   authority concerned.
   b) Node ID
   A binary number that uniquely identifies within the network the node which generates the
   call reference.
   c) Call Reference ID
   A binary number used for the call reference of the call. This is generated by the node for
   each call.

*/
          proto_tree_add_item(bat_ase_element_tree, hf_isup_network_id, parameter_tvb, offset, tempdata, ENC_NA);
          offset += tempdata;
        } /* end if */

        proto_tree_add_item(bat_ase_element_tree, hf_Local_BCU_ID, parameter_tvb, offset, 4, ENC_LITTLE_ENDIAN);
        offset += 4;
        break;
      case SIGNAL :
        /* As type is Constructor new elements follow, return to main loop */
        break;
      case BEARER_REDIRECTION_CAPABILITY :
        tempdata = tvb_get_uint8(parameter_tvb, offset);
        proto_tree_add_boolean(bat_ase_element_tree, hf_late_cut_through_cap_ind , parameter_tvb, offset, 1, tempdata);
        offset = offset + content_len;
        break;
      case BEARER_REDIRECTION_INDICATORS :
        number_of_indicators = 0;
        while (number_of_indicators < content_len) {
          tempdata = tvb_get_uint8(parameter_tvb, offset);
          proto_tree_add_uint(bat_ase_element_tree, hf_bat_ase_bearer_redir_ind , parameter_tvb, offset, 1, tempdata);
          offset = offset + 1;
          number_of_indicators = number_of_indicators + 1;
        }
        break;
      case SIGNAL_TYPE :
        tempdata = tvb_get_uint8(parameter_tvb, offset);
        proto_tree_add_uint(bat_ase_element_tree, hf_bat_ase_signal , parameter_tvb, offset, 1, tempdata);
        offset = offset + content_len;
        break;
      case DURATION :
        duration = tvb_get_letohs(parameter_tvb, offset);
        proto_tree_add_uint(bat_ase_element_tree, hf_bat_ase_duration , parameter_tvb, offset, 2, duration);
        offset = offset + content_len;
        break;
      default :
        proto_tree_add_item(bat_ase_element_tree, hf_bat_ase_default, parameter_tvb, offset, content_len, ENC_NA);
        offset = offset + content_len;
    }
  }

}



/*
Octet
    -------------------------------------------
1   | ext. Application context identifier lsb
    -------------------------------------------
1a  | ext. msb
    -------------------------------------------
2   | ext. spare                        SNI RCI
    -------------------------------------------
3   | ext. SI APM segmentation indicator
    -------------------------------------------
3a  | ext. Segmentation local reference
    -------------------------------------------
4a  |
:   |   APM-user information
4n  |
    +-------------------------------------------

        Figure 77/Q.763 . Application transport parameter field
*/
static void
dissect_isup_application_transport_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{

  uint8_t  si_and_apm_seg_ind;
  uint8_t  apm_Segmentation_local_ref = 0;
  uint16_t aci16;
  int      offset = 0;
  uint8_t  octet;
  unsigned length = tvb_reported_length(parameter_tvb);
  bool more_frag;
  bool save_fragmented;

  tvbuff_t      *new_tvb  = NULL;
  tvbuff_t      *next_tvb = NULL;
  fragment_head *frag_msg = NULL;

  static int * const apm_flags[] = {
    &hf_isup_extension_ind,
    &hf_isup_apm_si_ind,
    &hf_isup_apm_segmentation_ind,
    NULL
  };

  static int * const app_trans_flags[] = {
    &hf_isup_extension_ind,
    &hf_isup_app_Send_notification_ind,
    &hf_isup_app_Release_call_ind,
    NULL
  };

  static int * const app_field_flags[] = {
    &hf_isup_extension_ind,
    &hf_isup_app_cont_ident,
    NULL
  };

  aci16 = tvb_get_uint8(parameter_tvb, offset);

  if ((aci16 & H_8BIT_MASK) == 0x80) {
    /* Octet 1 */
    aci16 = aci16 & 0x7f;
    proto_tree_add_bitmask(parameter_tree, parameter_tvb, offset, hf_isup_app_transport_param_field8, ett_app_transport_fields, app_field_flags, ENC_NA);
    offset = offset + 1;
  }
  /* Octet 1a */
  else {
    proto_tree_add_item(parameter_tree, hf_isup_app_transport_param_field16, parameter_tvb, offset, 2, ENC_BIG_ENDIAN);
    aci16 = (aci16<<8) | (tvb_get_uint8(parameter_tvb, offset) & 0x7f);
    proto_tree_add_uint(parameter_tree, hf_isup_app_cont_ident , parameter_tvb, offset, 2, aci16);
    offset = offset + 2;
  }

  /* Octet 2 */
  proto_tree_add_bitmask(parameter_tree, parameter_tvb, offset, hf_isup_app_transport_instruction_indicator, ett_app_transport, app_trans_flags, ENC_NA);
  offset = offset + 1;

  /* Octet 3*/
  si_and_apm_seg_ind  = tvb_get_uint8(parameter_tvb, offset);
  proto_tree_add_bitmask(parameter_tree, parameter_tvb, offset, hf_isup_apm_seg_indicator, ett_apm_seg_indicator, apm_flags, ENC_NA);
  offset = offset + 1;

  /* Octet 3a */
  if ((si_and_apm_seg_ind & H_8BIT_MASK) == 0x00) {
    apm_Segmentation_local_ref  = tvb_get_uint8(parameter_tvb, offset);
    proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
    proto_tree_add_item(parameter_tree, hf_isup_apm_slr, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
    offset = offset + 1;
  }
  /* For APM'98'-user applications. (aci 0 - 3), APM-user information field starts at octet 4 */
  if (aci16 > 3) {
    /* Octet 4 Originating Address length */
    octet = tvb_get_uint8(parameter_tvb, offset);
    proto_tree_add_item(parameter_tree, hf_isup_orig_addr_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
    offset += 1;
    if (octet != 0) {
      /* 4b */
      proto_tree_add_item(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      /* nature of address indicator */
      offset += 1;
      proto_tree_add_item(parameter_tree, hf_isup_inn_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      offset += 1;
      /* Address digits */
      proto_tree_add_item(parameter_tree, hf_isup_address_digits, parameter_tvb, offset, octet - 2, ENC_NA);
      offset = offset + octet - 2;
    }
    /* Octet 5 Destination Address length */
    octet = tvb_get_uint8(parameter_tvb, offset);
    proto_tree_add_item(parameter_tree, hf_isup_dest_addr_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
    offset += 1;
    if (octet != 0) {
      /* 4b */
      proto_tree_add_item(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      /* nature of address indicator */
      offset += 1;
      proto_tree_add_item(parameter_tree, hf_isup_inn_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      offset += 1;
      /* Address digits */
      proto_tree_add_item(parameter_tree, hf_isup_address_digits, parameter_tvb, offset, octet - 2, ENC_NA);
      offset = offset + octet - 2;
    }
  }
  /*
   * Defragment ?
   *
   */
  if (isup_apm_desegment) {
    if ((si_and_apm_seg_ind != 0xc0) && ((si_and_apm_seg_ind & H_8BIT_MASK)!=0x80)) {
      /* debug ws_warning("got here Frame %u", pinfo->num); */
      /* Segmented message */
      save_fragmented = pinfo->fragmented;
      pinfo->fragmented = true;
      more_frag = true;
      if (si_and_apm_seg_ind == 0)
        more_frag = false;

      frag_msg = fragment_add_seq_next(&isup_apm_msg_reassembly_table,
                                       parameter_tvb, offset,
                                       pinfo,
                                       (apm_Segmentation_local_ref & 0x7f),         /* ID for fragments belonging together */
                                       NULL,
                                       tvb_reported_length_remaining(parameter_tvb, offset), /* fragment length - to the end */
                                       more_frag);                                  /* More fragments? */

      if ((si_and_apm_seg_ind & 0x3f) !=0 && (si_and_apm_seg_ind &0x40) !=0) {
        /* First fragment set number of fragments */
        fragment_set_tot_len(&isup_apm_msg_reassembly_table,
                             pinfo,
                             apm_Segmentation_local_ref & 0x7f,
                             NULL,
                             (si_and_apm_seg_ind & 0x3f));
      }

      new_tvb = process_reassembled_data(parameter_tvb, offset, pinfo,
                                         "Reassembled ISUP", frag_msg, &isup_apm_msg_frag_items,
                                         NULL, parameter_tree);

      if (frag_msg) { /* Reassembled */
        col_append_str(pinfo->cinfo, COL_INFO,
                       " (Message Reassembled)");
      } else { /* Not last packet of reassembled Short Message */
        col_append_str(pinfo->cinfo, COL_INFO,
                       " (Message fragment)");
      }

      pinfo->fragmented = save_fragmented;
    }
  }/*isup_apm_desegment*/

  if (offset == (int)length) {
    /* No data */
    proto_tree_add_item(parameter_tree, hf_isup_apm_user_info_field, parameter_tvb, offset, 0, ENC_NA);
    return;
  }
  if (new_tvb) { /* take it all */
    next_tvb = new_tvb;
  } else { /* make a new subset */
    next_tvb = tvb_new_subset_remaining(parameter_tvb, offset);
  }

  proto_tree_add_item(parameter_tree, hf_isup_apm_user_info_field, parameter_tvb, offset, -1, ENC_NA);

  switch (aci16 & 0x7fff) {
    case 3:
      /* Charging ASE */
      dissect_charging_ase_ChargingMessageType_PDU(next_tvb, pinfo, parameter_tree, NULL);
      break;
    case 5:
      /* dissect BAT ASE element, without transparent data (Q.765.5-200006) */
      dissect_bat_ase_Encapsulated_Application_Information(next_tvb, pinfo, parameter_tree, 0);
      break;
    default:
      expert_add_info_format(pinfo, parameter_tree, &ei_isup_not_dissected_yet, "No further dissection of APM-user information field");
      break;
  }
}



/* ------------------------------------------------------------------
  Dissector Parameter Optional Forward Call indicators
 */
static void
dissect_isup_optional_forward_call_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t ind;
  static int * const indicators[] = {
    &hf_isup_cug_call_ind,
    &hf_isup_simple_segmentation_ind,
    &hf_isup_connected_line_identity_request_ind,
    NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, OPTIONAL_FORWARD_CALL_IND_LENGTH, indicators, ENC_NA);

  ind = tvb_get_uint8(parameter_tvb, 0);
  proto_item_append_text(parameter_item, " : %s (%u)",
                      val_to_str_const(ind & BA_8BIT_MASK, isup_CUG_call_ind_value, "spare"),
                      ind);
}
/* ------------------------------------------------------------------
  Dissector Parameter calling party number
 */
void
dissect_isup_calling_party_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t      indicators1, indicators2;
  int          offset = 0;
  int          number_plan;
  static int * const indicators1_fields[] = {
    &hf_isup_odd_even_indicator,
    &hf_isup_calling_party_nature_of_address_indicator,
    NULL
  };
  static int * const indicators2_fields[] = {
    &hf_isup_ni_indicator,
    &hf_isup_numbering_plan_indicator,
    &hf_isup_address_presentation_restricted_indicator,
    &hf_isup_screening_indicator,
    NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
  indicators2 = tvb_get_uint8(parameter_tvb, 1);
  number_plan = (indicators2 & 0x70)>> 4;
  offset = 2;

  tap_calling_number = dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
                             hf_isup_calling, hf_isup_calling_party_odd_address_signal_digit,
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
                             number_plan == 1 ? CALLING_PARTY_NUMBER : NONE,
                             (indicators1 & 0x7f));
}
/* ------------------------------------------------------------------
  Dissector Parameter Original called  number
 */
void
dissect_isup_original_called_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t     indicators1;
  int         offset = 0;
  static int * const indicators1_fields[] = {
    &hf_isup_odd_even_indicator,
    &hf_isup_calling_party_nature_of_address_indicator,
    NULL
  };
  static int * const indicators2_fields[] = {
    &hf_isup_numbering_plan_indicator,
    &hf_isup_address_presentation_restricted_indicator,
    NULL
  };


  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
  offset = 2;

  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
                             hf_isup_original_called_number,
                             hf_isup_calling_party_odd_address_signal_digit,
                             hf_isup_calling_party_even_address_signal_digit,
                             ((indicators1 & 0x80) == 0), NONE, 0);
}
/* ------------------------------------------------------------------
  Dissector Parameter Redirecting number
 */
void
dissect_isup_redirecting_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t     indicators1;
  int         offset = 0;
  static int * const indicators1_fields[] = {
    &hf_isup_odd_even_indicator,
    &hf_isup_calling_party_nature_of_address_indicator,
    NULL
  };
  static int * const indicators2_fields[] = {
    &hf_isup_numbering_plan_indicator,
    &hf_isup_address_presentation_restricted_indicator,
    NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
  offset = 2;

  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
                             hf_isup_redirecting, hf_isup_calling_party_odd_address_signal_digit,
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
                             NONE, 0);
}

/* ------------------------------------------------------------------
  Dissector Parameter Redirection number
 */
static void
dissect_isup_redirection_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t     indicators1;
  int         offset = 0;
  static int * const indicators1_fields[] = {
    &hf_isup_odd_even_indicator,
    &hf_isup_called_party_nature_of_address_indicator,
    NULL
  };
  static int * const indicators2_fields[] = {
    &hf_isup_inn_indicator,
    &hf_isup_numbering_plan_indicator,
    NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
  offset = 2;

  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
                             hf_isup_redirection_number, hf_isup_called_party_odd_address_signal_digit,
                             hf_isup_called_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
                             NONE, 0);
}

/* ------------------------------------------------------------------
  Dissector Parameter Connection request
 */
static void
dissect_isup_connection_request_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint32_t local_ref;
  uint16_t spc;
  uint8_t protocol_class, credit, offset = 0;

  local_ref = tvb_get_ntoh24(parameter_tvb, 0);
  proto_tree_add_item(parameter_tree, hf_isup_local_reference, parameter_tvb, offset, LOCAL_REF_LENGTH, ENC_BIG_ENDIAN);
  offset = LOCAL_REF_LENGTH;
  spc = tvb_get_letohs(parameter_tvb, offset) & 0x3FFF; /*since 1st 2 bits spare */
  proto_tree_add_item(parameter_tree, hf_isup_signalling_point_code, parameter_tvb, offset, SPC_LENGTH, ENC_BIG_ENDIAN);
  offset += SPC_LENGTH;
  protocol_class = tvb_get_uint8(parameter_tvb, offset);
  proto_tree_add_item(parameter_tree, hf_isup_protocol_class, parameter_tvb, offset, PROTOCOL_CLASS_LENGTH, ENC_BIG_ENDIAN);
  offset += PROTOCOL_CLASS_LENGTH;
  credit = tvb_get_uint8(parameter_tvb, offset);
  proto_tree_add_item(parameter_tree, hf_isup_credit, parameter_tvb, offset, CREDIT_LENGTH, ENC_BIG_ENDIAN);

  proto_item_append_text(parameter_item,
                      " : Local Reference = %u, SPC = %u, Protocol Class = %u, Credit = %u",
                      local_ref, spc, protocol_class, credit);
}
/* ------------------------------------------------------------------
  Dissector Parameter Redirection information
 */
void
dissect_isup_redirection_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  if (tvb_reported_length(parameter_tvb) == 2) {
    uint16_t indicators;
    indicators = tvb_get_ntohs(parameter_tvb, 0);
    proto_tree_add_uint(parameter_tree, hf_isup_redirecting_ind, parameter_tvb, 0, REDIRECTION_INFO_LENGTH, indicators);
    proto_tree_add_uint(parameter_tree, hf_isup_original_redirection_reason, parameter_tvb, 0, REDIRECTION_INFO_LENGTH, indicators);
    proto_tree_add_uint(parameter_tree, hf_isup_redirection_counter, parameter_tvb, 0, REDIRECTION_INFO_LENGTH, indicators);
    proto_tree_add_uint(parameter_tree, hf_isup_redirection_reason, parameter_tvb, 0, REDIRECTION_INFO_LENGTH, indicators);
  }
  else { /* ISUP'88 (blue book) */
    uint16_t indicators;
    indicators = tvb_get_uint8(parameter_tvb, 0) * 0x100; /*since 2nd octet isn't present*/
    proto_tree_add_uint(parameter_tree, hf_isup_redirecting_ind, parameter_tvb, 0, 1, indicators);
    proto_tree_add_uint(parameter_tree, hf_isup_original_redirection_reason, parameter_tvb, 0, 1, indicators);
    proto_item_append_text(parameter_item, " (2nd octet not present since ISUP '88)");
  }
}
/* ------------------------------------------------------------------
  Dissector Parameter Closed user group interlock code
 */
static void
dissect_isup_closed_user_group_interlock_code_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  char    NI_digits[5] = "";
  uint8_t digit_pair;
  uint16_t bin_code;

  digit_pair = tvb_get_uint8(parameter_tvb, 0);
  NI_digits[0] = number_to_char((digit_pair & HGFE_8BIT_MASK) / 0x10);
  NI_digits[1] = number_to_char(digit_pair & DCBA_8BIT_MASK);
  digit_pair = tvb_get_uint8(parameter_tvb, 1);
  NI_digits[2] = number_to_char((digit_pair & HGFE_8BIT_MASK) / 0x10);
  NI_digits[3] = number_to_char(digit_pair & DCBA_8BIT_MASK);
  NI_digits[4] = '\0';
  proto_tree_add_string(parameter_tree, hf_isup_network_identity, parameter_tvb, 0, 2, NI_digits);
  bin_code = tvb_get_ntohs(parameter_tvb, 2);
  proto_tree_add_item(parameter_tree, hf_isup_binary_code, parameter_tvb, 2, 2, ENC_BIG_ENDIAN);
  proto_item_append_text(parameter_item, " : NI = %s, Binary code = 0x%x", NI_digits, bin_code);
}
/* ------------------------------------------------------------------
  Dissector Parameter User service information- no detailed dissection since defined in Rec. Q.931
 */
static void
dissect_isup_user_service_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{ unsigned length = tvb_reported_length(parameter_tvb);
  proto_tree_add_item(parameter_tree, hf_isup_user_service_information, parameter_tvb, 0, length, ENC_NA);
  dissect_q931_bearer_capability_ie(parameter_tvb,
                                    0, length,
                                    parameter_tree);
}
/* ------------------------------------------------------------------
  Dissector Parameter Signalling point code
 */
static void
dissect_isup_signalling_point_code_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint16_t spc;

  spc = tvb_get_letohs(parameter_tvb, 0) & 0x3FFF; /*since 1st 2 bits spare */
  proto_tree_add_item(parameter_tree, hf_isup_signalling_point_code, parameter_tvb, 0, SIGNALLING_POINT_CODE_LENGTH, ENC_BIG_ENDIAN);

  proto_item_append_text(parameter_item, " : %u", spc);
}
/* ------------------------------------------------------------------
  Dissector Parameter Connected number
 */
static void
dissect_isup_connected_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t     indicators1;
  int         offset = 0;
  static int * const indicators1_fields[] = {
    &hf_isup_odd_even_indicator,
    &hf_isup_calling_party_nature_of_address_indicator,
    NULL
  };
  static int * const indicators2_fields[] = {
    &hf_isup_numbering_plan_indicator,
    &hf_isup_address_presentation_restricted_indicator,
    &hf_isup_screening_indicator,
    NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
  offset = 2;

  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
                             hf_isup_connected_number, hf_isup_calling_party_odd_address_signal_digit,
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
                             NONE, 0);
}

/* ------------------------------------------------------------------
  Dissector Transit network selection
 */
static void
dissect_isup_transit_network_selection_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t     indicators1;
  int         offset = 0;
  static int * const indicators_fields[] = {
    &hf_isup_odd_even_indicator,
    &hf_isup_type_of_network_identification,
    &hf_isup_network_identification_plan,
    NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators_fields, ENC_NA);
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
  offset = 1;

  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
                             hf_isup_transit_network_selection, hf_isup_calling_party_odd_address_signal_digit,
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
                             NONE, 0);
}

/* ------------------------------------------------------------------
  Dissector Parameter Circuit assignment map
 */
static void
dissect_isup_circuit_assignment_map_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{ uint8_t map_type;

  map_type = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint(parameter_tree, hf_isup_map_type, parameter_tvb, 0, 1, map_type);
  proto_tree_add_item(parameter_tree, hf_isup_circuit_assignment_map, parameter_tvb, 1, 5, ENC_NA);
}
/* ------------------------------------------------------------------
  Dissector Parameter Automatic congestion level
 */
static void
dissect_isup_automatic_congestion_level_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ uint8_t congestion_level;

  congestion_level = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint(parameter_tree, hf_isup_automatic_congestion_level, parameter_tvb, 0, AUTO_CONGEST_LEVEL_LENGTH, congestion_level);
  proto_item_append_text(parameter_item, " : %s (%u)",
                      val_to_str_const(congestion_level, isup_auto_congestion_level_value, "spare"), congestion_level);
}
/* ------------------------------------------------------------------
  Dissector Parameter Optional backward Call indicators
 */
static void
dissect_isup_optional_backward_call_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  static int * const indicators[] = {
    &hf_isup_inband_information_ind,
    &hf_isup_call_diversion_may_occur_ind,
    &hf_isup_simple_segmentation_ind,
    &hf_isup_mlpp_user_ind,
    NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, OPTIONAL_BACKWARD_CALL_IND_LENGTH, indicators, ENC_NA);

  proto_item_append_text(parameter_item, " : 0x%x", tvb_get_uint8(parameter_tvb, 0));
}
/* ------------------------------------------------------------------
  Dissector Parameter User-to-user indicators
 */
static const value_string isup_UUI_request_service_values[] = {
  { 0,  "No information"},
  { 1,  "Spare"},
  { 2,  "Request, not essential"},
  { 3,  "Request,essential"},
  { 0,  NULL}
};

static const value_string isup_UUI_response_service_values[] = {
  { 0,  "No information"},
  { 1,  "Not provided"},
  { 2,  "Provided"},
  { 3,  "Spare"},
  { 0,  NULL}
};
static const true_false_string isup_UUI_network_discard_ind_value = {
  "User-to-user information discarded by the network",
  "No information"
};

static void
dissect_isup_user_to_user_indicators_parameter(tvbuff_t *parameter_tvb,
                                               proto_tree *parameter_tree,
                                               proto_item *parameter_item)
{
  uint8_t indicators;
  static int * const req_fields[] = {
    &hf_isup_UUI_type,
    &hf_isup_UUI_req_service1,
    &hf_isup_UUI_req_service2,
    &hf_isup_UUI_req_service3,
    NULL
  };
  static int * const res_fields[] = {
    &hf_isup_UUI_type,
    &hf_isup_UUI_res_service1,
    &hf_isup_UUI_res_service2,
    &hf_isup_UUI_res_service3,
    &hf_isup_UUI_network_discard_ind,
    NULL
  };

  indicators = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_boolean(parameter_tree, hf_isup_UUI_type, parameter_tvb, 0, 1, indicators);
  if ((indicators & 0x01) == 0) {
    /* Request */
    proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, req_fields, ENC_NA);
  }
  else {
    /* Response */
    proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, res_fields, ENC_NA);
  }
  proto_item_append_text(parameter_item, " : 0x%x", indicators);
}
/* ------------------------------------------------------------------
  Dissector Parameter Original ISC point code
 */
static void
dissect_isup_original_isc_point_code_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint16_t spc;

  spc = tvb_get_letohs(parameter_tvb, 0) & 0x3FFF; /*since 1st 2 bits spare */
  proto_tree_add_item(parameter_tree, hf_isup_origination_isc_point_code, parameter_tvb, 0, ORIGINAL_ISC_POINT_CODE_LENGTH, ENC_BIG_ENDIAN);

  proto_item_append_text(parameter_item, " : %u", spc);
}
/* ------------------------------------------------------------------
   Dissector Parameter Generic notification indicator

   3.25 Generic notification indicator

   a) Extension indicator (ext.)
   0 information continues in the next octet
   1 last octet

   b) Notification indicator
   0 0 0 0 0 0 0 user suspended
   0 0 0 0 0 0 1 user resumed
   0 0 0 0 0 1 0 bearer service change
   0 0 0 0 0 1 1 encoded component discriminator for extension to ASN.1 (used in DSS1)
   0 0 0 0 1 0 0 call completion delay
   
   1 0 0 0 0 0 1
   to
   0 0 0 0 1 0 1 reserved

   1 0 0 0 0 1 0 conference established
   1 0 0 0 0 1 1 conference disconnected
   1 0 0 0 1 0 0 other party added
   1 0 0 0 1 0 1 isolated
   1 0 0 0 1 1 0 reattached
   1 0 0 0 1 1 1 other party isolated
   1 0 0 1 0 0 0 other party reattached
   1 0 0 1 0 0 1 other party split
   1 0 0 1 0 1 0 other party disconnected
   1 0 0 1 0 1 1 conference floating
   
   1 0 1 1 1 1 1
   to
   1 0 0 1 1 0 0 reserved

   1 1 0 0 0 0 0 call is a waiting call
   
   1 1 0 0 1 1 1
   to
   1 1 0 0 0 0 1 reserved

   1 1 0 1 0 0 0 diversion activated (used in DSS1)
   1 1 0 1 0 0 1 call transfer, alerting
   1 1 0 1 0 1 0 call transfer, active
   
   
   
   1 1 1 1 0 0 0
   to
   1 1 0 1 0 1 1
   reserved
   1 1 1 1 0 0 1 remote hold
   1 1 1 1 0 1 0 remote retrieval
   1 1 1 1 0 1 1 call is diverting
   
   
   
   1 1 1 1 1 1 1
   to
   1 1 1 1 1 0 0
   reserved
*/
static const value_string q763_generic_notification_indicator_vals[] = {
    { 0x00 , "User Suspended" },
    { 0x01 , "User Resumed" },
    { 0x02 , "Bearer service change" },
    { 0x03 , "Discriminator for extension to ASN.1 encoded component (used in DSS1)" },
    { 0x04 , "Call completion delay" },
    { 0x42 , "Conference established" },
    { 0x43 , "Conference disconnected" },
    { 0x44 , "Other party added" },
    { 0x45 , "Isolated" },
    { 0x46 , "Reattached" },
    { 0x47 , "Other party isolated" },
    { 0x48 , "Other party reattached" },
    { 0x49 , "Other party split" },
    { 0x4A , "Other party disconnected" },
    { 0x4B , "Conference floating" },
    { 0x60 , "Call is a waiting call" },
    { 0x68 , "Diversion activated (used in DSS1)" },
    { 0x69 , "Call transfer, alerting" },
    { 0x6A , "Call transfer, active" },
    { 0x79 , "Remote hold" },
    { 0x7A , "Remote retrieval" },
    { 0x7B , "Call is diverting" },
    { 0 , NULL },
};
static value_string_ext q763_generic_notification_indicator_vals_ext = VALUE_STRING_EXT_INIT(q763_generic_notification_indicator_vals);

static void
dissect_isup_generic_notification_indicator_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t indicators;

  indicators = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
  proto_tree_add_item(parameter_tree, hf_isup_notification_indicator, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
  proto_item_append_text(parameter_item, " : %s",
                      val_to_str_ext((indicators&0x7f), &q763_generic_notification_indicator_vals_ext, "Reserved (0x%X)"));
}
/* ------------------------------------------------------------------
  Dissector Parameter Call history information
 */
static void
dissect_isup_call_history_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint16_t info;

  info = tvb_get_ntohs(parameter_tvb, 0);
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_call_history_info, parameter_tvb, 0, CALL_HISTORY_INFO_LENGTH, info, "propagation delay = %u ms", info);
  proto_item_append_text(parameter_item, " : propagation delay = %u ms", info);
}
/* ------------------------------------------------------------------
  Dissector Parameter Access delivery information
 */
static void
dissect_isup_access_delivery_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t indicator;

  indicator = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_boolean(parameter_tree, hf_isup_access_delivery_ind, parameter_tvb, 0, ACCESS_DELIVERY_INFO_LENGTH, indicator);
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
}
/* ------------------------------------------------------------------
  Dissector Parameter Network specific facility
 */
static void
dissect_isup_network_specific_facility_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{ unsigned length = tvb_reported_length(parameter_tvb);
  proto_tree_add_item(parameter_tree, hf_isup_network_specific_facility, parameter_tvb, 0, length, ENC_NA);
}
/* ------------------------------------------------------------------
  Dissector Parameter User service information prime
 */
static void
dissect_isup_user_service_information_prime_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{ unsigned length = tvb_reported_length(parameter_tvb);
  proto_tree_add_item(parameter_tree, hf_isup_user_service_information_prime, parameter_tvb, 0, length, ENC_NA);
  dissect_q931_bearer_capability_ie(parameter_tvb,
                                    0, length,
                                    parameter_tree);
}
/* ------------------------------------------------------------------
  Dissector Parameter Propagation delay counter
 */
static void
dissect_isup_propagation_delay_counter_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint32_t info;

  proto_tree_add_item_ret_uint(parameter_tree, hf_isup_propagation_delay_counter, parameter_tvb, 0, PROPAGATION_DELAY_COUNT_LENGTH, ENC_BIG_ENDIAN, &info);
  proto_item_append_text(parameter_item, ": counter = %u ms", info);
}
/* ------------------------------------------------------------------
  Dissector Parameter Remote operations
 */
static void
dissect_isup_remote_operations_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{ unsigned length = tvb_reported_length(parameter_tvb);
  proto_tree_add_item(parameter_tree, hf_isup_remote_operations, parameter_tvb, 0, length, ENC_NA);
}
/* ------------------------------------------------------------------
  Dissector Parameter Service activation
 */
static void
dissect_isup_service_activation_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  unsigned  i;
  uint8_t feature_code;
  unsigned  length = tvb_reported_length(parameter_tvb);

  for (i=0; i<length; i++) {
    feature_code = tvb_get_uint8(parameter_tvb, i);
    proto_tree_add_uint_format(parameter_tree, hf_isup_feature_code, parameter_tvb, i, 1, feature_code, "Feature Code %u: %u", i+1, feature_code);
  }
}
/* ------------------------------------------------------------------
  Dissector Parameter User service information prime - no detailed dissection since defined in Rec. Q.931
 */
static void
dissect_isup_user_teleservice_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  unsigned length = tvb_reported_length(parameter_tvb);
  proto_tree_add_item(parameter_tree, hf_isup_user_teleservice_information, parameter_tvb, 0, length, ENC_NA);

  dissect_q931_high_layer_compat_ie(parameter_tvb, 0, length, parameter_tree);
}
/* ------------------------------------------------------------------
  Dissector Parameter Transmission medium requirement used
 */
static void
dissect_isup_transmission_medium_used_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t transmission_medium_requirement;

  transmission_medium_requirement = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint(parameter_tree, hf_isup_transmission_medium_requirement_prime,
                      parameter_tvb, 0, TRANSMISSION_MEDIUM_RQMT_PRIME_LENGTH, transmission_medium_requirement);

  proto_item_append_text(parameter_item,
                      " : %u (%s)",
                      transmission_medium_requirement,
                      val_to_str_ext_const(transmission_medium_requirement,
                                           &isup_transmission_medium_requirement_prime_value_ext,
                                           "spare/reserved"));
}
/* ------------------------------------------------------------------
  Dissector Parameter Call diversion information
 */
static void
dissect_isup_call_diversion_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ uint8_t indicator;

  indicator = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_call_diversion_information, parameter_tvb, 0, CALL_DIV_INFO_LENGTH, indicator,
        "0x%x (refer to 3.6/Q.763 for detailed decoding)", indicator);
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
}
/* ------------------------------------------------------------------
  Dissector Parameter Echo control  information
 */
static const value_string OECD_inf_ind_vals[] = {
  {0x00, "no information"},
  {0x01, "outgoing echo control device not included and not available"},
  {0x02, "outgoing echo control device included"},
  {0x03, "outgoing echo control device not included but available"},
  { 0,  NULL }
};
static const value_string IECD_inf_ind_vals[] = {
  {0x00, "no information"},
  {0x01, "incoming echo control device not included and not available"},
  {0x02, "incoming echo control device included"},
  {0x03, "incoming echo control device not included but available"},
  { 0,  NULL }
};

static const value_string OECD_req_ind_vals[] = {
  {0x00, "no information"},
  {0x01, "outgoing echo control device activation request"},
  {0x02, "outgoing echo control device deactivation request"},
  {0x03, "spare"},
  { 0,  NULL }
};

static const value_string IECD_req_ind_vals[] = {
  {0x00, "no information"},
  {0x01, "incoming echo control device activation request"},
  {0x02, "incoming echo control device deactivation request"},
  {0x03, "spare"},
  { 0,  NULL }
};

static void
dissect_isup_echo_control_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ uint8_t indicator;
  static int * const info[] = {
    &hf_isup_OECD_inf_ind,
    &hf_isup_IECD_inf_ind,
    &hf_isup_OECD_req_ind,
    &hf_isup_IECD_req_ind,
    NULL
  };

  indicator = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_bitmask(parameter_tree, parameter_tvb, 0, hf_isup_echo_control_information, ett_echo_control_information, info, ENC_NA);

  proto_item_append_text(parameter_item, " : 0x%x", indicator);
}
/* ------------------------------------------------------------------
  Dissector Parameter Message compatibility information
 */

static const true_false_string isup_pass_on_not_possible_indicator_value = {
  "discard information",
  "release call",
};

static void
dissect_isup_message_compatibility_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  int   offset = 0;

  static int * const params[] = {
    &hf_isup_transit_at_intermediate_exchange_ind,
    &hf_isup_Release_call_ind,
    &hf_isup_Send_notification_ind,
    &hf_isup_Discard_message_ind_value,
    &hf_isup_pass_on_not_possible_indicator2,
    &hf_isup_Broadband_narrowband_interworking_ind2,
    &hf_isup_extension_ind,
    NULL
  };

  proto_tree_add_bitmask(parameter_tree, parameter_tvb, offset, hf_isup_message_compatibility_information, ett_message_compatibility_information, params, ENC_NA);
}
/* ------------------------------------------------------------------
  Dissector Parameter compatibility information
 */
static const true_false_string isup_transit_at_intermediate_exchange_ind_value  = {
  "End node interpretation",
  "Transit interpretation"
};


static const true_false_string isup_Discard_message_ind_value = {
  "Discard message",
  "Do not discard message (pass on)",
};

static const true_false_string isup_Discard_parameter_ind_value = {
  "Discard parameter",
  "Do not discard parameter (pass on)",
};

static const value_string isup_Pass_on_not_possible_indicator_vals[] = {
  { 0x00, "Release call" },
  { 0x01, "Discard message" },
  { 0x02, "Discard parameter" },
  { 0x03, "Reserved (interpreted as 00)" },
  { 0, NULL },
};
static const value_string ISUP_Broadband_narrowband_interworking_indicator_vals[] = {
  { 0x00, "Pass on" },
  { 0x01, "Discard message" },
  { 0x02, "Release call" },
  { 0x03, "Discard parameter" },
  { 0, NULL },
};

static void
dissect_isup_parameter_compatibility_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  unsigned  length = tvb_reported_length(parameter_tvb);
  unsigned  len    = length;
  uint8_t upgraded_parameter, upgraded_parameter_no;
  int    offset;
  uint8_t instruction_indicators;

  static int * const indicator_flags[] = {
    &hf_isup_transit_at_intermediate_exchange_ind,
    &hf_isup_Release_call_ind,
    &hf_isup_Send_notification_ind,
    &hf_isup_Discard_message_ind_value,
    &hf_isup_Discard_parameter_ind,
    &hf_isup_Pass_on_not_possible_indicator,
    &hf_isup_extension_ind,
    NULL
  };

  offset = 0;
  upgraded_parameter_no = 0;

/* etxrab Decoded as per Q.763 section 3.41 */

  while (len > 0) {
    upgraded_parameter_no = upgraded_parameter_no + 1;
    upgraded_parameter = tvb_get_uint8(parameter_tvb, offset);

    proto_tree_add_uint_format(parameter_tree, hf_isup_upgraded_parameter, parameter_tvb, offset, 1, upgraded_parameter,
                              "Upgraded parameter no: %u = %s", upgraded_parameter_no,
                              val_to_str_ext(upgraded_parameter, &isup_parameter_type_value_ext, "unknown (%u)"));
    offset += 1;
    len -= 1;
    instruction_indicators = tvb_get_uint8(parameter_tvb, offset);
    proto_tree_add_bitmask(parameter_tree, parameter_tvb, offset, hf_isup_instruction_indicators, ett_instruction_indicators, indicator_flags, ENC_NA);

    offset += 1;
    len -= 1;
    if (!(instruction_indicators & H_8BIT_MASK)) {
      if (len == 0)
        return;
      instruction_indicators = tvb_get_uint8(parameter_tvb, offset);
      proto_tree_add_uint(parameter_tree, hf_isup_Broadband_narrowband_interworking_ind,
                          parameter_tvb, offset, 1, instruction_indicators);
      offset += 1;
      len -= 1;
    }

    if (len == 0)
      return;
  }
}
/* ------------------------------------------------------------------
  Dissector Parameter MLPP precedence
 */
static const value_string isup_mlpp_precedence_look_forward_busy_vals[] = {
    { 0x00 , "Allowed" },
    { 0x01 , "Not Allowed" },
    { 0x02 , "Path reserved" },
    { 0x03 , "Spare" },
    { 0 , NULL },
};

static const value_string isup_mlpp_precedence_level_vals[] = {
    { 0x00 , "Flash Override" },
    { 0x01 , "Flash" },
    { 0x02 , "Immediate" },
    { 0x03 , "Priority" },
    { 0x04 , "Routine" },
    { 0x05 , "Spare" },
    { 0x06 , "Spare" },
    { 0x07 , "Spare" },
    { 0x08 , "Spare" },
    { 0x09 , "Spare" },
    { 0x0A , "Spare" },
    { 0x0B , "Spare" },
    { 0x0C , "Spare" },
    { 0x0D , "Spare" },
    { 0x0E , "Spare" },
    { 0x0F , "Spare" },
    { 0 , NULL },
};

static void
dissect_isup_mlpp_precedence_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  char        NI_digits[5] = "";
  const char *temp_text = "";
  uint8_t     digit_pair;
  uint32_t    bin_code;

  proto_tree_add_item(parameter_tree, hf_isup_look_forward_busy, parameter_tvb, 0, 1, ENC_NA);

  proto_tree_add_item(parameter_tree, hf_isup_precedence_level, parameter_tvb, 0, 1, ENC_NA);

  digit_pair   = tvb_get_uint8(parameter_tvb, 1);
  NI_digits[0] = number_to_char((digit_pair & HGFE_8BIT_MASK) / 0x10);
  NI_digits[1] = number_to_char(digit_pair & DCBA_8BIT_MASK);
  digit_pair   = tvb_get_uint8(parameter_tvb, 2);
  NI_digits[2] = number_to_char((digit_pair & HGFE_8BIT_MASK) / 0x10);
  NI_digits[3] = number_to_char(digit_pair & DCBA_8BIT_MASK);
  NI_digits[4] = '\0';
  proto_tree_add_string(parameter_tree, hf_isup_network_identity, parameter_tvb, 1, 2, NI_digits);
  bin_code = tvb_get_ntoh24(parameter_tvb, 3);
  proto_tree_add_item(parameter_tree, hf_isup_mlpp_service_domain, parameter_tvb, 3, 3, ENC_BIG_ENDIAN);
  proto_item_append_text(parameter_item,
                      " : Prec = %s, NI = %s, MLPP service domain = 0x%x", temp_text, NI_digits, bin_code);
}
/* ------------------------------------------------------------------
  Dissector Parameter MCID request indicators
 */
static void
dissect_isup_mcid_request_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ uint8_t indicator;

  indicator = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_mcid_request_indicators, parameter_tvb, 0, MCID_REQUEST_IND_LENGTH, indicator, "0x%x (MCID requested by Bit1=1, Holding requested by Bit2=1 see 3.31/Q.763)", indicator);
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
}
/* ------------------------------------------------------------------
  Dissector Parameter MCID response indicators
 */
static void
dissect_isup_mcid_response_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ uint8_t indicator;

  indicator = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_mcid_response_indicators, parameter_tvb, 0, MCID_RESPONSE_IND_LENGTH, indicator, "0x%x (MCID included if Bit1=1, Holding provided if Bit2=1 see 3.32/Q.763)", indicator);
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
}
/* ------------------------------------------------------------------
  Dissector Parameter Hop counter
 */
static void
dissect_isup_hop_counter_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ uint8_t counter;

  counter = tvb_get_uint8(parameter_tvb, 0) & EDCBA_8BIT_MASK; /* since bits H,G and F are spare */
  proto_tree_add_item(parameter_tree, hf_isup_hop_counter, parameter_tvb, 0, HOP_COUNTER_LENGTH, ENC_NA);
  proto_item_append_text(parameter_item, " : %u", counter);
}
/* ------------------------------------------------------------------
  Dissector Parameter Originating line information
 */
static void
dissect_isup_orig_line_info_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ uint8_t info;

  info = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_item(parameter_tree, hf_isup_originating_line_info, parameter_tvb, 0, ORIG_LINE_INFO_LENGTH, ENC_NA);
  proto_item_append_text(parameter_item,  " : %u (ANI II if < 51, reserved otherwise)", info);
}
/* ------------------------------------------------------------------
  Dissector Parameter Transmission medium requirement prime
 */
static void
dissect_isup_transmission_medium_requirement_prime_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t transmission_medium_requirement;

  transmission_medium_requirement = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint(parameter_tree, hf_isup_transmission_medium_requirement_prime,
                      parameter_tvb, 0, TRANSMISSION_MEDIUM_RQMT_PRIME_LENGTH, transmission_medium_requirement);

  proto_item_append_text(parameter_item,
                      " : %u (%s)",
                      transmission_medium_requirement,
                      val_to_str_ext_const(transmission_medium_requirement,
                                           &isup_transmission_medium_requirement_prime_value_ext,
                                           "spare/reserved"));
}

/* ------------------------------------------------------------------
  Dissector Parameter location number
 */
void
dissect_isup_location_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t     indicators1, indicators2;
  int         offset = 0;
  static int * const indicators1_fields[] = {
    &hf_isup_odd_even_indicator,
    &hf_isup_calling_party_nature_of_address_indicator,
    NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
  indicators2 = tvb_get_uint8(parameter_tvb, 1);
  proto_tree_add_boolean(parameter_tree, hf_isup_inn_indicator, parameter_tvb, 1, 1, indicators2);
  proto_tree_add_uint(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, 1, 1, indicators2);
  if ((indicators2 & GFE_8BIT_MASK) == 0x50) {
    proto_tree_add_uint_format_value(parameter_tree, hf_isup_number_different_meaning, parameter_tvb, 1, 1, indicators2 & GFE_8BIT_MASK,
                                     "Numbering plan indicator = private numbering plan");
  }
  proto_tree_add_uint(parameter_tree, hf_isup_address_presentation_restricted_indicator, parameter_tvb, 1, 1, indicators2);
  proto_tree_add_uint(parameter_tree, hf_isup_screening_indicator, parameter_tvb, 1, 1, indicators2);

   /* NOTE  When the address presentation restricted indicator indicates address not available, the
    * subfields in items a), b), c) and d) are coded with 0's, and the screening indicator is set to 11
    * (network provided).
    * BUG 938 - Just check if there is someting more to dissect.
    */
  if (tvb_reported_length_remaining(parameter_tvb, offset) < 3) {
    proto_item_append_text(parameter_item, " : address not available");
    return;
  }

  offset = 2;

  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
                             hf_isup_location_number, hf_isup_calling_party_odd_address_signal_digit,
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
                             NONE, 0);
}

/* ------------------------------------------------------------------
  Dissector Parameter Redirection number restriction
 */
static const value_string isup_redirection_presentation_indicator_vals[] = {
    { 0x00 , "Presentation allowed" },
    { 0x01 , "Presentation restricted" },
    { 0x02 , "Spare" },
    { 0x03 , "Spare" },
    { 0 , NULL },
};

static void
dissect_isup_redirection_number_restriction_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t indicator;

  indicator = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_item(parameter_tree, hf_isup_presentation_indicator, parameter_tvb, 0, REDIRECTION_NUMBER_RESTRICTION_LENGTH, ENC_NA);
  proto_item_append_text(parameter_item, " : 0x%x ", indicator);
}
/* ------------------------------------------------------------------
  Dissector Parameter Call transfer identity
 */
static void
dissect_isup_call_transfer_reference_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ uint8_t id;

  id = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_item(parameter_tree, hf_isup_call_transfer_identity, parameter_tvb, 0, CALL_TRANSFER_REF_LENGTH, ENC_NA);
  proto_item_append_text(parameter_item,  " : %u", id);
}
/* ------------------------------------------------------------------
  Dissector Parameter Loop prevention
 */

static void
dissect_isup_loop_prevention_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t indicator;

  indicator = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_item(parameter_tree, hf_isup_loop_prevention_indicator_type, parameter_tvb, 0, LOOP_PREVENTION_IND_LENGTH, ENC_NA);
  if ((indicator & A_8BIT_MASK) == 0) {
    proto_item_append_text(parameter_item, " : Request (%u)", indicator);
  }
  else {
    proto_tree_add_uint(parameter_tree, hf_isup_loop_prevention_response_ind,
                        parameter_tvb, 0, LOOP_PREVENTION_IND_LENGTH, indicator);
    proto_item_append_text(parameter_item, " : Response (%u)", indicator);
  }
}

/* ------------------------------------------------------------------
  Dissector Parameter Call transfer number
 */
static void
dissect_isup_call_transfer_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t     indicators1, indicators2;
  int         offset = 0;

  indicators1 = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_boolean(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, indicators1);
  proto_tree_add_uint(parameter_tree, hf_isup_calling_party_nature_of_address_indicator, parameter_tvb, 0, 1, indicators1);
  indicators2 = tvb_get_uint8(parameter_tvb, 1);
  proto_tree_add_uint(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, 1, 1, indicators2);
  if ((indicators2 & GFE_8BIT_MASK) == 0x50)
    proto_tree_add_uint_format_value(parameter_tree, hf_isup_number_different_meaning, parameter_tvb, 1, 1, indicators2 & GFE_8BIT_MASK,
                    "Numbering plan indicator = private numbering plan");
  proto_tree_add_uint(parameter_tree, hf_isup_address_presentation_restricted_indicator, parameter_tvb, 1, 1, indicators2);
  proto_tree_add_uint(parameter_tree, hf_isup_screening_indicator_enhanced, parameter_tvb, 1, 1, indicators2);
  offset = 2;

  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
                             hf_isup_call_transfer_number, hf_isup_calling_party_odd_address_signal_digit,
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
                             NONE, 0);
}

/* ------------------------------------------------------------------
  Dissector Parameter CCSS
 */
static const true_false_string tfs_ccss_call_no_indication = { "CCSS call", "no indication"};

static void
dissect_isup_ccss_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t indicator;

  indicator = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_item(parameter_tree, hf_isup_ccss_call_indicator, parameter_tvb, 0, LOOP_PREVENTION_IND_LENGTH, ENC_NA);
  if ((indicator & A_8BIT_MASK) == 0) {
    proto_item_append_text(parameter_item, " : no indication (%u)", indicator);
  }
  else {
    proto_item_append_text(parameter_item, " : CCSS call (%u)", indicator);
  }
}
/* ------------------------------------------------------------------
 Parameter Forward GVNS
 */
static void
dissect_isup_forward_gvns_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{ unsigned length = tvb_reported_length(parameter_tvb);
  proto_tree_add_item(parameter_tree, hf_isup_forward_gvns, parameter_tvb, 0, length, ENC_NA);
}
/* ------------------------------------------------------------------
 Parameter Redirect capability
 */

static const value_string isup_jpn_redirect_capabilit_vals[] = {
  { 0,   "Reserved" },
  { 1,   "Redirect possible before ACM" },
  { 2,   "Reserved" },
  { 3,   "Reserved" },
  { 4,   "Spare" },
  { 5,   "Spare" },
  { 6,   "Spare" },
  { 7,   "Spare" },
  { 0,   NULL}
};

static void
dissect_isup_redirect_capability_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_, uint8_t itu_isup_variant)
{
  unsigned length = tvb_reported_length(parameter_tvb);

  switch (itu_isup_variant) {
    case ISUP_JAPAN_VARIANT:
    /* Fall through */
    case ISUP_JAPAN_TTC_VARIANT:
      proto_tree_add_item(parameter_tree, hf_isup_extension_ind,             parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
      proto_tree_add_item(parameter_tree, hf_japan_isup_redirect_capability, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
      break;
    default:
      proto_tree_add_uint_format_value(parameter_tree, hf_isup_redirect_capability, parameter_tvb, 0, length, itu_isup_variant, "(format is a national matter)");
      break;
  }
}
/* ------------------------------------------------------------------
  Dissector Parameter Backward GVNS
 */
static void
dissect_isup_backward_gvns_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ uint8_t indicator;

  indicator = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_backward_gvns, parameter_tvb, 0, BACKWARD_GVNS_LENGTH, indicator,
                    "0x%x (refer to 3.62/Q.763 for detailed decoding)", indicator);
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
}
/* ------------------------------------------------------------------
  Dissector Parameter Network management controls
 */
static void
dissect_isup_network_management_controls_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ uint8_t indicator;

  indicator = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_boolean(parameter_tree, hf_isup_temporary_alternative_routing_ind,
                         parameter_tvb, 0, NETWORK_MANAGEMENT_CONTROLS_LENGTH, indicator);
  proto_tree_add_boolean(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, NETWORK_MANAGEMENT_CONTROLS_LENGTH, indicator);
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
}
/* ------------------------------------------------------------------
  Dissector Parameter Correlation id - no detailed dissection since defined in Rec. Q.1281
 */
static void
dissect_isup_correlation_id_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{ unsigned length = tvb_reported_length(parameter_tvb);
  proto_tree_add_item(parameter_tree, hf_isup_correlation_id, parameter_tvb, 0, length, ENC_NA);
}
/* ------------------------------------------------------------------
  Dissector Parameter SCF id - no detailed dissection since defined in Rec. Q.1281
 */
static void
dissect_isup_scf_id_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{ unsigned length = tvb_reported_length(parameter_tvb);
  proto_tree_add_item(parameter_tree, hf_isup_scf_id, parameter_tvb, 0, length, ENC_NA);
}
/* ------------------------------------------------------------------
  Dissector Parameter Call diversion treatment indicators
 */
static void
dissect_isup_call_diversion_treatment_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ uint8_t indicator;

  indicator = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint(parameter_tree, hf_isup_call_to_be_diverted_ind, parameter_tvb, 0, CALL_DIV_TREATMENT_IND_LENGTH, indicator);
  proto_tree_add_boolean(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, CALL_DIV_TREATMENT_IND_LENGTH, indicator);
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
}

/* ------------------------------------------------------------------
  Dissector Parameter called IN  number
 */
static void
dissect_isup_called_in_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t     indicators1;
  int         offset = 0;
  static int * const indicators1_fields[] = {
    &hf_isup_odd_even_indicator,
    &hf_isup_calling_party_nature_of_address_indicator,
    NULL
  };
  static int * const indicators2_fields[] = {
    &hf_isup_numbering_plan_indicator,
    &hf_isup_address_presentation_restricted_indicator,
    NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
  offset = 2;

  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
                             hf_isup_called_in_number, hf_isup_calling_party_odd_address_signal_digit,
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
                             NONE, 0);
}

/* ------------------------------------------------------------------
  Dissector Parameter Call offering treatment indicators
 */
static void
dissect_isup_call_offering_treatment_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ uint8_t indicator;

  indicator = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint(parameter_tree, hf_isup_call_to_be_offered_ind, parameter_tvb, 0, CALL_OFFERING_TREATMENT_IND_LENGTH, indicator);
  proto_tree_add_boolean(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, CALL_OFFERING_TREATMENT_IND_LENGTH, indicator);
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
}
/* ------------------------------------------------------------------
 Parameter Charged party identification
 */
static void
dissect_isup_charged_party_identification_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{ unsigned length = tvb_reported_length(parameter_tvb);
  proto_tree_add_item(parameter_tree, hf_isup_charged_party_identification, parameter_tvb, 0, length, ENC_NA);
}
/* ------------------------------------------------------------------
  Dissector Parameter Conference treatment indicators
 */
static void
dissect_isup_conference_treatment_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ uint8_t indicator;

  indicator = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint(parameter_tree, hf_isup_conference_acceptance_ind, parameter_tvb, 0, CONFERENCE_TREATMENT_IND_LENGTH, indicator);
  proto_tree_add_boolean(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, CONFERENCE_TREATMENT_IND_LENGTH, indicator);
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
}
/* ------------------------------------------------------------------
  Dissector Parameter Display information
 * TODO Output Display info :
 * Quote from Q.931:
 * 4.5.16 Display
 * The purpose of the Display information element is to supply display information
 * that may be displayed by the user. The information contained in this element is coded
 * in IA5 characters.
 * 8 7 6 5 4 3 2 1   Octet
 * 0 0 1 0 1 0 0 0   1      Display information element identifier
 *                   2      Length of display contents
 * 0                 3      Display information (IA5 characters)
 * etc.
 * - end - quote -
 * Assuming octet 2 and onwards is passed here - just output text ?
 */
static void
dissect_isup_display_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{ unsigned length = tvb_reported_length(parameter_tvb);
  proto_tree_add_item(parameter_tree, hf_isup_display_information, parameter_tvb, 0, length, ENC_NA);
}
/* ------------------------------------------------------------------
 Parameter UID action indicators
 */
static void
dissect_isup_uid_action_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ uint8_t indicator;

  indicator = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_uid_action_indicators, parameter_tvb, 0, UID_ACTION_IND_LENGTH, indicator,
        "0x%x (refer to 3.78/Q.763 for detailed decoding)", indicator);
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
}
/* ------------------------------------------------------------------
 Parameter UID capability indicators
 */
static void
dissect_isup_uid_capability_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ uint8_t indicator;

  indicator = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_uid_capability_indicators, parameter_tvb, 0, UID_CAPABILITY_IND_LENGTH,
                      indicator, "0x%x (refer to 3.79/Q.763 for detailed decoding)", indicator);
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
}
/* ------------------------------------------------------------------
 Parameter Redirect counter
 */
static void
dissect_isup_redirect_counter_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_, uint8_t itu_isup_variant)
{
  unsigned length = tvb_reported_length(parameter_tvb);

  switch (itu_isup_variant) {
    case ISUP_JAPAN_VARIANT:
    /* Fall through */
    case ISUP_JAPAN_TTC_VARIANT:
      proto_tree_add_item(parameter_tree, hf_japan_isup_redirect_counter, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
      break;
    default:
      proto_tree_add_uint_format_value(parameter_tree, hf_isup_redirect_counter, parameter_tvb, 0, length, itu_isup_variant, "(format is a national matter)");
      break;
  }
}
/* ------------------------------------------------------------------
  Dissector Parameter Collect call request
 */
static const true_false_string tfs_collect_call_req_no_indication = { "collect call requested", "no indication"};

static void
dissect_isup_collect_call_request_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
{ uint8_t indicator;

  indicator = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_item(parameter_tree, hf_isup_collect_call_request_indicator, parameter_tvb, 0, COLLECT_CALL_REQUEST_LENGTH, ENC_NA);
  if ((indicator & A_8BIT_MASK) == 0) {
    proto_item_append_text(parameter_item, " : no indication (0x%x)", indicator);
  }
  else {
    proto_item_append_text(parameter_item, " : collect call requested (0x%x)", indicator);
  }
}
/* ------------------------------------------------------------------
  Dissector Parameter Calling geodetic location
 */
void
dissect_isup_calling_geodetic_location_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  unsigned  length = tvb_reported_length(parameter_tvb);
  uint8_t oct, lpri;

  oct = tvb_get_uint8(parameter_tvb, 0);
  lpri = (oct & 0xc0) >> 2;

  proto_tree_add_uint(parameter_tree, hf_isup_geo_loc_presentation_restricted_ind, parameter_tvb, 0, 1, oct);
  proto_tree_add_uint(parameter_tree, hf_isup_geo_loc_screening_ind, parameter_tvb, 0, 1, oct);

  proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, 1, 1, ENC_NA);
  proto_tree_add_item(parameter_tree, hf_isup_geo_loc_shape, parameter_tvb, 1, 1, ENC_NA);

  if (length > 2)
  {
    if (lpri < 0x2)
    {
      proto_tree_add_item(parameter_tree, hf_isup_geo_loc_shape_description, parameter_tvb, 2, length - 2, ENC_NA);
    }
    else
    {
      /* not supposed to have any data if 'lpri' was 'location not available' */

      proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, 2, length - 2,
                "Unknown (?), should not have data if LPRI is 'location not available'");
    }
  }
}

/* ------------------------------------------------------------------
  Dissector Parameter Generic number
 */
static const range_string number_qualifier_indicator_vals[] = {
  { 0x00, 0x00, "reserved (dialled digits) (national use)"},
  { 0x01, 0x01, "additional called number (national use)"},
  { 0x02, 0x02, "reserved (supplemental user provided calling number - failed network screening) (national use)"},
  { 0x03, 0x03, "reserved (supplemental user provided calling number - not screened) (national use)"},
  { 0x04, 0x04, "reserved (redirecting terminating number) (national use)"},
  { 0x05, 0x05, "additional connected number"},
  { 0x06, 0x06, "additional calling party number"},
  { 0x07, 0x07, "reserved for additional original called number"},
  { 0x08, 0x08, "reserved for additional redirecting number"},
  { 0x09, 0x09, "reserved for additional redirection number"},
  { 0x0a, 0x0a, "reserved (used in 1992 version)"},
  { 0x0b, 0x7f, "spare"},
  { 0x80, 0xfe, "reserved for national use"},
  { 0xff, 0xff, "reserved for expansion"},
  { 0, 0, NULL}
};
void
dissect_isup_generic_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t     indicators1, indicators2;
  int         offset = 0;
  static int * const indicators1_fields[] = {
    &hf_isup_odd_even_indicator,
    &hf_isup_calling_party_nature_of_address_indicator,
    NULL
  };

  proto_tree_add_item(parameter_tree, hf_isup_number_qualifier_indicator, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb,1 , 1, indicators1_fields, ENC_NA);
  indicators1 = tvb_get_uint8(parameter_tvb, 1);
  indicators2 = tvb_get_uint8(parameter_tvb, 2);
  proto_tree_add_boolean(parameter_tree, hf_isup_ni_indicator, parameter_tvb, 2, 1, indicators2);
  proto_tree_add_uint(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, 2, 1, indicators2);
  if ((indicators2 & GFE_8BIT_MASK) == 0x50) {
    proto_tree_add_uint_format_value(parameter_tree, hf_isup_number_different_meaning, parameter_tvb, 2, 1, indicators2 & GFE_8BIT_MASK,
                                     "Numbering plan indicator = private numbering plan");
  }
  proto_tree_add_uint(parameter_tree, hf_isup_address_presentation_restricted_indicator, parameter_tvb, 2, 1, indicators2);
  proto_tree_add_uint(parameter_tree, hf_isup_screening_indicator_enhanced, parameter_tvb, 2, 1, indicators2);
  offset = 3;

  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
                             hf_isup_generic_number, hf_isup_calling_party_odd_address_signal_digit,
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
                             NONE, 0);

  /*
   * Indicators1 = Nature of address
   * Indicators2 = Number plan indicator
   */
  indicators1 = indicators1 & 0x7f;
  indicators2 = (indicators2 & 0x70)>>4;
  if ((indicators1 == ISUP_CALLED_PARTY_NATURE_INTERNATNL_NR) && (indicators2 == ISDN_NUMBERING_PLAN))
    dissect_e164_cc(parameter_tvb, parameter_tree, 3, E164_ENC_BCD);
}

/* ------------------------------------------------------------------
  Dissector Parameter  Jurisdiction parameter
 */
static void
dissect_isup_jurisdiction_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  int         offset = 0;

  offset = 0;

  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
                             hf_isup_jurisdiction, hf_isup_called_party_odd_address_signal_digit,
                             hf_isup_called_party_even_address_signal_digit, (tvb_reported_length(parameter_tvb) > 0),
                             NONE, 0);
}

/* ------------------------------------------------------------------
  Dissector Parameter Generic name
 */
static void
dissect_isup_generic_name_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  int     gen_name_length;
  char   *gen_name = NULL;
  static int * const indicators[] = {
    &hf_isup_generic_name_presentation,
    &hf_isup_generic_name_availability,
    &hf_isup_generic_name_type,
    NULL
  };

  gen_name = (char *)wmem_alloc(pinfo->pool, MAXGNAME + 1);
  gen_name[0] = '\0';
  gen_name_length = tvb_reported_length(parameter_tvb) - 1;

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators, ENC_NA);

  gen_name = tvb_get_string_enc(pinfo->pool, parameter_tvb, 1, gen_name_length, ENC_ASCII);
  gen_name[gen_name_length] = '\0';
  proto_tree_add_string(parameter_tree, hf_isup_generic_name_ia5, parameter_tvb, 1, gen_name_length, gen_name);
  proto_item_append_text(parameter_item, " : %s", gen_name);

  }

/* ------------------------------------------------------------------
 Dissector Parameter Generic digits
 */
void
dissect_isup_generic_digits_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{ unsigned length = tvb_reported_length(parameter_tvb);
  proto_tree_add_item(parameter_tree, hf_isup_generic_digits, parameter_tvb, 0, length, ENC_NA);
}

/* ------------------------------------------------------------------
  Dissector Parameter Charge number
 */
static void
dissect_isup_charge_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  uint8_t     indicators1;
  int         offset = 0;
  static int * const indicators1_fields[] = {
    &hf_isup_odd_even_indicator,
    &hf_isup_charge_number_nature_of_address_indicator,
    NULL
  };

  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, 1, 1, ENC_NA);
  offset = 2;

  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
                             hf_isup_charge_number, hf_isup_calling_party_odd_address_signal_digit,
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
                             NONE, 0);
}

/* ------------------------------------------------------------------ */
static void
dissect_isup_unknown_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  unsigned length = tvb_reported_length(parameter_tvb);
  proto_tree_add_item(parameter_tree, hf_isup_parameter_value, parameter_tvb, 0, length, ENC_NA);
}
/* ------------------------------------------------------------------ */

/* Japan ISUP */

/*
  8 7 6 5 4 3 2 1
  O/E Nature of address indicator 1
  INN NAPI Spare 2
  2nd address signal 1st address signal 3
  ... ... :
  Filler (if necessary) nth address signal 15
*/
static void
dissect_japan_isup_called_dir_num(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  int offset = 0;
  int parameter_length;

  parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);

  proto_tree_add_item(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
  proto_tree_add_item(parameter_tree, hf_isup_called_party_nature_of_address_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
  offset += 1;

  proto_tree_add_item(parameter_tree, hf_isup_inn_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
  proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
  offset += 1;

  proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, offset, parameter_length-offset, "Number not dissected yet");
}


/*
  8     7     6     5     4     3     2    1
  +-----+-----+-----+-----+-----+-----+-----+-----+
  -            Information Type Tag               -  1
  +-----------------------------------------------+
  -           Information Type Length             -  2
  +-----------------------------------------------+
  -           Information Type Value              -  3
  +-----------------------------------------------+
  .                                              .
  .                                              .
  .                                              .
  +-----------------------------------------------+
  -            Information Type Tag               -  n+1
  +-----------------------------------------------+
  -           Information Type Length             -  n+2
  +-----------------------------------------------+
  -           Information Type Value              -  n+3
  |-----------------------------------------------/

  Information Type Tag

  00000000  Reserved (Note)
  00000001  Reserved
  00000010  Reserved
  00000011  Performing redirect indicator
  00000100  Invoking redirect reason
  00000101
  to     Spare
  11111111

  Note: In standard this value is marked as -Not used-,
  here is treated as reserved.

  Performing redirect indicator

  8     7     6     5     4     3     2     1
  +-----+-----+-----+-----+-----+-----+-----+-----+
  - ext -      Performing redirect reason         -  1
  +-----+-----------------------------------------+
  -                             -Redirect possible-
  -          Spare              -  indicator at   -  2
  -                             -   performing    -
  -                             -    exchange     -
  +-----------------------------+-----------------+
  :                       :                       :  :
  :                       :                       :
  +-----------------------------------------------+
  - ext -      Performing redirect reason         -  2n|1
  +-----+-----------------------|-----------------+    Reason n
  -                             -Redirect possible-
  -          Spare              -  indicator at   -  2n
  -                             -   performing    -
  -                             -    exchange     -
  |-----------------------------+-----------------/


  Redirect possible indicator at performing exchange
  000      No indication
  001      Redirect possible before ACM
  010      Reserved
  011      Reserved
  100
  to       Spare
  111

  Invoking redirect reason

  8     7     6     5     4     3     2    1
  +-----+-----+-----+-----+-----+-----+-----+-----+
  - ext -        Invoking redirect reason         -  1
  +-----+-----------------------------------------+
  :     :                                         :
  :     :                                         :
  +-----------------------------------------------+
  - ext -        Invoking redirect reason         -  n
  |-----+-----------------------------------------/

  Extension indicator (ext)

  0        Information continues in next octet
  1        Last octet

  Invoking redirect reason

  0000000  Unknown / not available
  0000001  Service provider portability (national use)
  0000010  Reserved for location portability
  0000011  Reserved for service portability
  0000100
  to       Spare
  0111111
  1000000
  to       Reserved for national use
  1111101
  1111110  Local number portability / Mobile number
  portability
  1111111  Reserved for national use

*/

static const value_string isup_rfi_info_type_values[] = {
  { 0,   "Reserved" },
  { 1,   "Reserved" },
  { 2,   "Reserved" },
  { 3,   "Performing redirect indicator" },
  { 4,   "Invoking redirect reason" },
  { 0,   NULL}
};

/* Performing redirect reason */
static const value_string perf_redir_reason_vals[] = {
  { 0,   "Unknown/not available" },
  { 1,   "Service provider portability (national use)" },
  { 2,   "Reserved for location portability" },
  { 3,   "Reserved for service portability" },
/*
  0000100
  to       Spare
  0111111
  1000000
  to       Reserved for national use
  1111101
*/
  { 0x7e,   "Local number portability / Mobile number portability" },
  { 0x7f,   "Reserved for national use" },
  { 0,   NULL}
};


static const value_string redir_pos_ind_vals[] = {
  { 0,   "No indication" },
  { 1,   "Redirect possible before ACM" },
  { 2,   "Reserved" },
  { 3,   "Reserved" },
  { 4,   "Reserved" },
  { 5,   "Reserved" },
  { 6,   "Reserved" },
  { 7,   "Reserved" },
  { 0,   NULL}
};


static void
dissect_japan_isup_redirect_fwd_inf(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  int    offset = 0;
  uint8_t tag, tag_len, ext_ind;
  int    parameter_length;

  parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);

  while (offset < parameter_length) {
    /* Information Type Tag */
    tag = tvb_get_uint8(parameter_tvb, offset);
    proto_tree_add_item(parameter_tree, hf_japan_isup_rfi_info_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
    offset += 1;
    /* Information Type Length */
    tag_len = tvb_get_uint8(parameter_tvb, offset);
    proto_tree_add_item(parameter_tree, hf_japan_isup_rfi_info_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
    offset += 1;
    switch (tag) {
      case 3: /* Performing redirect indicator */
        /* Performing redirect reason oct 1 */
        ext_ind = 0;
        while (ext_ind == 0) {
          ext_ind = tvb_get_uint8(parameter_tvb, offset) >> 7;
          proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
          proto_tree_add_item(parameter_tree, hf_japan_isup_perf_redir_reason, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
          offset += 1;
          /* Redirect possible indicator at performing exchange */
          proto_tree_add_item(parameter_tree, hf_japan_isup_redir_pos_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
          offset += 1;
        }
        break;
      case 4:
        /* Invoking redirect reason */
        ext_ind = 0;
        while (ext_ind == 0) {
          ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
          proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
          proto_tree_add_item(parameter_tree, hf_japan_isup_inv_redir_reason, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
          offset += 1;
        }
        break;
      default:
        /* Information Type Value */
        proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, offset, tag_len, "Unknown(not dissected) tag");
        offset = offset + tag_len;
        break;
    }
  }
}


static const value_string japan_isup_bwd_info_type_vals[] = {
  { 0,   "Reserved" },
  { 1,   "Reserved" },
  { 2,   "Reserved" },
  { 3,   "invoking redirect reason" },
  { 0,   NULL}
};

static void
dissect_japan_isup_redirect_backw_inf(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  int    offset = 0;
  uint8_t tag, tag_len, ext_ind;
  int    parameter_length;

  parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);

  while (offset < parameter_length) {
    /* Information Type Tag */
    tag = tvb_get_uint8(parameter_tvb, offset);
    proto_tree_add_item(parameter_tree, hf_japan_isup_bwd_info_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
    offset += 1;
    /* Information Type Length */
    tag_len = tvb_get_uint8(parameter_tvb, offset);
    proto_tree_add_item(parameter_tree, hf_japan_isup_tag_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
    offset += 1;
    switch (tag) {
      case 3: /* invoking redirect reason */
        /* invoking redirect reason oct 1 */
        ext_ind = 0;
        while (ext_ind == 0) {
          ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
          proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
          proto_tree_add_item(parameter_tree, hf_japan_isup_inv_redir_reason, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
          offset += 1;
        }
        break;
      default:
        /* Information Type Value */
        proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, offset, tag_len, "Unknown(not dissected) tag");
        offset = offset + tag_len;
        break;
    }
  }
}


static const value_string japan_isup_emerg_call_type_vals[] = {
  { 0,   "No specific category" },
  { 1,   "Spare" },
  { 2,   "Spare" },
  { 3,   "Spare" },
  { 0,   NULL}
};
static void
dissect_japan_isup_emergency_call_ind(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  int offset = 0;

  proto_tree_add_item(parameter_tree, hf_japan_isup_emerg_call_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
}

static const value_string hold_at_emerg_call_disc_ind_vals[] = {
  { 0,   "No indication" },
  { 1,   "Emergency Call is holding" },
  { 2,   "Call Back from the Emergency Center" },
  { 3,   "Re-answer to an Emergency call" },
  { 0,   NULL}
};

static void
dissect_japan_isup_emergency_call_inf_ind(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  int offset = 0;


  proto_tree_add_item(parameter_tree, hf_japan_isup_hold_at_emerg_call_disc_ind, parameter_tvb, offset, 2, ENC_BIG_ENDIAN);
}

static void
dissect_japan_isup_network_poi_cad(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  proto_item    *digits_item;
  proto_tree    *digits_tree;
  int            offset = 0;
  uint8_t        octet;
  uint8_t        odd_even;
  uint8_t        carrier_info_length;
  int            num_octets_with_digits = 0;
  int            digit_index = 0;
  wmem_strbuf_t *ca_number = wmem_strbuf_new_sized(pinfo->pool, MAXDIGITS+1);

  /* POI Hierarchy information

     8     7     6     5     4     3     2    1
     +-----------------------|-----------------------+
     |  Entry POI Hierarchy  |  Exit POI Hierarchy   |  1
     |                       |                       |
     \-----------------------------------------------|

  */

  /* POI Hierarchy information */
  proto_tree_add_item(parameter_tree, hf_isup_carrier_info_poi_entry_HEI, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
  proto_tree_add_item(parameter_tree, hf_isup_carrier_info_poi_exit_HEI, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
  offset += 1;

  /* length of CA information (in octets) */
  carrier_info_length = tvb_get_uint8(parameter_tvb, offset);
  proto_tree_add_item(parameter_tree, hf_japan_isup_carrier_info_length, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
  offset += 1;

  /* POI|CA information (Charge Area)

     8     7     6     5     4     3     2     1
     +-----|-----------------------------------------+
     |Odd/ |                Spare                    |  1
     |even |                                         |
     +-----------------------------------------------+
     |   2nd CA code digit   |   1st CA code digit   |  2
     |                       |                       |
     +-----------------------+-----------------------+
     .                      .                       .
     .                      .                       .
     .                      .                       .
     +-----------------------+-----------------------+
     |         Filler        |   5|th CA code digit  |  m
     |                       |                       |
     \-----------------------------------------------|
  */

  digits_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1,
                                ett_isup_address_digits, &digits_item, "Charge Area Number");

  /* Odd.Even Indicator*/
  odd_even = tvb_get_uint8(parameter_tvb, offset);
  proto_tree_add_boolean(digits_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, odd_even);

  /* Number of Octets containing digits*/
  num_octets_with_digits = carrier_info_length - 1;

  /* Lets now load up the digits.*/
  /* If the odd indicator is set... drop the Filler from the last octet.*/
  /* This loop also loads up ca_number with the digits for display*/
  digit_index = 0;
  while (num_octets_with_digits > 0) {
    offset += 1;
    octet = tvb_get_uint8(parameter_tvb, offset);
    if (++digit_index > MAXDIGITS) {
      expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
      break;
    }
    proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_odd_no_digits, parameter_tvb, 0, 1, octet);
    wmem_strbuf_append_c(ca_number, number_to_char(octet & ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK));
    if (num_octets_with_digits == 1) {
      if (odd_even == 0) {
        if (++digit_index > MAXDIGITS) {
          expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
          break;
        }
        proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
        wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
      }
    }
    else {
      if (++digit_index > MAXDIGITS) {
        expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
        break;
      }
      proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
      wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
    }

    num_octets_with_digits--;
  }
  proto_item_append_text(digits_item, ": %s", wmem_strbuf_get_str(ca_number));
}

static const range_string jpn_isup_add_user_cat_type_vals[] = {
  {  0,    0,    "Spare" },
  {  1,    0x80, "Reserved for network specific use" },
  {  0x81, 0xfa, "Spare" },
  {  0xfb, 0xfb, "Type 3 of additional mobile service information" },
  {  0xfc, 0xfc, "Type 2 of additional mobile service information" },
  {  0xfd, 0xfd, "Type 1 of additional mobile service information" },
  {  0xfe, 0xfe, "Type 1 of additional fixed service information" },
  {  0xff, 0xff, "Spare" },
  {  0,    0,    NULL } };

static const value_string jpn_isup_type_1_add_fixed_serv_inf_vals[] = {
  { 0,   "Spare" },
  { 1,   "Train payphone" },
  { 2,   "Pink (non-NTT payphone)" },
  { 0,   NULL}
};

static const value_string jpn_isup_type_1_add_mobile_serv_inf_vals[] = {
  { 0,   "Spare" },
  { 1,   "Cellular telephone service" },
  { 2,   "Maritime telephone service" },
  { 3,   "Airplane telephone service" },
  { 4,   "Paging service" },
  { 5,   "PHS service" },
  { 6,   "Spare" },
  { 0,   NULL}
};
static const value_string jpn_isup_type_2_add_mobile_serv_inf_vals[] = {
  { 0,   "Spare" },
  { 1,   "HiCap method (analog)" },
  { 2,   "N/J-TACS" },
  { 3,   "PDC 800 MHz" },
  { 4,   "PDC 1500 MHz" },
  { 5,   "N-STAR satellite" },
  { 6,   "cdmaOne 800 MHz" },
  { 7,   "Iridium satellite" },
  { 8,   "IMT-2000" },
  { 9,   "PHS (fixed network dependent)" },
  { 10,   "Spare" },
  { 0,   NULL}
};
static value_string_ext jpn_isup_type_2_add_mobile_serv_inf_vals_ext = VALUE_STRING_EXT_INIT(jpn_isup_type_2_add_mobile_serv_inf_vals);


void
dissect_japan_isup_additonal_user_cat(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  int    offset = 0;
  uint8_t type;
  int    parameter_length;

  parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);

  while (offset < parameter_length) {
    /* Type of Additional User/Service Information */
    type = tvb_get_uint8(parameter_tvb, offset);
    proto_tree_add_item(parameter_tree, hf_japan_isup_add_user_cat_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
    offset += 1;
    /* Additional User/Service Information  */
    switch (type) {
      case 0xfe:
        /* Type 1 of additional fixed service information */
        proto_tree_add_item(parameter_tree, hf_japan_isup_type_1_add_fixed_serv_inf, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
        break;
      case 0xfd:
        /* Type 1 of additional mobile service information */
        proto_tree_add_item(parameter_tree, hf_japan_isup_type_1_add_mobile_serv_inf, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
        break;
      case 0xfc:
        /* Type 2 of additional mobile service information */
        proto_tree_add_item(parameter_tree, hf_japan_isup_type_2_add_mobile_serv_inf, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
        break;
      case 0xfb:
        /* Type 3 of additional mobile service information */
        proto_tree_add_item(parameter_tree, hf_japan_isup_type_3_add_mobile_serv_inf, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
        break;
      default:
        proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, offset, 1,
                "Unknown(not dissected) Additional User/Service Information");
        break;
    }
    offset += 1;
  }
}


static const value_string jpn_isup_reason_for_clip_fail_vals[] = {
  { 0,   "Spare" },
  { 1,   "User's request" },
  { 2,   "Interaction with other service" },
  { 3,   "Public telephone origination" },
  { 4,   "Spare" },
  { 0,   NULL}
};
static void
dissect_japan_isup_reason_for_clip_fail(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  int offset = 0;


  proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
  proto_tree_add_item(parameter_tree, hf_japan_isup_reason_for_clip_fail, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
}

static void
dissect_japan_isup_contractor_number(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  int         offset = 0;
  int         parameter_length;
  char        *digit_str;

  parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);

  proto_tree_add_item(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
  proto_tree_add_item(parameter_tree, hf_isup_called_party_nature_of_address_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
  offset += 1;

  proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
  offset += 1;

  proto_tree_add_item_ret_display_string(parameter_tree, hf_japan_isup_contractor_number,  parameter_tvb, offset, parameter_length-2, ENC_BCD_DIGITS_0_9|ENC_LITTLE_ENDIAN, pinfo->pool, &digit_str);

  proto_item_append_text(parameter_item, " %s", digit_str);

}
/* ------------------------------------------------------------------
  Dissector Parameter Optional .Carrier Information


   8     7     6     5     4     3     2    1
+-----------------------------------------------+
|                 spare             |    IEC    |  1
|                                   | indicator |
+-----------------------------------------------+
|         Category of carrier 1                 |  2
|                                               |
+-----------------------------------------------+
|         Length of carrier 1 information       |  3
|                                               |
+-----------------------------------------------+
|         Carrier 1 information / octet 1       |  4
|                                               |
+-----------------------------------------------+
 .                    .                         .
 .                    .                         .
 .                    .                         .
+-----------------------------------------------+
|         Carrier 1 information / octet n       |  3+n
|                                               |
+-----------------------------------------------+
 .                                              .
 */
static void
dissect_japan_isup_carrier_information(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
{
  proto_item *catagory_of_carrier;
  proto_tree *carrier_info_tree;

  proto_item *digits_item;
  proto_tree *digits_tree;

  proto_item *type_of_carrier;
  proto_tree *type_of_carrier_tree;

  uint8_t octet;
  uint8_t odd_even;
  uint8_t type_of_carrier_info;
  uint8_t carrier_info_length;
  uint8_t carrierX_end_index;

  int offset = 0;
  int length = 0;

  int num_octets_with_digits = 0;

  int digit_index;
  wmem_strbuf_t *cid_number;
  wmem_strbuf_t *ca_number;

  /*Octet 1 : IEC Indicator*/
  octet = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_uint(parameter_tree, hf_isup_carrier_info_iec, parameter_tvb, 0, 1, octet);


  length = tvb_reported_length_remaining(parameter_tvb, 2);
  if (length == 0) {
    expert_add_info(pinfo, parameter_item, &ei_isup_empty_number);
    proto_item_append_text(parameter_item, ": (empty)");
    return;
  }

  offset = 1;

  /* Lets loop through the Carrier Information*/

  while (length > 0) {

    carrier_info_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1,
                        ett_isup_carrier_info, &catagory_of_carrier, "Category of Carrier:");

    /*Octet 2 : Category of Carrier*/
    octet = tvb_get_uint8(parameter_tvb, offset);
    /*proto_tree_add_uint(carrier_info_tree, hf_isup_carrier_info_cat_of_carrier, parameter_tvb, 0, 1, octet);*/
    proto_item_append_text(catagory_of_carrier, ": %s (%u)", val_to_str_ext_const(octet, &isup_carrier_info_category_vals_ext, "spare"), octet );


    /*Octet 3 : Length of Category Information No.x*/
    offset += 1;
    carrierX_end_index = tvb_get_uint8(parameter_tvb, offset)+offset;

    while (offset < carrierX_end_index) {

      type_of_carrier_tree = proto_tree_add_subtree(carrier_info_tree, parameter_tvb, offset, -1,
                                    ett_isup_carrier_info, &type_of_carrier, "Type of Carrier:");

      /* Type of Carrier Information*/
      offset += 1;
      type_of_carrier_info = tvb_get_uint8(parameter_tvb, offset);
      /*proto_tree_add_uint(type_of_carrier_tree, hf_isup_carrier_info_type_of_carrier_info, parameter_tvb, 0, 1, type_of_carrier_info);*/
      proto_item_append_text(type_of_carrier, ": %s (%u)", val_to_str_ext_const(type_of_carrier_info, &isup_carrier_info_type_of_carrier_vals_ext, "spare"), type_of_carrier_info );


      /* Carrier Information Length */
      offset += 1;
      carrier_info_length = tvb_get_uint8(parameter_tvb, offset);

      /* POI Hierarchy information

         8     7     6     5     4     3     2    1
         +-----------------------|-----------------------+
         |  Entry POI Hierarchy  |  Exit POI Hierarchy   |  1
         |                       |                       |
         \-----------------------------------------------|

      */

      if (type_of_carrier_info == CARRIER_INFO_TYPE_OF_CARRIER_POIHIE) {
        /* POI Hierarchy information */
        offset += 1;
        octet = tvb_get_uint8(parameter_tvb, offset);
        proto_tree_add_uint(type_of_carrier_tree, hf_isup_carrier_info_poi_entry_HEI, parameter_tvb, 0, 1, octet);
        proto_tree_add_uint(type_of_carrier_tree, hf_isup_carrier_info_poi_exit_HEI, parameter_tvb, 0, 1, octet);
      }

      /* POI|CA information (Charge Area)

         8     7     6     5     4     3     2     1
         +-----|-----------------------------------------+
         |Odd/ |                Spare                    |  1
         |even |                                         |
         +-----------------------------------------------+
         |   2nd CA code digit   |   1st CA code digit   |  2
         |                       |                       |
         +-----------------------+-----------------------+
         .                      .                       .
         .                      .                       .
         .                      .                       .
         +-----------------------+-----------------------+
         |         Filler        |   5|th CA code digit  |  m
         |                       |                       |
         \-----------------------------------------------|
      */
      if (type_of_carrier_info == CARRIER_INFO_TYPE_OF_CARRIER_POICA) {

        digits_tree = proto_tree_add_subtree(type_of_carrier_tree, parameter_tvb, offset, -1,
                                        ett_isup_address_digits, &digits_item, "Charge Area");

        /* Odd.Even Indicator*/
        offset += 1;
        odd_even = tvb_get_uint8(parameter_tvb, offset);
        proto_tree_add_boolean(digits_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, odd_even);

        /* Number of Octets containing digits*/
        num_octets_with_digits = carrier_info_length - 1;

        /* Lets now load up the digits.*/
        /* If the odd indicator is set... drop the Filler from the last octet.*/
        /* This loop also loads up ca_number with the digits for display*/
        ca_number = wmem_strbuf_new_sized(pinfo->pool, MAXDIGITS+1);
        digit_index = 0;
        while (num_octets_with_digits > 0) {
          offset += 1;
          if (++digit_index > MAXDIGITS) {
            expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
            break;
          }
          octet = tvb_get_uint8(parameter_tvb, offset);
          proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_odd_no_digits, parameter_tvb, 0, 1, octet);
          wmem_strbuf_append_c(ca_number, number_to_char(octet & ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK));
          if (num_octets_with_digits == 1) {
            if (odd_even == 0) {
              if (++digit_index > MAXDIGITS) {
                expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
                break;
              }
              proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
              wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
            }
          }
          else {
            if (++digit_index > MAXDIGITS) {
              expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
              break;
            }
            proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
            wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
          }

          num_octets_with_digits--;
        }

        proto_item_append_text(digits_item, ": %s", wmem_strbuf_get_str(ca_number));

      }

      /* Carrier Identification Code
         8     7     6     5     4     3     2     1
         +-----|-----------------------------------------+
         |Odd/ |                Spare                    |  1
         |even |                                         |
         +-----------------------------------------------+
         |   2nd ID code digit   |   1st ID code digit   |  2
         |                       |                       |
         +-----------------------+-----------------------+
         .                      .                       .
         .                      .                       .
         .                      .                       .
         +-----------------------+-----------------------+
         | Filler (if necessary) |   n|th ID code digit  |  m
         |                       |                       |
         \-----------------------------------------------|
      */

      if (type_of_carrier_info == CARRIER_INFO_TYPE_OF_CARRIER_CARID) {
        digits_tree = proto_tree_add_subtree(type_of_carrier_tree, parameter_tvb, offset, -1,
                                        ett_isup_address_digits, &digits_item, "Carrier ID Code");

        offset += 1;
        /* Odd.Even Indicator*/
        odd_even = tvb_get_uint8(parameter_tvb, offset);
        proto_tree_add_boolean(digits_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, odd_even);

        /* Number of Octets containing digits*/
        num_octets_with_digits = carrier_info_length - 1;

        /* Lets now load up the digits.*/
        /* If the odd indicator is set... drop the Filler from the last octet.*/
        /* This loop also loads up cid_number with the digits for display*/
        cid_number = wmem_strbuf_new_sized(pinfo->pool, MAXDIGITS+1);
        digit_index = 0;
        while (num_octets_with_digits > 0) {
          offset += 1;
          if (++digit_index > MAXDIGITS) {
            expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
            break;
          }
          octet = tvb_get_uint8(parameter_tvb, offset);
          proto_tree_add_uint(digits_tree, hf_isup_carrier_info_odd_no_digits, parameter_tvb, 0, 1, octet);
          wmem_strbuf_append_c(cid_number, number_to_char(octet & ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK));
          if (num_octets_with_digits == 1) {
            if (odd_even == 0) {
              if (++digit_index > MAXDIGITS) {
                expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
                break;
              }
              proto_tree_add_uint(digits_tree, hf_isup_carrier_info_even_no_digits, parameter_tvb, 0, 1, octet);
              wmem_strbuf_append_c(cid_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
            }
          }
          else {
            if (++digit_index > MAXDIGITS) {
              expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
              break;
            }
            proto_tree_add_uint(digits_tree, hf_isup_carrier_info_even_no_digits, parameter_tvb, 0, 1, octet);
            wmem_strbuf_append_c(cid_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
          }
          num_octets_with_digits--;
        }
        proto_item_append_text(digits_item, ": %s", wmem_strbuf_get_str(cid_number));
      }
    }

    offset += 1;
    length = tvb_reported_length_remaining(parameter_tvb, offset);
  }
}


static const range_string japan_isup_charge_delay_type_value[] = {
  {  0,    0,    "Spare" },
  {  1,    0x80, "Reserved for network specific use" },
  {  0x81, 0xfa, "Spare" },
  {  0xfb, 0xfc, "Reserved" },
  {  0xfd, 0xfd, "Charge rate transfer" },
  {  0xfe, 0xfe, "Terminating charge area information" },
  {  0xff, 0xff, "Spare" },
  {  0,    0,    NULL } };

static void
dissect_japan_isup_charge_inf_delay(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{

  int offset = 0;
  int parameter_length;

  parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);

  while (offset < parameter_length) {
    proto_tree_add_item(parameter_tree, hf_japan_isup_charge_delay_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
    offset += 1;
  }
}

/* ----------------------------------------------------
  Dissector Parameter Optional .Additional User Information

   8     7     6     5     4     3     2    1
+-----------------------------------------------+
|     Type of additional user/service           |  1
|     information (1)                           |
+-----------------------------------------------+
|     Additional user/service information (1)   |  2
|                                               |
+-----------------------------------------------+
 .                                              .
 .                                              .
 .                                              .
+-----------------------------------------------+
|      Type of additional user/service          |  2n|1
|      information (n)                          |
+-----------------------------------------------+
|      Additional user/service information (n)  |  2n
|                                               |
\------------------------------------------------
*/



/* ----------------------------------------------------
  Dissector Parameter Optional .Charge Area Information

  8     7     6     5     4     3     2     1
+-----+-----------------------------------------+
|Odd/ |     Nature of information indicator     |  1
|even |                                         |
+-----------------------------------------------+
| 2nd NC digit          | 1st NC digit          |  2 ||
|                       |                       |     | see
+-----------------------+-----------------------+     | Note
|  4th NC digit         | 3rd NC digit          |  3 ||
|                       |                       |
+-----------------------+-----------------------+
| 2nd MA/CA code digit  | 1st MA/CA code digit  |  4
|                       |                       |
+-----------------------+-----------------------+
 .                      .                       .
 .                      .                       .
 .                      .                       .
+-----------------------+-----------------------+
| Filler (if necessary) | nth MA/CA code digit  |  m
|                       |                       |
\-----------------------------------------------|
*/
static void
dissect_japan_isup_charge_area_info(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  proto_item *digits_item;
  proto_tree *digits_tree;

  uint8_t octet;

  int nat_of_info_indic;
  int length;
  int offset;
  int odd_even;
  int digit_index = 0;

  wmem_strbuf_t *ca_number = wmem_strbuf_new_sized(pinfo->pool, MAXDIGITS+1);

  /*Octet 1 : Indicator*/
  octet = tvb_get_uint8(parameter_tvb, 0);
  nat_of_info_indic = octet & 0x7F;
  odd_even = octet & 0x80;
  proto_tree_add_boolean(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, octet);
  proto_tree_add_uint(parameter_tree, hf_japan_isup_charge_area_nat_of_info_value, parameter_tvb, 0, 1, octet);

  offset = 1;
  length = tvb_reported_length_remaining(parameter_tvb, offset);

  /*Only CA code digits.*/
  if (nat_of_info_indic == CHARGE_AREA_NAT_INFO_CA) {
    digits_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1,
                                ett_isup_address_digits, &digits_item, "Charge Area");

    while (length > 0) {
      if (++digit_index > MAXDIGITS) {
        expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
        break;
      }
      octet = tvb_get_uint8(parameter_tvb, offset);
      proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_odd_no_digits, parameter_tvb, 0, 1, octet);
      wmem_strbuf_append_c(ca_number, number_to_char(octet & ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK));
      if (length == 1) {
        if (odd_even == 0) {
          if (++digit_index > MAXDIGITS) {
            expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
            break;
          }
          proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
          wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
        }
      }
      else {
        if (++digit_index > MAXDIGITS) {
          expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
          break;
        }
        proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
        wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
      }
      offset += 1;
      length -= 1;
    }
    proto_item_append_text(digits_item, ": %s", wmem_strbuf_get_str(ca_number));
  }
  /*Only MA code digits.*/
  if (nat_of_info_indic == CHARGE_AREA_NAT_INFO_MA) {
    digits_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1,
                                ett_isup_address_digits, &digits_item, "Message Area:");

    /* First two octets contains*/
    /* four NC digits*/
    octet = tvb_get_uint8(parameter_tvb, offset);
    proto_tree_add_uint(digits_tree, hf_japan_isup_charging_info_nc_odd_digits, parameter_tvb, 0, 1, octet);
    proto_tree_add_uint(digits_tree, hf_japan_isup_charging_info_nc_even_digits, parameter_tvb, 0, 1, octet);
    offset++;
    octet = tvb_get_uint8(parameter_tvb, offset);
    proto_tree_add_uint(digits_tree, hf_japan_isup_charging_info_nc_odd_digits, parameter_tvb, 0, 1, octet);
    proto_tree_add_uint(digits_tree, hf_japan_isup_charging_info_nc_even_digits, parameter_tvb, 0, 1, octet);
    offset++;

    /* Now loop through MA/CA digits.*/
    length = tvb_reported_length_remaining(parameter_tvb, offset);

    while (length > 0) {
      octet = tvb_get_uint8(parameter_tvb, offset);
      proto_tree_add_uint(digits_tree, hf_isup_charging_info_maca_odd_digits, parameter_tvb, 0, 1, octet);
      if (length == 1) {
        if (odd_even == 0) {
          proto_tree_add_uint(digits_tree, hf_isup_charging_info_maca_even_digits, parameter_tvb, 0, 1, octet);
        }
      }
      else {
        proto_tree_add_uint(digits_tree, hf_isup_charging_info_maca_even_digits, parameter_tvb, 0, 1, octet);
      }
      offset += 1;
      length -= 1;
    }

  }
}

static const value_string japan_isup_chg_info_type_value[] = {
  { 0,      "Spare" },
  { 1,      "Reserved" },
  { 2,      "Reserved" },
  { 3,      "Advanced Charge Rate Transfer(TDS Service)" },
  { 0xfe,   "Charge rate transfer (flexible charging)" },
  { 0xff,   "Spare" },
  { 0,   NULL}
};

static uint16_t
dissect_japan_chg_inf_type(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  uint16_t chg_inf_type;

  chg_inf_type = tvb_get_uint8(parameter_tvb, 0);
  proto_tree_add_item(parameter_tree, hf_japan_isup_charge_info_type, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);

  return chg_inf_type;
}

static const value_string japan_isup_sig_elem_type_values[] = {
  { 2,   "Activate" },
  { 0,   NULL}
};

static const value_string japan_isup_op_cls_values[] = {
  { 0,   "Class 1" },
  { 1,   "Class 2" },
  { 2,   "Class 3" },
  { 3,   "Class 4" },
  { 0,   NULL}
};

static const value_string japan_isup_op_type_values[] = {
  { 6,   "Immediate charging" },
  { 0,   NULL}
};

static const value_string japan_isup_charging_party_type_values[] = {
  { 0,   "Originator charge" },
  { 0,   NULL}
};

static const value_string japan_isup_collecting_method_values[] = {
  { 0,   "Subscriber will be claimed" },
  { 0,   NULL}
};

static const value_string japan_isup_tariff_rate_pres_values[] = {
  { 2,   "No charge rate information" },
  { 0,   NULL}
};

static void
dissect_japan_chg_inf_type_acr(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  int    offset = 0;
  uint8_t ext_ind;

  /* length : 2-5 octets */
  ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
  proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
  proto_tree_add_item(parameter_tree, hf_japan_isup_sig_elem_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
  offset += 1;
  if (!ext_ind) {
    /* Activation ID */
    ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
    proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
    proto_tree_add_item(parameter_tree, hf_japan_isup_activation_id, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
    offset += 1;
    if (!ext_ind) {
      /* Operation type and class */
      ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
      proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      proto_tree_add_item(parameter_tree, hf_japan_isup_op_cls, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      proto_tree_add_item(parameter_tree, hf_japan_isup_op_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      offset += 1;
      if (!ext_ind) {
        /* Tariff collecting method and charging party type */
        proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
        proto_tree_add_item(parameter_tree, hf_japan_isup_charging_party_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
        proto_tree_add_item(parameter_tree, hf_japan_isup_collecting_method, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
        offset += 1;
      }
    }
  }
  /* Tariff rate presentation */
  proto_tree_add_item(parameter_tree, hf_japan_isup_tariff_rate_pres, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);

}


static const value_string japan_isup_utp_values[] = {
  { 0,   "Spare" },
  { 0xfc,   "100 yen" },
  { 0xfd,   "10 yen" },
  { 0xfe,   "No indication" },
  { 0xff,   "Spare" },
  { 0,   NULL}
};

static const value_string japan_isup_crci1_values[] = {
  { 0,   "Spare" },
  { 0x7c,   "Public (Payphone)" },
  { 0x7d,   "Ordinary" },
  { 0x7e,   "No flexible charge rate information" },
  { 0x7f,   "Spare" },
  { 0,   NULL}
};

static void
dissect_japan_chg_inf_type_crt(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
{
  int    offset = 0;
  uint8_t ext_ind;
  uint8_t len;
  int    parameter_length;

  parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);


  /* Unit per Time Period (UTP) */
  proto_tree_add_item(parameter_tree, hf_japan_isup_utp, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
  offset += 1;

  /* Charge rate information category 1 (CRIC 1) */
  ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
  proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
  proto_tree_add_item(parameter_tree, hf_japan_isup_crci1, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
  offset += 1;
  if (!ext_ind) {
    len = tvb_get_uint8(parameter_tvb, offset);
    proto_tree_add_item(parameter_tree, hf_japan_isup_crci1_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
    offset += 1;
    /* Initial units (IU) IA5 coded in two octets */
    proto_tree_add_item(parameter_tree, hf_japan_isup_iu, parameter_tvb, offset, 2, ENC_NA|ENC_ASCII);
    offset += 2;
    /* Daytime Charge rate (DCR) (Octets A, B, C) IA5 coded in three octets */
    proto_tree_add_item(parameter_tree, hf_japan_isup_dcr, parameter_tvb, offset, 3, ENC_NA|ENC_ASCII);
    offset+=3;
    if (len > 5) {
      /* Evening Charge rate (ECR) (Octets B, E, F) IA5 coded in three octets */
      proto_tree_add_item(parameter_tree, hf_japan_isup_ecr, parameter_tvb, offset, 3, ENC_NA|ENC_ASCII);
      offset += 3;
    }
    if (len > 8) {
      /* Nighttime Charge rate (NCR) (Octet G,H,I) IA5 coded in three octets */
      proto_tree_add_item(parameter_tree, hf_japan_isup_ncr, parameter_tvb, offset, 3, ENC_NA|ENC_ASCII);
      offset += 3;
    }
    if (len > 11) {
      /* Spare charge rate (SCR) (Octets J,K,L) IA5 coded in three octets */
      proto_tree_add_item(parameter_tree, hf_japan_isup_scr, parameter_tvb, offset, 3, ENC_NA|ENC_ASCII);
      offset += 3;
    }
  }
  if (parameter_length > offset) {
    /* Charge rate information category 2 (CRIC 2) */
    ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
    proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
    proto_tree_add_item(parameter_tree, hf_japan_isup_crci2, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
    offset += 1;
    if (!ext_ind) {
      len = tvb_get_uint8(parameter_tvb, offset);
      proto_tree_add_item(parameter_tree, hf_japan_isup_crci1_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
      offset += 1;
      /* Initial units (IU) IA5 coded in two octets */
      proto_tree_add_item(parameter_tree, hf_japan_isup_iu, parameter_tvb, offset, 2, ENC_NA|ENC_ASCII);
      offset += 2;
      /* Daytime Charge rate (DCR) (Octets A, B, C) IA5 coded in three octets */
      proto_tree_add_item(parameter_tree, hf_japan_isup_dcr, parameter_tvb, offset, 3, ENC_NA|ENC_ASCII);
      offset += 3;
      if (len > 5) {
        /* Evening Charge rate (ECR) (Octets B, E, F) IA5 coded in three octets */
        proto_tree_add_item(parameter_tree, hf_japan_isup_ecr, parameter_tvb, offset, 3, ENC_NA|ENC_ASCII);
        offset += 3;
      }
      if (len > 8) {
        /* Nighttime Charge rate (NCR) (Octet G,H,I) IA5 coded in three octets */
        proto_tree_add_item(parameter_tree, hf_japan_isup_ncr, parameter_tvb, offset, 3, ENC_NA|ENC_ASCII);
        offset += 3;
      }
      if (len > 11) {
        /* Spare charge rate (SCR) (Octets J,K,L) IA5 coded in three octets */
        proto_tree_add_item(parameter_tree, hf_japan_isup_scr, parameter_tvb, offset, 3, ENC_NA|ENC_ASCII);
        /*offset += 3;*/
      }
    }
  }
}


static void
dissect_japan_chg_inf_param(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item, uint16_t chg_inf_type)
{

  switch (chg_inf_type) {
    case 3:
      /* Advanced Charge Rate Transfer (TDS service) */
      dissect_japan_chg_inf_type_acr(parameter_tvb, parameter_tree, parameter_item);
      break;
    case 254:
      /* Charge rate transfer (flexible charging) */
      dissect_japan_chg_inf_type_crt(parameter_tvb, parameter_tree, parameter_item);
      break;
    default:
      proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, 0, -1, "Charge information data, not dissected yet");
      break;
  }
}

/* END Japan ISUP */

/* ------------------------------------------------------------------
  Dissector all optional parameters
*/
static void
dissect_isup_optional_parameter(tvbuff_t *optional_parameters_tvb, packet_info *pinfo, proto_tree *isup_tree, uint8_t itu_isup_variant)
{
  proto_item *parameter_item;
  proto_tree *parameter_tree;
  int         offset = 0;
  unsigned    parameter_type, parameter_length, actual_length;
  tvbuff_t   *parameter_tvb;
  uint8_t     octet;
  uint16_t    chg_inf_type = 0xffff;

  /* Dissect all optional parameters while end of message isn't reached */
  parameter_type = 0xFF; /* Start-initialization since parameter_type is used for while-condition */

  while ((tvb_reported_length_remaining(optional_parameters_tvb, offset)  >= 1) && (parameter_type != PARAM_TYPE_END_OF_OPT_PARAMS)) {
    parameter_type = tvb_get_uint8(optional_parameters_tvb, offset);

    if (parameter_type != PARAM_TYPE_END_OF_OPT_PARAMS) {
      parameter_length = tvb_get_uint8(optional_parameters_tvb, offset + PARAMETER_TYPE_LENGTH);
      if (parameter_length + PARAMETER_TYPE_LENGTH + PARAMETER_LENGTH_IND_LENGTH > (unsigned)(tvb_reported_length_remaining(optional_parameters_tvb, offset))) {
        proto_tree_add_expert_format(isup_tree, pinfo, &ei_isup_opt_par_length_err, optional_parameters_tvb, offset, -1,
          "Wrong parameter length %u, should be %u",
          parameter_length,
          tvb_reported_length_remaining(optional_parameters_tvb, offset)- (PARAMETER_TYPE_LENGTH + PARAMETER_LENGTH_IND_LENGTH));
        return;
      }

      parameter_tree = proto_tree_add_subtree_format(isup_tree, optional_parameters_tvb,
                                           offset,
                                           parameter_length  + PARAMETER_TYPE_LENGTH + PARAMETER_LENGTH_IND_LENGTH,
                                           ett_isup_parameter, &parameter_item,
                                           "Parameter: (t=%u, l=%u)",
                                           parameter_type, parameter_length);
      /* Handle national extensions here */
      switch (itu_isup_variant) {
        case ISUP_JAPAN_VARIANT:
        /* Fall through */
        case ISUP_JAPAN_TTC_VARIANT:
          proto_tree_add_uint_format_value(parameter_tree, hf_isup_opt_parameter_type, optional_parameters_tvb, offset, PARAMETER_TYPE_LENGTH,
                                     parameter_type,
                                     "%u (%s)",
                                     parameter_type,
                                     val_to_str_ext_const(parameter_type, &japan_isup_parameter_type_value_ext, "unknown"));
          proto_item_append_text(parameter_tree, ": %s", val_to_str_ext_const(parameter_type, &japan_isup_parameter_type_value_ext, "Unknown"));
          break;
        default:
          proto_tree_add_uint(parameter_tree, hf_isup_opt_parameter_type, optional_parameters_tvb, offset, PARAMETER_TYPE_LENGTH, parameter_type);
          proto_item_append_text(parameter_tree, ": %s", val_to_str_ext_const(parameter_type, &ansi_isup_parameter_type_value_ext, "Unknown"));
          break;

      }
      offset += PARAMETER_TYPE_LENGTH;

      octet = tvb_get_uint8(optional_parameters_tvb, offset);

      proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, optional_parameters_tvb, offset,
                                 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
      offset += PARAMETER_LENGTH_IND_LENGTH;
      if (octet == 0)
        continue;

      actual_length = tvb_reported_length_remaining(optional_parameters_tvb, offset);
      if (actual_length > 0) {
        parameter_tvb = tvb_new_subset_length_caplen(optional_parameters_tvb, offset, MIN(parameter_length, actual_length), parameter_length);
        switch (parameter_type) {
          case PARAM_TYPE_CALL_REF:
            dissect_isup_call_reference_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_TRANSM_MEDIUM_REQU:
            dissect_isup_transmission_medium_requirement_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_ACC_TRANSP:
            dissect_isup_access_transport_parameter(parameter_tvb, parameter_tree, parameter_item, pinfo);
            break;
          case PARAM_TYPE_CALLED_PARTY_NR:
            dissect_isup_called_party_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_SUBSQT_NR:
            dissect_isup_subsequent_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_NATURE_OF_CONN_IND:
            dissect_isup_nature_of_connection_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_FORW_CALL_IND:
            dissect_isup_forward_call_indicators_parameter(parameter_tvb, pinfo, parameter_item, parameter_tree);
            break;
          case PARAM_TYPE_OPT_FORW_CALL_IND:
            dissect_isup_optional_forward_call_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALLING_PRTY_CATEG:
            dissect_isup_calling_partys_category_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
            break;
          case PARAM_TYPE_CALLING_PARTY_NR:
            dissect_isup_calling_party_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_REDIRECTING_NR:
            dissect_isup_redirecting_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_REDIRECTION_NR:
            dissect_isup_redirection_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CONNECTION_REQ:
            dissect_isup_connection_request_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_INFO_REQ_IND:
            dissect_isup_information_request_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_INFO_IND:
            dissect_isup_information_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CONTINUITY_IND:
            dissect_isup_continuity_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_BACKW_CALL_IND:
            dissect_isup_backward_call_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CAUSE_INDICATORS:
            dissect_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_REDIRECTION_INFO:
            dissect_isup_redirection_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CIRC_GRP_SV_MSG_TYPE:
            dissect_isup_circuit_group_supervision_message_type_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_RANGE_AND_STATUS:
            dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_FACILITY_IND:
            dissect_isup_facility_ind_parameter(parameter_tvb, parameter_item);
            break;
          case PARAM_TYPE_CLSD_USR_GRP_ILOCK_CD:
            dissect_isup_closed_user_group_interlock_code_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_USER_SERVICE_INFO:
            dissect_isup_user_service_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_SIGNALLING_POINT_CODE:
            dissect_isup_signalling_point_code_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_USER_TO_USER_INFO:
            dissect_isup_user_to_user_information_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CONNECTED_NR:
            dissect_isup_connected_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_SUSP_RESUME_IND:
            dissect_isup_suspend_resume_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_TRANSIT_NETW_SELECT:
            dissect_isup_transit_network_selection_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_EVENT_INFO:
            dissect_isup_event_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CIRC_ASSIGN_MAP:
            dissect_isup_circuit_assignment_map_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CIRC_STATE_IND:
            dissect_isup_circuit_state_ind_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_AUTO_CONG_LEVEL:
            dissect_isup_automatic_congestion_level_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_ORIG_CALLED_NR:
            dissect_isup_original_called_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_OPT_BACKW_CALL_IND:
            dissect_isup_optional_backward_call_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_USER_TO_USER_IND:
            dissect_isup_user_to_user_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_ORIG_ISC_POINT_CODE:
            dissect_isup_original_isc_point_code_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_GENERIC_NOTIF_IND:
            dissect_isup_generic_notification_indicator_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALL_HIST_INFO :
            dissect_isup_call_history_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_ACC_DELIV_INFO:
            dissect_isup_access_delivery_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_NETW_SPECIFIC_FACLTY:
            dissect_isup_network_specific_facility_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_USER_SERVICE_INFO_PR:
            dissect_isup_user_service_information_prime_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_PROPAG_DELAY_COUNTER:
            dissect_isup_propagation_delay_counter_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_REMOTE_OPERATIONS:
            dissect_isup_remote_operations_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_SERVICE_ACTIVATION:
            dissect_isup_service_activation_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_USER_TELESERV_INFO:
            dissect_isup_user_teleservice_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_TRANSM_MEDIUM_USED:
            dissect_isup_transmission_medium_used_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALL_DIV_INFO:
            dissect_isup_call_diversion_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_ECHO_CTRL_INFO:
            dissect_isup_echo_control_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_MSG_COMPAT_INFO:
            dissect_isup_message_compatibility_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_PARAM_COMPAT_INFO:
            dissect_isup_parameter_compatibility_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_MLPP_PRECEDENCE:
            dissect_isup_mlpp_precedence_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_MCID_REQ_IND:
            dissect_isup_mcid_request_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_MCID_RSP_IND:
            dissect_isup_mcid_response_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_HOP_COUNTER:
            dissect_isup_hop_counter_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_TRANSM_MEDIUM_RQUR_PR:
            dissect_isup_transmission_medium_requirement_prime_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_LOCATION_NR:
            dissect_isup_location_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_REDIR_NR_RSTRCT:
            dissect_isup_redirection_number_restriction_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALL_TRANS_REF:
            dissect_isup_call_transfer_reference_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_LOOP_PREV_IND:
            dissect_isup_loop_prevention_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALL_TRANS_NR:
            dissect_isup_call_transfer_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CCSS:
            dissect_isup_ccss_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_FORW_GVNS:
            dissect_isup_forward_gvns_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_BACKW_GVNS:
            dissect_isup_backward_gvns_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_REDIRECT_CAPAB:
            dissect_isup_redirect_capability_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
            break;
          case PARAM_TYPE_NETW_MGMT_CTRL:
            dissect_isup_network_management_controls_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CORRELATION_ID:
            dissect_isup_correlation_id_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_SCF_ID:
            dissect_isup_scf_id_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALL_DIV_TREAT_IND:
            dissect_isup_call_diversion_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALLED_IN_NR:
            dissect_isup_called_in_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALL_OFF_TREAT_IND:
            dissect_isup_call_offering_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CHARGED_PARTY_IDENT:
            dissect_isup_charged_party_identification_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CONF_TREAT_IND:
            dissect_isup_conference_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_DISPLAY_INFO:
            dissect_isup_display_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_UID_ACTION_IND:
            dissect_isup_uid_action_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_UID_CAPAB_IND:
            dissect_isup_uid_capability_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_REDIRECT_COUNTER:
            dissect_isup_redirect_counter_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
            break;
          case PARAM_TYPE_COLLECT_CALL_REQ:
            dissect_isup_collect_call_request_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_GENERIC_NR:
            dissect_isup_generic_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_GENERIC_DIGITS:
            dissect_isup_generic_digits_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_APPLICATON_TRANS:
            dissect_isup_application_transport_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;

          default:
            switch (itu_isup_variant) {
              case ISUP_JAPAN_VARIANT:
              /* Fall through */
              case ISUP_JAPAN_TTC_VARIANT:
                switch (parameter_type) {
                  case JAPAN_ISUP_PARAM_CALLED_DIRECTORY_NUMBER:
                    dissect_japan_isup_called_dir_num(parameter_tvb, pinfo, parameter_tree, parameter_item);
                    break;
                  case JAPAN_ISUP_PARAM_REDIRECT_FORWARD_INF: /* 0x8B */
                    dissect_japan_isup_redirect_fwd_inf(parameter_tvb, pinfo, parameter_tree, parameter_item);
                    break;
                  case JAPAN_ISUP_PARAM_REDIRECT_BACKWARD_INF:  /* 0x8C */
                    dissect_japan_isup_redirect_backw_inf(parameter_tvb, pinfo, parameter_tree, parameter_item);
                    break;
                  case JAPAN_ISUP_PARAM_EMERGENCY_CALL_IND: /* D7 */
                    dissect_japan_isup_emergency_call_ind(parameter_tvb, parameter_tree, parameter_item);
                    break;
                  case JAPAN_ISUP_PARAM_EMERGENCY_CALL_INF_IND: /* EC */
                    dissect_japan_isup_emergency_call_inf_ind(parameter_tvb, parameter_tree, parameter_item);
                    break;
                  case JAPAN_ISUP_PARAM_NETWORK_POI_CA: /* EE */
                    dissect_japan_isup_network_poi_cad(parameter_tvb, pinfo, parameter_tree, parameter_item);
                    break;
                  case JAPAN_ISUP_PARAM_TYPE_CARRIER_INFO: /* 241 F1 */
                    dissect_japan_isup_carrier_information(parameter_tvb, pinfo, parameter_tree, parameter_item);
                    break;
                  case JAPAN_ISUP_PARAM_CHARGE_INF_DELAY:  /* 242 F2 */
                    dissect_japan_isup_charge_inf_delay(parameter_tvb, parameter_tree, parameter_item);
                    break;
                  case JAPAN_ISUP_PARAM_TYPE_ADDITONAL_USER_CAT: /* F3 */
                    dissect_japan_isup_additonal_user_cat(parameter_tvb, pinfo, parameter_tree, parameter_item);
                    break;
                  case JAPAN_ISUP_PARAM_REASON_FOR_CLIP_FAIL: /* F5 */
                    dissect_japan_isup_reason_for_clip_fail(parameter_tvb, parameter_tree, parameter_item);
                    break;
                  case JAPAN_ISUP_PARAM_TYPE_CONTRACTOR_NUMBER: /* F9 */
                    dissect_japan_isup_contractor_number(parameter_tvb, pinfo, parameter_tree, parameter_item);
                    break;
                  case JAPAN_ISUP_PARAM_TYPE_CHARGE_INF_TYPE: /* FA */
                    chg_inf_type = dissect_japan_chg_inf_type(parameter_tvb, parameter_tree, parameter_item);
                    break;
                  case JAPAN_ISUP_PARAM_TYPE_CHARGE_INF:
                    dissect_japan_chg_inf_param(parameter_tvb, pinfo, parameter_tree, parameter_item, chg_inf_type);
                    break;
                  case JAPAN_ISUP_PARAM_TYPE_CHARGE_AREA_INFO:
                    dissect_japan_isup_charge_area_info(parameter_tvb, pinfo, parameter_tree, parameter_item);
                    break;
                  default:
                    dissect_isup_unknown_parameter(parameter_tvb, parameter_tree, parameter_item);
                    break;
                }
                break;
              default:
                dissect_isup_unknown_parameter(parameter_tvb, parameter_tree, parameter_item);
                break;
            }
            break;
        }

        offset += MIN(parameter_length, actual_length);
      }

    }
    else {
      /* End of optional parameters is reached */
      proto_tree_add_uint_format(isup_tree, hf_isup_parameter_type, optional_parameters_tvb , offset, PARAMETER_TYPE_LENGTH,
                                 parameter_type, "End of optional parameters (%u)", parameter_type);
    }
  }
}

/* ------------------------------------------------------------------
  Dissector all ANSI optional parameters
  TODO: Actually make this dissect ANSI :) - It's still plain old ITU for now
*/
static void
dissect_ansi_isup_optional_parameter(tvbuff_t *optional_parameters_tvb, packet_info *pinfo, proto_tree *isup_tree, uint8_t itu_isup_variant)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  int         offset = 0;
  unsigned    parameter_type, parameter_length, actual_length;
  tvbuff_t   *parameter_tvb;
  uint8_t     octet;

  /* Dissect all optional parameters while end of message isn't reached */
  parameter_type = 0xFF; /* Start-initialization since parameter_type is used for while-condition */

  while ((tvb_reported_length_remaining(optional_parameters_tvb, offset)  >= 1) && (parameter_type != PARAM_TYPE_END_OF_OPT_PARAMS)) {
    parameter_type = tvb_get_uint8(optional_parameters_tvb, offset);

    if (parameter_type != PARAM_TYPE_END_OF_OPT_PARAMS) {
      parameter_length = tvb_get_uint8(optional_parameters_tvb, offset + PARAMETER_TYPE_LENGTH);

      parameter_tree = proto_tree_add_subtree_format(isup_tree, optional_parameters_tvb,
                                           offset, parameter_length  + PARAMETER_TYPE_LENGTH + PARAMETER_LENGTH_IND_LENGTH,
                                           ett_isup_parameter, &parameter_item, "Parameter: (t=%u, l=%u): %s",
                                           parameter_type, parameter_length, val_to_str_ext_const(parameter_type, &ansi_isup_parameter_type_value_ext, "Unknown"));
      proto_tree_add_uint(parameter_tree, hf_isup_opt_parameter_type, optional_parameters_tvb, offset,
                                 PARAMETER_TYPE_LENGTH, parameter_type);
      offset += PARAMETER_TYPE_LENGTH;

      octet = tvb_get_uint8(optional_parameters_tvb, offset);

      proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, optional_parameters_tvb, offset,
                                 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
      offset += PARAMETER_LENGTH_IND_LENGTH;
      if (octet == 0)
        continue;

      actual_length = tvb_reported_length_remaining(optional_parameters_tvb, offset);
      if (actual_length > 0) {
        parameter_tvb = tvb_new_subset_length_caplen(optional_parameters_tvb, offset, MIN(parameter_length, actual_length), parameter_length);
        switch (parameter_type) {
          case PARAM_TYPE_CALL_REF:
            dissect_isup_call_reference_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_TRANSM_MEDIUM_REQU:
            dissect_isup_transmission_medium_requirement_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_ACC_TRANSP:
            dissect_isup_access_transport_parameter(parameter_tvb, parameter_tree, parameter_item, pinfo);
            break;
          case PARAM_TYPE_CALLED_PARTY_NR:
            dissect_isup_called_party_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_SUBSQT_NR:
            dissect_isup_subsequent_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_NATURE_OF_CONN_IND:
            dissect_isup_nature_of_connection_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_FORW_CALL_IND:
            dissect_isup_forward_call_indicators_parameter(parameter_tvb, pinfo, parameter_item, parameter_tree);
            break;
          case PARAM_TYPE_OPT_FORW_CALL_IND:
            dissect_isup_optional_forward_call_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALLING_PRTY_CATEG:
            dissect_isup_calling_partys_category_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
            break;
          case PARAM_TYPE_CALLING_PARTY_NR:
            dissect_isup_calling_party_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_REDIRECTING_NR:
            dissect_isup_redirecting_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_REDIRECTION_NR:
            dissect_isup_redirection_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CONNECTION_REQ:
            dissect_isup_connection_request_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_INFO_REQ_IND:
            dissect_isup_information_request_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_INFO_IND:
            dissect_isup_information_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CONTINUITY_IND:
            dissect_isup_continuity_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_BACKW_CALL_IND:
            dissect_ansi_isup_backward_call_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CAUSE_INDICATORS:
            dissect_ansi_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_REDIRECTION_INFO:
            dissect_isup_redirection_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CIRC_GRP_SV_MSG_TYPE:
            dissect_isup_circuit_group_supervision_message_type_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_RANGE_AND_STATUS:
            dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_FACILITY_IND:
            dissect_isup_facility_ind_parameter(parameter_tvb, parameter_item);
            break;
          case PARAM_TYPE_CLSD_USR_GRP_ILOCK_CD:
            dissect_isup_closed_user_group_interlock_code_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_USER_SERVICE_INFO:
            dissect_isup_user_service_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_SIGNALLING_POINT_CODE:
            dissect_isup_signalling_point_code_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_USER_TO_USER_INFO:
            dissect_isup_user_to_user_information_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CONNECTED_NR:
            dissect_isup_connected_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_SUSP_RESUME_IND:
            dissect_isup_suspend_resume_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_TRANSIT_NETW_SELECT:
            dissect_ansi_isup_transit_network_selection_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_EVENT_INFO:
            dissect_isup_event_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CIRC_ASSIGN_MAP:
            dissect_isup_circuit_assignment_map_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CIRC_STATE_IND:
            dissect_isup_circuit_state_ind_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_AUTO_CONG_LEVEL:
            dissect_isup_automatic_congestion_level_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_ORIG_CALLED_NR:
            dissect_isup_original_called_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_OPT_BACKW_CALL_IND:
            dissect_isup_optional_backward_call_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_USER_TO_USER_IND:
            dissect_isup_user_to_user_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_ORIG_ISC_POINT_CODE:
            dissect_isup_original_isc_point_code_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_GENERIC_NOTIF_IND:
            dissect_isup_generic_notification_indicator_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALL_HIST_INFO :
            dissect_isup_call_history_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_ACC_DELIV_INFO:
            dissect_isup_access_delivery_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_NETW_SPECIFIC_FACLTY:
            dissect_isup_network_specific_facility_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_USER_SERVICE_INFO_PR:
            dissect_isup_user_service_information_prime_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_PROPAG_DELAY_COUNTER:
            dissect_isup_propagation_delay_counter_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_REMOTE_OPERATIONS:
            dissect_isup_remote_operations_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_SERVICE_ACTIVATION:
            dissect_isup_service_activation_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_USER_TELESERV_INFO:
            dissect_isup_user_teleservice_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_TRANSM_MEDIUM_USED:
            dissect_isup_transmission_medium_used_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALL_DIV_INFO:
            dissect_isup_call_diversion_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_ECHO_CTRL_INFO:
            dissect_isup_echo_control_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_MSG_COMPAT_INFO:
            dissect_isup_message_compatibility_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_PARAM_COMPAT_INFO:
            dissect_isup_parameter_compatibility_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_MLPP_PRECEDENCE:
            dissect_isup_mlpp_precedence_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_MCID_REQ_IND:
            dissect_isup_mcid_request_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_MCID_RSP_IND:
            dissect_isup_mcid_response_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_HOP_COUNTER:
            dissect_isup_hop_counter_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_ORIG_LINE_INFO:
            dissect_isup_orig_line_info_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_TRANSM_MEDIUM_RQUR_PR:
            dissect_isup_transmission_medium_requirement_prime_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_LOCATION_NR:
            dissect_isup_location_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_REDIR_NR_RSTRCT:
            dissect_isup_redirection_number_restriction_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALL_TRANS_REF:
            dissect_isup_call_transfer_reference_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_LOOP_PREV_IND:
            dissect_isup_loop_prevention_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALL_TRANS_NR:
            dissect_isup_call_transfer_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CCSS:
            dissect_isup_ccss_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_FORW_GVNS:
            dissect_isup_forward_gvns_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_BACKW_GVNS:
            dissect_isup_backward_gvns_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_REDIRECT_CAPAB:
            dissect_isup_redirect_capability_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
            break;
          case PARAM_TYPE_NETW_MGMT_CTRL:
            dissect_isup_network_management_controls_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CORRELATION_ID:
            dissect_isup_correlation_id_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_SCF_ID:
            dissect_isup_scf_id_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALL_DIV_TREAT_IND:
            dissect_isup_call_diversion_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALLED_IN_NR:
            dissect_isup_called_in_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALL_OFF_TREAT_IND:
            dissect_isup_call_offering_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CHARGED_PARTY_IDENT:
            dissect_isup_charged_party_identification_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CONF_TREAT_IND:
            dissect_isup_conference_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_DISPLAY_INFO:
            dissect_isup_display_information_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_UID_ACTION_IND:
            dissect_isup_uid_action_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_UID_CAPAB_IND:
            dissect_isup_uid_capability_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_REDIRECT_COUNTER:
            dissect_isup_redirect_counter_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
            break;
          case PARAM_TYPE_COLLECT_CALL_REQ:
            dissect_isup_collect_call_request_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CALLING_GEODETIC_LOCATION:
            dissect_isup_calling_geodetic_location_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_GENERIC_NR:
            dissect_isup_generic_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_JURISDICTION:
            dissect_isup_jurisdiction_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_GENERIC_NAME:
            dissect_isup_generic_name_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_GENERIC_DIGITS:
            dissect_isup_generic_digits_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_CHARGE_NR:
            dissect_isup_charge_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case PARAM_TYPE_APPLICATON_TRANS:
            dissect_isup_application_transport_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          case ANSI_ISUP_PARAM_TYPE_CARRIER_ID:
            dissect_ansi_isup_param_carrier_id(parameter_tvb, pinfo, parameter_tree, parameter_item);
            break;
          default:
            dissect_isup_unknown_parameter(parameter_tvb, parameter_tree, parameter_item);
            break;
        }

        offset += MIN(parameter_length, actual_length);
      }

    }
    else {
      /* End of optional parameters is reached */
      proto_tree_add_uint_format(isup_tree, hf_isup_parameter_type, optional_parameters_tvb , offset,
                                 PARAMETER_TYPE_LENGTH, parameter_type, "End of optional parameters (%u)", parameter_type);
    }
  }
}

/* ------------------------------------------------------------------ */
/* Dissectors for all used message types                              */
/* Called by dissect_isup_message(),                                  */
/* call parameter dissectors in order of mandatory parameters         */
/* (since not labeled)                                                */
/* ------------------------------------------------------------------
  Dissector Message Type Circuit Validation Test Response
 */
static int
dissect_ansi_isup_circuit_validation_test_resp_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
{
  proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, actual_length;

  /* Do stuff for first mandatory fixed parameter: CVR Response Indicator */
  parameter_type = ANSI_ISUP_PARAM_TYPE_CVR_RESP_IND;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset, CVR_RESP_IND_LENGTH,
                                    ett_isup_parameter, &parameter_item, "CVR Response Indicator");

  proto_tree_add_uint_format_value(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type,
                             "%u (%s)",
                             parameter_type,
                             val_to_str_ext_const(parameter_type, &isup_parameter_type_value_ext, "CVR Response Indicator"));

  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);

  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(CVR_RESP_IND_LENGTH, actual_length), CVR_RESP_IND_LENGTH);
  dissect_isup_cvr_response_ind_parameter(parameter_tvb, parameter_tree, parameter_item);
  offset += CVR_RESP_IND_LENGTH;

  /* Do stuff for second mandatory fixed parameter: CG Characteristics Indicator */
  parameter_type = ANSI_ISUP_PARAM_TYPE_CG_CHAR_IND;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
                                       CG_CHAR_IND_LENGTH, ett_isup_parameter, &parameter_item,
                                       "Circuit Group Characteristics Indicators");
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type,
                             "%u (%s)",
                             parameter_type,
                             val_to_str_ext_const(parameter_type, &isup_parameter_type_value_ext, "Circuit Group Characters"));
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(CG_CHAR_IND_LENGTH, actual_length), CG_CHAR_IND_LENGTH);
  dissect_isup_circuit_group_char_ind_parameter(parameter_tvb, parameter_tree, parameter_item);
  offset += CG_CHAR_IND_LENGTH;

  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type Circuit Reservation
 */
static int
dissect_ansi_isup_circuit_reservation_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, actual_length;

  /* Do stuff for mandatory fixed parameter: Nature of Connection Indicators */
  parameter_type = PARAM_TYPE_NATURE_OF_CONN_IND;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
                                       NATURE_OF_CONNECTION_IND_LENGTH, ett_isup_parameter, &parameter_item,
                                       "Nature of Connection Indicators");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(NATURE_OF_CONNECTION_IND_LENGTH, actual_length), NATURE_OF_CONNECTION_IND_LENGTH);
  dissect_isup_nature_of_connection_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
  offset += NATURE_OF_CONNECTION_IND_LENGTH;

  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type Initial address message
 */
static int
dissect_isup_initial_address_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree, uint8_t itu_isup_variant)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, parameter_pointer, parameter_length, actual_length;

  /* Do stuff for first mandatory fixed parameter: Nature of Connection Indicators */
  parameter_type = PARAM_TYPE_NATURE_OF_CONN_IND;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
                                       NATURE_OF_CONNECTION_IND_LENGTH, ett_isup_parameter, &parameter_item,
                                       "Nature of Connection Indicators");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(NATURE_OF_CONNECTION_IND_LENGTH, actual_length), NATURE_OF_CONNECTION_IND_LENGTH);
  dissect_isup_nature_of_connection_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
  offset += NATURE_OF_CONNECTION_IND_LENGTH;

  /* Do stuff for 2nd mandatory fixed parameter: Forward Call Indicators */
  parameter_type =  PARAM_TYPE_FORW_CALL_IND;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
                                       FORWARD_CALL_IND_LENGTH, ett_isup_parameter, &parameter_item,
                                       "Forward Call Indicators");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(FORWARD_CALL_IND_LENGTH, actual_length), FORWARD_CALL_IND_LENGTH);
  dissect_isup_forward_call_indicators_parameter(parameter_tvb, pinfo, parameter_item, parameter_tree);
  offset +=  FORWARD_CALL_IND_LENGTH;

  /* Do stuff for 3nd mandatory fixed parameter: Calling party's category */
  parameter_type = PARAM_TYPE_CALLING_PRTY_CATEG;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
                                       CALLING_PRTYS_CATEGORY_LENGTH,
                                        ett_isup_parameter, &parameter_item,
                                       "Calling Party's category");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(CALLING_PRTYS_CATEGORY_LENGTH, actual_length), CALLING_PRTYS_CATEGORY_LENGTH);
  dissect_isup_calling_partys_category_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
  offset += CALLING_PRTYS_CATEGORY_LENGTH;

  switch (isup_standard) {
    case ITU_STANDARD:
      /* If ITU, do stuff for 4th mandatory fixed parameter: Transmission medium requirement */
      parameter_type = PARAM_TYPE_TRANSM_MEDIUM_REQU;
      parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
                                           TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH,
                                           ett_isup_parameter, &parameter_item,
                                           "Transmission medium requirement");
      proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
      actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
      parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
                                     offset,
                                     MIN(TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH, actual_length),
                                     TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH);
      dissect_isup_transmission_medium_requirement_parameter(parameter_tvb, parameter_tree, parameter_item);
      offset += TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH;
      break;
    case ANSI_STANDARD:
      /* If ANSI, do stuff for the first mandatory variable parameter, USER_SERVICE_INFORMATION */
      parameter_type = PARAM_TYPE_USER_SERVICE_INFO;
      parameter_pointer = tvb_get_uint8(message_tvb, offset);
      parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);
      parameter_tree    = proto_tree_add_subtree(isup_tree, message_tvb,
                                              offset +  parameter_pointer,
                                              parameter_length + PARAMETER_LENGTH_IND_LENGTH,
                                               ett_isup_parameter, &parameter_item,
                                              "User Service Information");
      proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
      proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
                                 PARAMETER_POINTER_LENGTH, parameter_pointer);
      proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
                                 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
      actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
      parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
                                     offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
                                     MIN(parameter_length, actual_length),
                                     parameter_length);
      dissect_isup_user_service_information_parameter(parameter_tvb, parameter_tree, parameter_item);
      offset += PARAMETER_POINTER_LENGTH;
      break;
  }

  /* Do stuff for mandatory variable parameter Called party number */
  parameter_type = PARAM_TYPE_CALLED_PARTY_NR;
  parameter_pointer = tvb_get_uint8(message_tvb, offset);
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);

  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
                                       offset +  parameter_pointer,
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
                                        ett_isup_parameter, &parameter_item,
                                       "Called Party Number");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
                                 MIN(parameter_length, actual_length),
                                 parameter_length);
  dissect_isup_called_party_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
  offset += PARAMETER_POINTER_LENGTH;

  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type subsequent address message
 */
static int dissect_isup_subsequent_address_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, parameter_pointer, parameter_length, actual_length;

  /* Do stuff for mandatory variable parameter Subsequent number */
  parameter_type = PARAM_TYPE_SUBSQT_NR;

  parameter_pointer = tvb_get_uint8(message_tvb, offset);
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);

  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
                                       offset +  parameter_pointer,
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
                                        ett_isup_parameter, &parameter_item,
                                       "Subsequent Number");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
                                 MIN(parameter_length, actual_length),
                                 parameter_length);
  dissect_isup_subsequent_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
  offset += PARAMETER_POINTER_LENGTH;

  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type Information request message
 */
static int
dissect_isup_information_request_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, actual_length;

  /* Do stuff for first mandatory fixed parameter: Information request indicators*/
  parameter_type = PARAM_TYPE_INFO_REQ_IND;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
                                       INFO_REQUEST_IND_LENGTH,
                                        ett_isup_parameter, &parameter_item,
                                       "Information request indicators");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(INFO_REQUEST_IND_LENGTH, actual_length), INFO_REQUEST_IND_LENGTH);
  dissect_isup_information_request_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
  offset += INFO_REQUEST_IND_LENGTH;
  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type Information
 */
static int
dissect_isup_information_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
{
  proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, actual_length;

  /* Do stuff for first mandatory fixed parameter: Information  indicators*/
  parameter_type = PARAM_TYPE_INFO_IND;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
                                       INFO_IND_LENGTH, ett_isup_parameter, &parameter_item,
                                       "Information indicators");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(INFO_IND_LENGTH, actual_length), INFO_IND_LENGTH);
  dissect_isup_information_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
  offset += INFO_IND_LENGTH;
  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type Continuity
 */
static int
dissect_isup_continuity_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, actual_length;

  /* Do stuff for first mandatory fixed parameter: Continuity indicators*/
  parameter_type = PARAM_TYPE_CONTINUITY_IND;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
                                       CONTINUITY_IND_LENGTH, ett_isup_parameter, &parameter_item,
                                       "Continuity indicators");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(CONTINUITY_IND_LENGTH, actual_length), CONTINUITY_IND_LENGTH);
  dissect_isup_continuity_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
  offset += CONTINUITY_IND_LENGTH;
  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type Address complete
 */
static int
dissect_isup_address_complete_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
{
  proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, actual_length;

  /* Do stuff for first mandatory fixed parameter: backward call indicators*/
  parameter_type = PARAM_TYPE_BACKW_CALL_IND;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
                                       BACKWARD_CALL_IND_LENGTH, ett_isup_parameter, &parameter_item,
                                       "Backward Call Indicators");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(BACKWARD_CALL_IND_LENGTH, actual_length), BACKWARD_CALL_IND_LENGTH);
  dissect_isup_backward_call_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
  offset += BACKWARD_CALL_IND_LENGTH;
  return offset;
}

static int
dissect_ansi_isup_address_complete_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
{
  proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, actual_length;

  /* Do stuff for first mandatory fixed parameter: backward call indicators*/
  parameter_type = PARAM_TYPE_BACKW_CALL_IND;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
    BACKWARD_CALL_IND_LENGTH, ett_isup_parameter, &parameter_item,
    "Backward Call Indicators");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(BACKWARD_CALL_IND_LENGTH, actual_length), BACKWARD_CALL_IND_LENGTH);
  dissect_ansi_isup_backward_call_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
  offset += BACKWARD_CALL_IND_LENGTH;
  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type Connect
 */
static int
dissect_isup_connect_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, actual_length;

  /* Do stuff for first mandatory fixed parameter: backward call indicators*/
  parameter_type = PARAM_TYPE_BACKW_CALL_IND;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
                                       BACKWARD_CALL_IND_LENGTH, ett_isup_parameter, &parameter_item,
                                       "Backward Call Indicators");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(BACKWARD_CALL_IND_LENGTH, actual_length), BACKWARD_CALL_IND_LENGTH);
  dissect_isup_backward_call_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
  offset += BACKWARD_CALL_IND_LENGTH;
  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type release message
 */
static int
dissect_isup_release_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, parameter_pointer, parameter_length, actual_length;

  /* Do stuff for mandatory variable parameter Cause indicators */
  parameter_type =  PARAM_TYPE_CAUSE_INDICATORS;

  parameter_pointer = tvb_get_uint8(message_tvb, offset);
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);

  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
                                       offset +  parameter_pointer,
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
                                        ett_isup_parameter, &parameter_item,
                                       "Cause indicators");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
                                 MIN(parameter_length, actual_length),
                                 parameter_length);
  switch (isup_standard) {
    case ITU_STANDARD:
      dissect_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
      break;
    case ANSI_STANDARD:
      dissect_ansi_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
      break;
  }
  offset += PARAMETER_POINTER_LENGTH;

  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type Resume/Suspend
 */
static int
dissect_isup_suspend_resume_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, actual_length;

  /* Do stuff for first mandatory fixed parameter: backward call indicators*/
  parameter_type = PARAM_TYPE_SUSP_RESUME_IND;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
                                       SUSPEND_RESUME_IND_LENGTH,
                                        ett_isup_parameter, &parameter_item,
                                       "Suspend/Resume indicator");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(SUSPEND_RESUME_IND_LENGTH, actual_length), SUSPEND_RESUME_IND_LENGTH);
  dissect_isup_suspend_resume_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
  offset += SUSPEND_RESUME_IND_LENGTH;
  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type Circuit group reset/query message
 */
static int
dissect_isup_circuit_group_reset_query_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, parameter_pointer, parameter_length, actual_length;

  /* Do stuff for mandatory variable parameter range and status*/
  parameter_type =  PARAM_TYPE_RANGE_AND_STATUS;

  parameter_pointer = tvb_get_uint8(message_tvb, offset);
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);

  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
                                       offset +  parameter_pointer,
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
                                        ett_isup_parameter, &parameter_item,
                                       "Range and status");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
                                 MIN(parameter_length, actual_length),
                                 parameter_length);
  dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
  offset += PARAMETER_POINTER_LENGTH;

  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type Circuit group blocking/blocking ack/unblocking/unblocking ack messages
 */
static int
dissect_isup_circuit_group_blocking_messages(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, parameter_pointer, parameter_length, actual_length;

   /* Do stuff for first mandatory fixed parameter: circuit group supervision message type*/
  parameter_type = PARAM_TYPE_CIRC_GRP_SV_MSG_TYPE;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
                                       CIRC_GRP_SV_MSG_TYPE_LENGTH,
                                        ett_isup_parameter, &parameter_item,
                                       "Circuit group supervision message type");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(CIRC_GRP_SV_MSG_TYPE_LENGTH, actual_length), CIRC_GRP_SV_MSG_TYPE_LENGTH);
  dissect_isup_circuit_group_supervision_message_type_parameter(parameter_tvb, parameter_tree, parameter_item);
  offset += CIRC_GRP_SV_MSG_TYPE_LENGTH;

  /* Do stuff for mandatory variable parameter range and status*/
  parameter_type =  PARAM_TYPE_RANGE_AND_STATUS;

  parameter_pointer = tvb_get_uint8(message_tvb, offset);
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);

  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
                                       offset +  parameter_pointer,
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
                                        ett_isup_parameter, &parameter_item,
                                       "Range and status");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
                                 MIN(parameter_length, actual_length),
                                 parameter_length);
  dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
  offset += PARAMETER_POINTER_LENGTH;

  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type Facility request/accepted
 */
static int
dissect_isup_facility_request_accepted_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, actual_length;

  /* Do stuff for first mandatory fixed parameter: facility indicators*/
  parameter_type = PARAM_TYPE_FACILITY_IND;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
                                       FACILITY_IND_LENGTH,
                                        ett_isup_parameter, &parameter_item,
                                       "Facility indicator");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(FACILITY_IND_LENGTH, actual_length), FACILITY_IND_LENGTH);
  dissect_isup_facility_ind_parameter(parameter_tvb, parameter_item);
  offset += FACILITY_IND_LENGTH;
  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type Facility reject
 */
static int
dissect_isup_facility_reject_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, parameter_pointer, parameter_length, actual_length;

  /* Do stuff for first mandatory fixed parameter: facility indicators*/
  parameter_type = PARAM_TYPE_FACILITY_IND;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
                                       FACILITY_IND_LENGTH,
                                        ett_isup_parameter, &parameter_item,
                                       "Facility indicator");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(FACILITY_IND_LENGTH, actual_length), FACILITY_IND_LENGTH);
  dissect_isup_facility_ind_parameter(parameter_tvb, parameter_item);
  offset += FACILITY_IND_LENGTH;

  /* Do stuff for mandatory variable parameter Cause indicators */
  parameter_type =  PARAM_TYPE_CAUSE_INDICATORS;

  parameter_pointer = tvb_get_uint8(message_tvb, offset);
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);

  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
                                       offset +  parameter_pointer,
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
                                        ett_isup_parameter, &parameter_item,
                                       "Cause indicators, see Q.850");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb,
                             offset, PARAMETER_POINTER_LENGTH, parameter_pointer);
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
                                 MIN(parameter_length, actual_length),
                                 parameter_length);
  switch (isup_standard) {
    case ITU_STANDARD:
      dissect_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
      break;
    case ANSI_STANDARD:
      dissect_ansi_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
      break;
  }
  offset += PARAMETER_POINTER_LENGTH;

  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type Circuit group reset acknowledgement message
 */
static int
dissect_isup_circuit_group_reset_acknowledgement_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, parameter_pointer, parameter_length, actual_length;

  /* Do stuff for mandatory variable parameter range and status*/
  parameter_type =  PARAM_TYPE_RANGE_AND_STATUS;

  parameter_pointer = tvb_get_uint8(message_tvb, offset);
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);

  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
                                       offset +  parameter_pointer,
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
                                       ett_isup_parameter, &parameter_item,
                                       "Range and status");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
                                 MIN(parameter_length, actual_length),
                                 parameter_length);
  dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
  offset += PARAMETER_POINTER_LENGTH;

  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type Circuit group query response message
 */
static int
dissect_isup_circuit_group_query_response_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, parameter_pointer, parameter_length, actual_length;

  /* Do stuff for 1. mandatory variable parameter range and status*/
  parameter_type =  PARAM_TYPE_RANGE_AND_STATUS;

  parameter_pointer = tvb_get_uint8(message_tvb, offset);
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);

  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
                                       offset +  parameter_pointer,
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
                                        ett_isup_parameter, &parameter_item,
                                       "Range and status");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
                                 MIN(parameter_length, actual_length),
                                 parameter_length);
  dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
  offset += PARAMETER_POINTER_LENGTH;

  /* Do stuff for 2. mandatory variable parameter Circuit state indicator*/
  parameter_type = PARAM_TYPE_CIRC_STATE_IND;

  parameter_pointer = tvb_get_uint8(message_tvb, offset);
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);

  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
                                       offset +  parameter_pointer,
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
                                        ett_isup_parameter, &parameter_item,
                                       "Circuit state indicator (national use)");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
                                 MIN(parameter_length, actual_length),
                                 parameter_length);
  dissect_isup_circuit_state_ind_parameter(parameter_tvb, parameter_tree, parameter_item);
  offset += PARAMETER_POINTER_LENGTH;

  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type Call Progress
*/
static int
dissect_isup_call_progress_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, actual_length;

  /* Do stuff for first mandatory fixed parameter: Event information*/
  parameter_type = PARAM_TYPE_EVENT_INFO;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
                                       EVENT_INFO_LENGTH, ett_isup_parameter, &parameter_item,
                                       "Event information");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(EVENT_INFO_LENGTH, actual_length), EVENT_INFO_LENGTH);
  dissect_isup_event_information_parameter(parameter_tvb, parameter_tree, parameter_item);
  offset += EVENT_INFO_LENGTH;
  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type User-to-User information
 */
static int
dissect_isup_user_to_user_information_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, parameter_pointer, parameter_length, actual_length;

  /* Do stuff for mandatory variable parameter User-to-user information*/
  parameter_type =  PARAM_TYPE_USER_TO_USER_INFO;

  parameter_pointer = tvb_get_uint8(message_tvb, offset);
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);

  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
                                       offset +  parameter_pointer,
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
                                       ett_isup_parameter, &parameter_item,
                                       "User-to-user information, see Q.931");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
                                 MIN(parameter_length, actual_length),
                                 parameter_length);
  dissect_isup_user_to_user_information_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
  offset += PARAMETER_POINTER_LENGTH;

  return offset;
}

/* ------------------------------------------------------------------
  Dissector Message Type Confusion
 */
static int
dissect_isup_confusion_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
{ proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, parameter_pointer, parameter_length, actual_length;

  /* Do stuff for mandatory variable parameter Cause indicators */
  parameter_type =  PARAM_TYPE_CAUSE_INDICATORS;

  parameter_pointer = tvb_get_uint8(message_tvb, offset);
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);

  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
                                       offset +  parameter_pointer,
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
                                        ett_isup_parameter, &parameter_item,
                                       "Cause indicators, see Q.850");
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length,
                             message_tvb, offset + parameter_pointer, PARAMETER_LENGTH_IND_LENGTH,
                             parameter_length);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
                                 MIN(parameter_length, actual_length),
                                 parameter_length);

  switch (isup_standard) {
    case ITU_STANDARD:
      dissect_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
      break;
    case ANSI_STANDARD:
      dissect_ansi_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
      break;
  }
  offset += PARAMETER_POINTER_LENGTH;

  return offset;
}

/* Dissect national messages */
static int
dissect_french_isup_charging_pulse_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
{
  int offset = 0;

  proto_tree_add_item(isup_tree, hf_isup_french_coll_field, message_tvb, offset, 1, ENC_BIG_ENDIAN);
  offset += 1;
  proto_tree_add_item(isup_tree, hf_isup_french_msg_num, message_tvb, offset, 1, ENC_BIG_ENDIAN);
  offset += 1;

  return offset;
}

static const value_string israeli_cmi_current_rate[] = {
  { 0,   "Current rate not present" },
  { 1,   "Rate expressed in deciseconds" },
  { 2,   "Rate expressed in centiseconds" },
  { 3,   "Rate expressed in milliseconds" },
  { 0,   NULL}
};
static const value_string israeli_cmi_next_rate[] = {
  { 0,   "Time indicator and next rate not present" },
  { 1,   "Rate expressed in deciseconds" },
  { 2,   "Rate expressed in centiseconds" },
  { 3,   "Rate expressed in milliseconds" },
  { 0,   NULL}
};
static const value_string israeli_time_indicators[] = {
  {  0,   "spare" },
  {  1,   "00.30 H" },
  {  2,   "01.00 H" },
  {  3,   "01.30 H" },
  {  4,   "02.00 H" },
  {  5,   "02.30 H" },
  {  6,   "03.00 H" },
  {  7,   "03.30 H" },
  {  8,   "04.00 H" },
  {  9,   "04.30 H" },
  { 10,   "05.00 H" },
  { 11,   "05.30 H" },
  { 12,   "06.00 H" },
  { 13,   "06.30 H" },
  { 14,   "07.00 H" },
  { 15,   "07.30 H" },
  { 16,   "08.00 H" },
  { 17,   "08.30 H" },
  { 18,   "09.00 H" },
  { 19,   "09.30 H" },
  { 20,   "10.00 H" },
  { 21,   "10.30 H" },
  { 22,   "11.00 H" },
  { 23,   "11.30 H" },
  { 24,   "12.00 H" },
  { 25,   "12.30 H" },
  { 26,   "13.00 H" },
  { 27,   "13.30 H" },
  { 28,   "14.00 H" },
  { 29,   "14.30 H" },
  { 30,   "15.00 H" },
  { 31,   "15.30 H" },
  { 32,   "16.00 H" },
  { 33,   "16.30 H" },
  { 34,   "17.00 H" },
  { 35,   "17.30 H" },
  { 36,   "18.00 H" },
  { 37,   "18.30 H" },
  { 38,   "19.00 H" },
  { 39,   "19.30 H" },
  { 40,   "20.00 H" },
  { 41,   "20.30 H" },
  { 42,   "21.00 H" },
  { 43,   "21.30 H" },
  { 44,   "22.00 H" },
  { 45,   "22.30 H" },
  { 46,   "23.00 H" },
  { 47,   "23.30 H" },
  { 48,   "24.00 H" },
  { 0,   NULL}
};
static value_string_ext israeli_time_indicators_ext = VALUE_STRING_EXT_INIT(israeli_time_indicators);

static int
dissect_israeli_backward_charging_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
{
  int offset = 0;

  proto_tree_add_item(isup_tree, hf_isup_israeli_charging_message_indicators_current, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
  proto_tree_add_item(isup_tree, hf_isup_israeli_charging_message_indicators_next, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
  offset += 1;
  proto_tree_add_item(isup_tree, hf_isup_israeli_current_rate, message_tvb, offset, 2, ENC_LITTLE_ENDIAN);
  offset += 2;
  proto_tree_add_item(isup_tree, hf_isup_israeli_time_indicator, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
  offset += 1;
  proto_tree_add_item(isup_tree, hf_isup_israeli_next_rate, message_tvb, offset, 2, ENC_LITTLE_ENDIAN);
  offset += 2;

  return offset;
}

static int
dissect_israeli_traffic_change_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
{
  int offset = 0;

  proto_tree_add_item(isup_tree, hf_isup_israeli_charging_message_indicators_current, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
  proto_tree_add_item(isup_tree, hf_isup_israeli_charging_message_indicators_next, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
  offset += 1;
  proto_tree_add_item(isup_tree, hf_isup_israeli_time_indicator, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
  offset += 1;
  proto_tree_add_item(isup_tree, hf_isup_israeli_next_rate, message_tvb, offset, 2, ENC_LITTLE_ENDIAN);
  offset += 2;

  return offset;
}

static int
dissect_japan_chg_inf(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
{
  proto_item *parameter_item;
  proto_tree *parameter_tree;
  tvbuff_t   *parameter_tvb;
  int         offset = 0;
  int         parameter_type, parameter_pointer, parameter_length, actual_length;
  uint8_t     chg_inf_type;

  /* Do stuff for first mandatory fixed parameter: Charge information type */
  parameter_type = JAPAN_ISUP_PARAM_TYPE_CHARGE_INF_TYPE;
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset, 1,
                            ett_isup_parameter, &parameter_item, "Charge information type");
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type,
                             "%u (%s)",
                             parameter_type,
                             val_to_str_ext_const(parameter_type, &japan_isup_parameter_type_value_ext, "unknown"));
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb, offset, MIN(1, actual_length), 1);
  chg_inf_type = tvb_get_uint8(parameter_tvb, 0);
  dissect_japan_chg_inf_type(parameter_tvb, parameter_tree, parameter_item);
  offset += 1;

  /* Do stuff for mandatory variable parameter Charge information */
  parameter_type = JAPAN_ISUP_PARAM_TYPE_CHARGE_INF;
  parameter_pointer = tvb_get_uint8(message_tvb, offset);
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);

  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
                                       offset +  parameter_pointer,
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
                                       ett_isup_parameter, &parameter_item,
                                       "Charge information");
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type,
                             "%u (%s)",
                             parameter_type,
                             val_to_str_ext_const(parameter_type, &japan_isup_parameter_type_value_ext, "unknown"));
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
                      PARAMETER_POINTER_LENGTH, parameter_pointer);
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
                      PARAMETER_LENGTH_IND_LENGTH, parameter_length);
  actual_length = tvb_ensure_captured_length_remaining(message_tvb, offset);
  parameter_tvb = tvb_new_subset_length_caplen(message_tvb,
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
                                 MIN(parameter_length, actual_length),
                                 parameter_length);

  /* TODO: Dissect the parameter here, switch on type */
  switch (chg_inf_type) {
    case 3:
      /* Advanced Charge Rate Transfer (TDS service) */
      dissect_japan_chg_inf_type_acr(parameter_tvb, parameter_tree, parameter_item);
      break;
    case 254:
      /* Charge rate transfer (flexible charging) */
      dissect_japan_chg_inf_type_crt(parameter_tvb, parameter_tree, parameter_item);
      break;
    default:
      proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, 0, -1, "Charge information data, not dissected yet");
      break;
  }


  offset += PARAMETER_POINTER_LENGTH;

  return offset;

}

/* ------------------------------------------------------------------ */
// NOLINTBEGIN(misc-no-recursion)
static void
dissect_ansi_isup_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree, uint8_t itu_isup_variant, uint32_t circuit_id)
{
  isup_tap_rec_t *tap_rec;

  tvbuff_t   *parameter_tvb;
  tvbuff_t   *optional_parameter_tvb;
  proto_tree *pass_along_tree;
  proto_item *type_item;
  int         offset, bufferlength;
  uint8_t     message_type, opt_parameter_pointer;
  bool        opt_part_possible = false; /* default setting - for message types allowing optional
                                            params explicitly set to true in case statement */
  tap_calling_number            = NULL;
  offset                        = 0;

  // We call ourselves for MESSAGE_TYPE_PASS_ALONG.
  increment_dissection_depth(pinfo);

  /* Extract message type field */
  message_type = tvb_get_uint8(message_tvb, 0);

  type_item = proto_tree_add_uint_format(isup_tree, hf_isup_message_type, message_tvb, 0, MESSAGE_TYPE_LENGTH, message_type, "Message type: %s (%u)",
                             val_to_str_ext_const(message_type, &ansi_isup_message_type_value_ext, "reserved"), message_type);

  offset +=  MESSAGE_TYPE_LENGTH;

  tap_rec = wmem_new(pinfo->pool, isup_tap_rec_t);
  tap_rec->message_type   = message_type;
  tap_rec->itu_isup_variant = itu_isup_variant;
  tap_rec->calling_number = NULL;
  tap_rec->called_number  = NULL;
  tap_rec->circuit_id     = circuit_id;

  parameter_tvb = tvb_new_subset_remaining(message_tvb, offset);

  /* distinguish between message types:*/
  switch (message_type) {
    case MESSAGE_TYPE_INITIAL_ADDR:
      offset += dissect_isup_initial_address_message(parameter_tvb, pinfo, isup_tree, itu_isup_variant);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_SUBSEQ_ADDR:
      offset += dissect_isup_subsequent_address_message(parameter_tvb, pinfo, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_INFO_REQ:
      offset += dissect_isup_information_request_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_INFO:
      offset += dissect_isup_information_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_CONTINUITY:
      offset += dissect_isup_continuity_message(parameter_tvb, isup_tree);
      break;
    case MESSAGE_TYPE_ADDR_CMPL:
      offset += dissect_ansi_isup_address_complete_message(parameter_tvb, pinfo, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_CONNECT:
      offset += dissect_isup_connect_message(parameter_tvb, pinfo, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_FORW_TRANS:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_ANSWER:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_RELEASE:
      offset += dissect_isup_release_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_SUSPEND:
      offset += dissect_isup_suspend_resume_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_RESUME:
      offset += dissect_isup_suspend_resume_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_REL_CMPL:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_CONT_CHECK_REQ:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_RESET_CIRCUIT:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_BLOCKING:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_UNBLOCKING:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_BLOCK_ACK:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_UNBLOCK_ACK:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_CIRC_GRP_RST:
      offset += dissect_isup_circuit_group_reset_query_message(parameter_tvb, pinfo, isup_tree);
      break;
    case MESSAGE_TYPE_CIRC_GRP_BLCK:
      offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
      break;
    case MESSAGE_TYPE_CIRC_GRP_UNBL:
      offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
      break;
    case MESSAGE_TYPE_CIRC_GRP_BL_ACK:
      offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
      break;
    case MESSAGE_TYPE_CIRC_GRP_UNBL_ACK:
      offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
      break;
    case MESSAGE_TYPE_FACILITY_REQ:
      offset += dissect_isup_facility_request_accepted_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_FACILITY_ACC:
      offset += dissect_isup_facility_request_accepted_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_FACILITY_REJ:
      offset += dissect_isup_facility_reject_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_LOOP_BACK_ACK:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_PASS_ALONG:
      /* call dissect_isup_message recursively */
    {
      uint8_t pa_message_type;
      pa_message_type = tvb_get_uint8(parameter_tvb, 0);
      pass_along_tree = proto_tree_add_subtree_format(isup_tree, parameter_tvb, offset, -1,
                                            ett_isup_pass_along_message, NULL, "Pass-along: %s Message (%u)",
                                            val_to_str_ext_const(pa_message_type, &isup_message_type_value_acro_ext, "reserved"),
                                            pa_message_type);
      dissect_ansi_isup_message(parameter_tvb, pinfo, pass_along_tree, itu_isup_variant, circuit_id);
      break;
    }
    case MESSAGE_TYPE_CIRC_GRP_RST_ACK:
      offset += dissect_isup_circuit_group_reset_acknowledgement_message(parameter_tvb, pinfo, isup_tree);
      break;
    case MESSAGE_TYPE_CIRC_GRP_QRY:
      offset += dissect_isup_circuit_group_reset_query_message(parameter_tvb, pinfo, isup_tree);
      break;
    case MESSAGE_TYPE_CIRC_GRP_QRY_RSP:
      offset += dissect_isup_circuit_group_query_response_message(parameter_tvb, pinfo, isup_tree);
      break;
    case MESSAGE_TYPE_CALL_PROGRSS:
      offset += dissect_isup_call_progress_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_USER2USER_INFO:
      offset += dissect_isup_user_to_user_information_message(parameter_tvb, pinfo, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_UNEQUIPPED_CIC:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_CONFUSION:
      offset += dissect_isup_confusion_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_OVERLOAD:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_CHARGE_INFO:
      /* do nothing since format is a national matter */
      bufferlength = tvb_reported_length_remaining(message_tvb, offset);
      if (bufferlength != 0)
        proto_tree_add_expert(isup_tree, pinfo, &ei_isup_format_national_matter, parameter_tvb, 0, bufferlength);
      break;
    case MESSAGE_TYPE_NETW_RESRC_MGMT:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_FACILITY:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_USER_PART_TEST:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_USER_PART_AVAIL:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_IDENT_REQ:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_IDENT_RSP:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_SEGMENTATION:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_LOOP_PREVENTION:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_APPLICATION_TRANS:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_PRE_RELEASE_INFO:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_SUBSEQUENT_DIR_NUM:
      /* do nothing since format is a national matter */
      bufferlength = tvb_reported_length_remaining(message_tvb, offset);
      if (bufferlength != 0)
        proto_tree_add_expert(isup_tree, pinfo, &ei_isup_format_national_matter, parameter_tvb, 0, bufferlength);
      break;
    case ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES_ACK:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES:
      offset += dissect_ansi_isup_circuit_reservation_message(parameter_tvb, pinfo, isup_tree);
      break;
    case ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST_RSP:
      opt_part_possible = true;
      offset += dissect_ansi_isup_circuit_validation_test_resp_message(parameter_tvb, isup_tree);
      break;
    case ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST:
      /* no dissector necessary since no mandatory parameters included */
      break;
    default:
      bufferlength = tvb_reported_length_remaining(message_tvb, offset);
      if (bufferlength != 0)
        expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
      break;
  }

  /* extract pointer to start of optional part (if any) */
  if (opt_part_possible == true) {
    opt_parameter_pointer = tvb_get_uint8(message_tvb, offset);
    if (opt_parameter_pointer > 0) {
      proto_tree_add_uint_format(isup_tree, hf_isup_pointer_to_start_of_optional_part, message_tvb, offset,
                                 PARAMETER_POINTER_LENGTH, opt_parameter_pointer,
                                 "Pointer to start of optional part: %u", opt_parameter_pointer);
      offset += opt_parameter_pointer;
      optional_parameter_tvb = tvb_new_subset_remaining(message_tvb, offset);
      dissect_ansi_isup_optional_parameter(optional_parameter_tvb, pinfo, isup_tree, itu_isup_variant);
    }
    else
      proto_tree_add_uint_format(isup_tree, hf_isup_pointer_to_start_of_optional_part, message_tvb, offset,
                                 PARAMETER_POINTER_LENGTH, opt_parameter_pointer,
                                 "No optional parameter present (Pointer: %u)", opt_parameter_pointer);
  }
  else if (message_type != MESSAGE_TYPE_CHARGE_INFO)
    expert_add_info(pinfo, type_item, &ei_isup_message_type_no_optional_parameters);

  /* if there are calling/called number, we'll get them for the tap */
  tap_rec->calling_number = tap_calling_number ? tap_calling_number : wmem_strdup(pinfo->pool, "");
  tap_rec->called_number  = tap_called_number;
  tap_rec->cause_value    = tap_cause_value;
  tap_queue_packet(isup_tap, pinfo, tap_rec);

  decrement_dissection_depth(pinfo);
}
// NOLINTEND(misc-no-recursion)

// NOLINTBEGIN(misc-no-recursion)
static void
dissect_isup_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree, uint8_t itu_isup_variant, uint32_t circuit_id)
{
  isup_tap_rec_t *tap_rec;

  tvbuff_t   *parameter_tvb;
  tvbuff_t   *optional_parameter_tvb;
  proto_tree *pass_along_tree;
  proto_item *type_item = NULL;
  int         offset, bufferlength;
  uint8_t     message_type, opt_parameter_pointer;
  bool        opt_part_possible = false; /* default setting - for message types allowing optional
                                             params explicitly set to true in case statement */
  tap_calling_number            = NULL;
  offset                        = 0;

  // We call ourselves for MESSAGE_TYPE_PASS_ALONG.
  increment_dissection_depth(pinfo);

  /* Extract message type field */
  message_type = tvb_get_uint8(message_tvb, 0);

  switch (itu_isup_variant) {
    case ISUP_ITU_STANDARD_VARIANT:
      type_item = proto_tree_add_uint_format_value(isup_tree, hf_isup_message_type, message_tvb, 0, MESSAGE_TYPE_LENGTH, message_type,
                                 "%s (%u)",
                                 val_to_str_ext_const(message_type, &isup_message_type_value_ext, "reserved"),
                                 message_type);
      break;
    case ISUP_FRENCH_VARIANT:
      type_item = proto_tree_add_uint_format_value(isup_tree, hf_isup_message_type, message_tvb, 0, MESSAGE_TYPE_LENGTH, message_type,
                                 "%s (%u)",
                                 val_to_str_ext_const(message_type, &french_isup_message_type_value_ext, "reserved"),
                                 message_type);
      break;
    case ISUP_ISRAELI_VARIANT:
      type_item = proto_tree_add_uint_format_value(isup_tree, hf_isup_message_type, message_tvb, 0, MESSAGE_TYPE_LENGTH, message_type,
                                 "%s (%u)",
                                 val_to_str_ext_const(message_type, &israeli_isup_message_type_value_ext, "reserved"),
                                 message_type);
      break;
    case ISUP_RUSSIAN_VARIANT:
      type_item = proto_tree_add_uint_format_value(isup_tree, hf_isup_message_type, message_tvb, 0, MESSAGE_TYPE_LENGTH, message_type,
                                 "%s (%u)",
                                 val_to_str_ext_const(message_type, &russian_isup_message_type_value_ext, "reserved"),
                                 message_type);
      break;
  case ISUP_JAPAN_VARIANT:
  /* Fall through */
  case ISUP_JAPAN_TTC_VARIANT:
      type_item = proto_tree_add_uint_format_value(isup_tree, hf_isup_message_type, message_tvb, 0, MESSAGE_TYPE_LENGTH, message_type,
                                 "%s (%u)",
                                 val_to_str_ext_const(message_type, &japan_isup_message_type_value_ext, "reserved"),
                                 message_type);
      break;
  }

  offset +=  MESSAGE_TYPE_LENGTH;

  tap_rec = wmem_new(pinfo->pool, isup_tap_rec_t);
  tap_rec->message_type   = message_type;
  tap_rec->itu_isup_variant = itu_isup_variant;
  tap_rec->calling_number = NULL;
  tap_rec->called_number  = NULL;
  tap_rec->circuit_id     = circuit_id;

  parameter_tvb = tvb_new_subset_remaining(message_tvb, offset);

  /* distinguish between message types:*/
  switch (message_type) {
    case MESSAGE_TYPE_INITIAL_ADDR:
      offset += dissect_isup_initial_address_message(parameter_tvb, pinfo, isup_tree, itu_isup_variant);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_SUBSEQ_ADDR:
      offset += dissect_isup_subsequent_address_message(parameter_tvb, pinfo, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_INFO_REQ:
      offset += dissect_isup_information_request_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_INFO:
      offset += dissect_isup_information_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_CONTINUITY:
      offset += dissect_isup_continuity_message(parameter_tvb, isup_tree);
      break;
    case MESSAGE_TYPE_ADDR_CMPL:
      offset += dissect_isup_address_complete_message(parameter_tvb, pinfo, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_CONNECT:
      offset += dissect_isup_connect_message(parameter_tvb, pinfo, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_FORW_TRANS:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_ANSWER:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_RELEASE:
      offset += dissect_isup_release_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_SUSPEND:
      offset += dissect_isup_suspend_resume_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_RESUME:
      offset += dissect_isup_suspend_resume_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_REL_CMPL:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_CONT_CHECK_REQ:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_RESET_CIRCUIT:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_BLOCKING:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_UNBLOCKING:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_BLOCK_ACK:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_UNBLOCK_ACK:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_CIRC_GRP_RST:
      offset += dissect_isup_circuit_group_reset_query_message(parameter_tvb, pinfo, isup_tree);
      break;
    case MESSAGE_TYPE_CIRC_GRP_BLCK:
      offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
      break;
    case MESSAGE_TYPE_CIRC_GRP_UNBL:
      offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
      break;
    case MESSAGE_TYPE_CIRC_GRP_BL_ACK:
      offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
      break;
    case MESSAGE_TYPE_CIRC_GRP_UNBL_ACK:
      offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
      break;
    case MESSAGE_TYPE_FACILITY_REQ:
      offset += dissect_isup_facility_request_accepted_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_FACILITY_ACC:
      offset += dissect_isup_facility_request_accepted_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_FACILITY_REJ:
      offset += dissect_isup_facility_reject_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_LOOP_BACK_ACK:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_PASS_ALONG:
      /* call dissect_isup_message recursively */
    {
      uint8_t pa_message_type;
      pa_message_type = tvb_get_uint8(parameter_tvb, 0);
      pass_along_tree = proto_tree_add_subtree_format(isup_tree, parameter_tvb, offset, -1,
                                            ett_isup_pass_along_message, NULL,
                                            "Pass-along: %s Message (%u)",
                                            val_to_str_ext_const(pa_message_type, &isup_message_type_value_acro_ext, "reserved"),
                                            pa_message_type);
      dissect_isup_message(parameter_tvb, pinfo, pass_along_tree, itu_isup_variant, circuit_id);
      break;
    }
    case MESSAGE_TYPE_CIRC_GRP_RST_ACK:
      offset += dissect_isup_circuit_group_reset_acknowledgement_message(parameter_tvb, pinfo, isup_tree);
      break;
    case MESSAGE_TYPE_CIRC_GRP_QRY:
      offset += dissect_isup_circuit_group_reset_query_message(parameter_tvb, pinfo, isup_tree);
      break;
    case MESSAGE_TYPE_CIRC_GRP_QRY_RSP:
      offset += dissect_isup_circuit_group_query_response_message(parameter_tvb, pinfo, isup_tree);
      break;
    case MESSAGE_TYPE_CALL_PROGRSS:
      offset += dissect_isup_call_progress_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_USER2USER_INFO:
      offset += dissect_isup_user_to_user_information_message(parameter_tvb, pinfo, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_UNEQUIPPED_CIC:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_CONFUSION:
      offset += dissect_isup_confusion_message(parameter_tvb, isup_tree);
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_OVERLOAD:
      /* no dissector necessary since no mandatory parameters included */
      break;
    case MESSAGE_TYPE_CHARGE_INFO:
      /* do nothing since format is a national matter */
      bufferlength = tvb_reported_length_remaining(message_tvb, offset);
      if (bufferlength != 0) {
        switch (itu_isup_variant) {
          case ISUP_RUSSIAN_VARIANT:
            proto_tree_add_expert(isup_tree, pinfo, &ei_isup_format_national_matter, parameter_tvb, 0, bufferlength);
            break;
          default:
            proto_tree_add_expert(isup_tree, pinfo, &ei_isup_format_national_matter, parameter_tvb, 0, bufferlength);
            break;
        }
      }
      break;
    case MESSAGE_TYPE_NETW_RESRC_MGMT:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_FACILITY:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_USER_PART_TEST:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_USER_PART_AVAIL:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_IDENT_REQ:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_IDENT_RSP:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_SEGMENTATION:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_LOOP_PREVENTION:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_APPLICATION_TRANS:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_PRE_RELEASE_INFO:
      /* no dissector necessary since no mandatory parameters included */
      opt_part_possible = true;
      break;
    case MESSAGE_TYPE_SUBSEQUENT_DIR_NUM:
      /* do nothing since format is a national matter */
      bufferlength = tvb_reported_length_remaining(message_tvb, offset);
      if (bufferlength != 0)
         proto_tree_add_expert(isup_tree, pinfo, &ei_isup_format_national_matter, parameter_tvb, 0, bufferlength);
      break;
    default:
      /* Handle national extensions here */
      switch (itu_isup_variant) {
        case ISUP_ITU_STANDARD_VARIANT:
          bufferlength = tvb_reported_length_remaining(message_tvb, offset);
          if (bufferlength != 0)
            expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
          break;
        case ISUP_FRENCH_VARIANT:
          switch (message_type) {
            case FRENCH_CHARGING_PULSE:
              offset += dissect_french_isup_charging_pulse_message(parameter_tvb, isup_tree);
              opt_part_possible = true;
              break;
            case FRENCH_CHARGING_ACK:
              opt_part_possible = true;
              break;
            default:
              bufferlength = tvb_reported_length_remaining(message_tvb, offset);
              if (bufferlength != 0)
                expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
              break;
          }
          break;
        case ISUP_ISRAELI_VARIANT:
          switch (message_type) {
            case ISRAELI_BACKWARD_CHARGING:
              offset += dissect_israeli_backward_charging_message(parameter_tvb, isup_tree);
              break;
            case ISRAELI_TRAFFIC_CHANGE:
              offset += dissect_israeli_traffic_change_message(parameter_tvb, isup_tree);
              break;
            case ISRAELI_CHARGE_ACK:
              /* No parameters */
              break;
            default:
              bufferlength = tvb_reported_length_remaining(message_tvb, offset);
              if (bufferlength != 0)
                expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
              break;
          }
          break;
        case ISUP_RUSSIAN_VARIANT:
          switch (message_type) {
            case RUSSIAN_CLEAR_CALLING_LINE:
              /* no dissector necessary since no mandatory parameters included */
              break;
            case RUSSIAN_RINGING:
              /* no dissector necessary since no mandatory parameters included */
              opt_part_possible = true;
              break;
            default:
              bufferlength = tvb_reported_length_remaining(message_tvb, offset);
              if (bufferlength != 0)
                expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
              break;
          }
          break;
        case ISUP_JAPAN_VARIANT:
        /* Fall through */
        case ISUP_JAPAN_TTC_VARIANT:
          switch (message_type) {
            case MESSAGE_TYPE_JAPAN_CHARG_INF:
              offset += dissect_japan_chg_inf(parameter_tvb, pinfo, isup_tree);
              opt_part_possible = true;
              break;
            default:
              bufferlength = tvb_reported_length_remaining(message_tvb, offset);
              if (bufferlength != 0)
                expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
              break;
          }
          break;
      } /* switch (itu_isup_variant) */
      break;
  }

  /* extract pointer to start of optional part (if any) */
  if (opt_part_possible == true) {
    opt_parameter_pointer = tvb_get_uint8(message_tvb, offset);
    if (opt_parameter_pointer > 0) {
      proto_tree_add_uint_format(isup_tree, hf_isup_pointer_to_start_of_optional_part, message_tvb, offset,
                                 PARAMETER_POINTER_LENGTH, opt_parameter_pointer,
                                 "Pointer to start of optional part: %u", opt_parameter_pointer);
      offset += opt_parameter_pointer;
      optional_parameter_tvb = tvb_new_subset_remaining(message_tvb, offset);
      dissect_isup_optional_parameter(optional_parameter_tvb, pinfo, isup_tree, itu_isup_variant);
    }
    else
      proto_tree_add_uint_format(isup_tree, hf_isup_pointer_to_start_of_optional_part, message_tvb, offset,
                                 PARAMETER_POINTER_LENGTH, opt_parameter_pointer,
                                 "No optional parameter present (Pointer: %u)", opt_parameter_pointer);
  }
  else if (message_type != MESSAGE_TYPE_CHARGE_INFO)
    expert_add_info(pinfo, type_item, &ei_isup_message_type_no_optional_parameters);

  /* if there are calling/called number, we'll get them for the tap */
  tap_rec->calling_number = tap_calling_number ? tap_calling_number : wmem_strdup(pinfo->pool, "");
  tap_rec->called_number  = tap_called_number;
  tap_rec->cause_value    = tap_cause_value;
  tap_queue_packet(isup_tap, pinfo, tap_rec);

  decrement_dissection_depth(pinfo);
}
// NOLINTEND(misc-no-recursion)

/* ------------------------------------------------------------------ */
static int
dissect_isup(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{

/* Set up structures needed to add the protocol subtree and manage it */
  proto_item       *ti;
  proto_tree       *isup_tree = NULL;
  tvbuff_t         *message_tvb;
  uint16_t          cic;
  uint8_t           message_type;
  uint8_t           itu_isup_variant = g_isup_variant;
  value_string_ext *used_value_string_ext;

/* Make entries in Protocol column and Info column on summary display */
/* dissect CIC in main dissector since pass-along message type carrying complete IUSP message w/o CIC needs
 *    recursive message dissector call
 */
/* Extract message type field */
  message_type = tvb_get_uint8(tvb, CIC_OFFSET + CIC_LENGTH);

  switch (mtp3_standard) {
    case ANSI_STANDARD:
      isup_standard = ANSI_STANDARD;
      col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(ANSI)");
      cic = tvb_get_letohs(tvb, CIC_OFFSET) & 0x3FFF; /*since upper 2 bits spare */
      if (isup_show_cic_in_info) {
        col_add_fstr(pinfo->cinfo, COL_INFO,
                     "%s (CIC %u) ",
                     val_to_str_ext_const(message_type, &ansi_isup_message_type_value_acro_ext, "reserved"),
                     cic);
      } else {
        col_add_fstr(pinfo->cinfo, COL_INFO, "%s ",
                     val_to_str_ext_const(message_type, &ansi_isup_message_type_value_acro_ext, "reserved"));
      }
      if (tree) {
        ti = proto_tree_add_item(tree, proto_isup, tvb, 0, -1, ENC_NA);
        isup_tree = proto_item_add_subtree(ti, ett_isup);
        proto_tree_add_uint(isup_tree, hf_isup_cic, tvb, CIC_OFFSET, CIC_LENGTH, cic);
      }
      conversation_set_elements_by_id(pinfo, CONVERSATION_ISUP, cic);
      message_tvb = tvb_new_subset_remaining(tvb, CIC_LENGTH);
      dissect_ansi_isup_message(message_tvb, pinfo, isup_tree, ISUP_ITU_STANDARD_VARIANT, cic);
      break;
    default:
      isup_standard = ITU_STANDARD;
      /* ITU, China, and Japan; yes, J7's CICs are a different size */
      cic = tvb_get_letohs(tvb, CIC_OFFSET) & 0x0FFF; /*since upper 4 bits spare */
      switch (itu_isup_variant) {
        case ISUP_FRENCH_VARIANT:
          col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(French)");
          used_value_string_ext = &french_isup_message_type_value_acro_ext;
          break;
        case ISUP_ISRAELI_VARIANT:
          col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(Israeli)");
          used_value_string_ext = &israeli_isup_message_type_value_acro_ext;
          break;
        case ISUP_RUSSIAN_VARIANT:
          col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(Russian)");
          used_value_string_ext = &russian_isup_message_type_value_acro_ext;
          break;
        case ISUP_JAPAN_VARIANT:
          col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(Japan)");
          used_value_string_ext = &japan_isup_message_type_value_acro_ext;
          break;
        case ISUP_JAPAN_TTC_VARIANT:
          col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(Japan TTC)");
          used_value_string_ext = &japan_isup_message_type_value_acro_ext;
          cic = tvb_get_letohs(tvb, CIC_OFFSET) & 0x1FFF; /*since upper 3 bits spare */
          break;
        default:
          col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(ITU)");
          used_value_string_ext = &isup_message_type_value_acro_ext;
          break;
      }
      if (isup_show_cic_in_info) {
        col_add_fstr(pinfo->cinfo, COL_INFO,
                     "%s (CIC %u) ",
                     val_to_str_ext_const(message_type, used_value_string_ext, "reserved"),
                     cic);
      } else {
        col_add_fstr(pinfo->cinfo, COL_INFO, "%s ",
                     val_to_str_ext_const(message_type, used_value_string_ext, "reserved"));
      }
      if (tree) {
        ti = proto_tree_add_item(tree, proto_isup, tvb, 0, -1, ENC_NA);
        isup_tree = proto_item_add_subtree(ti, ett_isup);
        proto_tree_add_uint(isup_tree, hf_isup_cic, tvb, CIC_OFFSET, CIC_LENGTH, cic);
      }
      conversation_set_elements_by_id(pinfo, CONVERSATION_ISUP, cic);
      message_tvb = tvb_new_subset_remaining(tvb, CIC_LENGTH);
      dissect_isup_message(message_tvb, pinfo, isup_tree, itu_isup_variant, cic);
  }
  return tvb_captured_length(tvb);
}

/* ------------------------------------------------------------------ */
static int
dissect_bicc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{

/* Set up structures needed to add the protocol subtree and manage it */
  proto_item       *ti;
  proto_tree       *bicc_tree = NULL;
  tvbuff_t         *message_tvb;
  uint32_t          bicc_cic;
  uint8_t           message_type;
  uint8_t           itu_isup_variant = g_isup_variant;
  value_string_ext *used_value_string_ext;

  /*circuit_t *circuit;*/

/* Make entries in Protocol column and Info column on summary display */
  switch (itu_isup_variant) {
    case ISUP_FRENCH_VARIANT:
      col_set_str(pinfo->cinfo, COL_PROTOCOL, "BICC(French)");
      used_value_string_ext = &french_isup_message_type_value_acro_ext;
      break;
    case ISUP_ISRAELI_VARIANT:
      col_set_str(pinfo->cinfo, COL_PROTOCOL, "BICC(Israeli)");
      used_value_string_ext = &israeli_isup_message_type_value_acro_ext;
      break;
    case ISUP_RUSSIAN_VARIANT:
      col_set_str(pinfo->cinfo, COL_PROTOCOL, "BICC(Russian)");
      used_value_string_ext = &russian_isup_message_type_value_acro_ext;
      break;
    case ISUP_JAPAN_VARIANT:
    /* Fall through */
    case ISUP_JAPAN_TTC_VARIANT:
      col_set_str(pinfo->cinfo, COL_PROTOCOL, "BICC(Japan)");
      used_value_string_ext = &japan_isup_message_type_value_acro_ext;
      break;
    default:
      col_set_str(pinfo->cinfo, COL_PROTOCOL, "BICC(ITU)");
      used_value_string_ext = &isup_message_type_value_acro_ext;
      break;
  }

/* Extract message type field */
  message_type = tvb_get_uint8(tvb, BICC_CIC_OFFSET + BICC_CIC_LENGTH);

  bicc_cic = tvb_get_letohl(tvb, BICC_CIC_OFFSET);

  conversation_set_elements_by_id(pinfo, CONVERSATION_BICC, bicc_cic);

  col_clear(pinfo->cinfo, COL_INFO);
  if (isup_show_cic_in_info) {
    col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
                        "%s (CIC %u)",
                        val_to_str_ext_const(message_type, used_value_string_ext, "reserved"),
                        bicc_cic);
  } else {
    col_append_sep_str(pinfo->cinfo, COL_INFO, ", ",
                        val_to_str_ext_const(message_type, used_value_string_ext, "reserved"));
  }
  /* dissect CIC in main dissector since pass-along message type carrying complete BICC/ISUP message w/o CIC needs
   * recursive message dissector call
   */
  if (tree) {
    ti = proto_tree_add_item(tree, proto_bicc, tvb, 0, -1, ENC_NA);
    bicc_tree = proto_item_add_subtree(ti, ett_bicc);


    proto_tree_add_uint_format(bicc_tree, hf_bicc_cic, tvb, BICC_CIC_OFFSET, BICC_CIC_LENGTH,
                               bicc_cic, "CIC: %u", bicc_cic);
  }

  message_tvb = tvb_new_subset_remaining(tvb, BICC_CIC_LENGTH);
  dissect_isup_message(message_tvb, pinfo, bicc_tree, itu_isup_variant, bicc_cic);
  col_set_fence(pinfo->cinfo, COL_INFO);
  return tvb_captured_length(tvb);
}

static int
dissect_application_isup(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)
{
/* Set up structures needed to add the protocol subtree and manage it */
  proto_item *ti;
  proto_tree *isup_tree = NULL;
  tvbuff_t   *message_tvb;
  uint8_t     message_type;
  char       *version, *base;
  uint8_t     itu_isup_variant = ISUP_ITU_STANDARD_VARIANT; /* Default */

  if (data) {
    media_content_info_t *content_info = (media_content_info_t *)data;
    if (content_info->media_str) {
      version = ws_find_media_type_parameter(pinfo->pool, content_info->media_str, "version");
      base = ws_find_media_type_parameter(pinfo->pool, content_info->media_str, "base");
      if ((version && g_ascii_strncasecmp(version, "ansi", 4) == 0) ||
          (base && g_ascii_strncasecmp(base, "ansi", 4) == 0) ||
          (version && g_ascii_strncasecmp(version, "gr", 2) == 0) ||
          (base && g_ascii_strncasecmp(base, "gr", 2) == 0)) {
        /*
         * "version" or "base" parameter begins with "ansi" or "gr", so it's
         * ANSI or Bellcore.
         */
        isup_standard = ANSI_STANDARD;
        col_append_str(pinfo->cinfo, COL_PROTOCOL, "/ISUP(ANSI)");
        message_type = tvb_get_uint8(tvb, 0);
        /* application/ISUP has no  CIC  */
        col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
                            "ISUP:%s",
                            val_to_str_ext_const(message_type, &ansi_isup_message_type_value_acro_ext, "reserved"));
        if (tree) {
          ti = proto_tree_add_item(tree, proto_isup, tvb, 0, -1, ENC_NA);
          isup_tree = proto_item_add_subtree(ti, ett_isup);
        }

        message_tvb = tvb_new_subset_remaining(tvb, 0);
        dissect_ansi_isup_message(message_tvb, pinfo, isup_tree, ISUP_ITU_STANDARD_VARIANT, 0);
        return tvb_reported_length(tvb);
      } else if ((version && g_ascii_strcasecmp(version, "spirou") == 0) ||
          (base && g_ascii_strcasecmp(base, "spirou") == 0)) {
        /*
         * "version" or "base" version is "spirou", so it's SPIROU.
         */
        isup_standard    = ITU_STANDARD;
        itu_isup_variant = ISUP_FRENCH_VARIANT;
      } else {
        isup_standard = ITU_STANDARD;
      }
    } else {
      /* default to ITU */
      isup_standard = ITU_STANDARD;
    }
  } else {
    /* default to ITU */
    isup_standard = ITU_STANDARD;
  }


  /* Extract message type field */
  message_type = tvb_get_uint8(tvb, 0);

  switch (itu_isup_variant) {
    case ISUP_ITU_STANDARD_VARIANT:
      /* Make entries in Protocol column and Info column on summary display */
      col_append_str(pinfo->cinfo, COL_PROTOCOL, "/ISUP(ITU)");

      /* application/ISUP has no  CIC  */
      col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
                          "ISUP:%s",
                          val_to_str_ext_const(message_type, &isup_message_type_value_acro_ext, "reserved"));
      break;
    case ISUP_FRENCH_VARIANT:
      /* Make entries in Protocol column and Info column on summary display */
      col_append_str(pinfo->cinfo, COL_PROTOCOL, "/ISUP(French)");

      /* application/ISUP has no  CIC  */
      col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
                          "ISUP:%s",
                          val_to_str_ext_const(message_type, &french_isup_message_type_value_acro_ext, "reserved"));
      break;
#if 0
      /* This case can't happen unless/until we can parse the Israeli variant
       * out of the content type
       */
    case ISUP_ISRAELI_VARIANT:
      /* Make entries in Protocol column and Info column on summary display */
      col_append_str(pinfo->cinfo, COL_PROTOCOL, "/ISUP(Israeli)");

      /* application/ISUP has no  CIC  */
      col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
                          "ISUP:%s",
                          val_to_str_ext_const(message_type, &israeli_isup_message_type_value_acro_ext, "reserved"));
      break;
#endif
    default:
      col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
                          "ISUP: Unknown variant %d", itu_isup_variant);
      break;
  }

  if (tree) {
    ti = proto_tree_add_item(tree, proto_isup, tvb, 0, -1, ENC_NA);
    isup_tree = proto_item_add_subtree(ti, ett_isup);
  }

  message_tvb = tvb_new_subset_remaining(tvb, 0);
  dissect_isup_message(message_tvb, pinfo, isup_tree, itu_isup_variant, 0);
  return tvb_reported_length(tvb);
}
/* ---------------------------------------------------- stats tree
*/
static int st_node_msg = -1;
static int st_node_dir = -1;

static void
msg_stats_tree_init(stats_tree *st)
{
  st_node_msg = stats_tree_create_node(st, "Messages by Type", 0, STAT_DT_INT, true);
  st_node_dir = stats_tree_create_node(st, "Messages by Direction", 0, STAT_DT_INT, true);
}

static tap_packet_status
msg_stats_tree_packet(stats_tree *st, packet_info *pinfo, epan_dissect_t *edt _U_, const void *p, tap_flags_t flags _U_)
{
  const isup_tap_rec_t *tap_rec = (const isup_tap_rec_t *)p;
  const char *msg;
  char        *src, *dst, *dir;
  int          msg_node;
  int          dir_node;
  value_string_ext *used_value_string_ext;

  switch (tap_rec->itu_isup_variant) {
    case ISUP_FRENCH_VARIANT:
      used_value_string_ext = &french_isup_message_type_value_acro_ext;
      break;
    case ISUP_ISRAELI_VARIANT:
      used_value_string_ext = &israeli_isup_message_type_value_acro_ext;
      break;
    case ISUP_RUSSIAN_VARIANT:
      used_value_string_ext = &russian_isup_message_type_value_acro_ext;
      break;
    case ISUP_JAPAN_VARIANT:
    case ISUP_JAPAN_TTC_VARIANT:
      used_value_string_ext = &japan_isup_message_type_value_acro_ext;
      break;
    default:
      used_value_string_ext = &isup_message_type_value_acro_ext;
      break;
  }
  msg = val_to_str_ext_const(tap_rec->message_type, used_value_string_ext, "reserved");

  src = address_to_str(NULL, &pinfo->src);
  dst = address_to_str(NULL, &pinfo->dst);
  dir = wmem_strdup_printf(NULL, "%s->%s", src, dst);
  wmem_free(NULL, src);
  wmem_free(NULL, dst);

  msg_node = tick_stat_node(st, msg, st_node_msg, true);
  tick_stat_node(st, dir, msg_node, false);

  dir_node = tick_stat_node(st, dir, st_node_dir, true);
  tick_stat_node(st, msg, dir_node, false);

  wmem_free(NULL, dir);

  return TAP_PACKET_REDRAW;
}

/*---------------------------------------------------------------------*/
/* Register the protocol with Wireshark */
void
proto_register_isup(void)
{
/* Setup list of header fields  See Section 1.6.1 for details*/
  static hf_register_info hf[] = {
    { &hf_isup_cic,
      { "CIC",           "isup.cic",
        FT_UINT16, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_message_type,
      { "Message Type",  "isup.message_type",
        FT_UINT8, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_parameter_type,
      { "Parameter Type",  "isup.parameter_type",
        FT_UINT8, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_parameter_value,
      { "Parameter Value",  "isup.parameter_value",
        FT_BYTES, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_mand_parameter_type,
      { "Mandatory Parameter",  "isup.parameter_type",
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &isup_parameter_type_value_ext, 0x0,
        NULL, HFILL }},

    { &hf_isup_opt_parameter_type,
      { "Optional Parameter",  "isup.parameter_type",
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &ansi_isup_parameter_type_value_ext, 0x0,
        NULL, HFILL }},

    { &hf_isup_parameter_length,
      { "Parameter Length",  "isup.parameter_length",
        FT_UINT8, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_mandatory_variable_parameter_pointer,
      { "Pointer to Parameter",  "isup.mandatory_variable_parameter_pointer",
        FT_UINT8, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_pointer_to_start_of_optional_part,
      { "Pointer to optional parameter part",  "isup.optional_parameter_part_pointer",
        FT_UINT8, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_satellite_indicator,
      { "Satellite Indicator",  "isup.satellite_indicator",
        FT_UINT8, BASE_HEX, VALS(isup_satellite_ind_value), BA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_continuity_check_indicator,
      { "Continuity Check Indicator",  "isup.continuity_check_indicator",
        FT_UINT8, BASE_HEX, VALS(isup_continuity_check_ind_value), DC_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_echo_control_device_indicator,
      { "Echo Control Device Indicator",  "isup.echo_control_device_indicator",
        FT_BOOLEAN, 8, TFS(&isup_echo_control_device_ind_value), E_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_forw_call_natnl_inatnl_call_indicator,
      { "National/international call indicator",  "isup.forw_call_natnl_inatnl_call_indicator",
        FT_BOOLEAN, 16, TFS(&isup_natnl_inatnl_call_ind_value), A_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_forw_call_end_to_end_method_indicator,
      { "End-to-end method indicator",  "isup.forw_call_end_to_end_method_indicator",
        FT_UINT16, BASE_HEX, VALS(isup_end_to_end_method_ind_value), CB_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_forw_call_interworking_indicator,
      { "Interworking indicator",  "isup.forw_call_interworking_indicator",
        FT_BOOLEAN, 16, TFS(&isup_interworking_ind_value), D_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_forw_call_end_to_end_info_indicator,
      { "End-to-end information indicator",  "isup.forw_call_end_to_end_information_indicator",
        FT_BOOLEAN, 16, TFS(&isup_end_to_end_info_ind_value), E_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_forw_call_isdn_user_part_indicator,
      { "ISDN user part indicator",  "isup.forw_call_isdn_user_part_indicator",
        FT_BOOLEAN, 16, TFS(&isup_ISDN_user_part_ind_value), F_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_forw_call_preferences_indicator,
      { "ISDN user part preference indicator",  "isup.forw_call_preferences_indicator",
        FT_UINT16, BASE_HEX, VALS(isup_preferences_ind_value), HG_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_forw_call_isdn_access_indicator,
      { "ISDN access indicator",  "isup.forw_call_isdn_access_indicator",
        FT_BOOLEAN, 16, TFS(&isup_ISDN_originating_access_ind_value), I_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_forw_call_sccp_method_indicator,
      { "SCCP method indicator",  "isup.forw_call_sccp_method_indicator",
        FT_UINT16, BASE_HEX, VALS(isup_SCCP_method_ind_value), KJ_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_forw_call_ported_num_trans_indicator,
      { "Ported number translation indicator",  "isup.forw_call_ported_num_trans_indicator",
        FT_BOOLEAN, 16, TFS(&isup_ISDN_ported_num_trans_ind_value), M_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_forw_call_qor_attempt_indicator,
      { "Query on Release attempt indicator",  "isup.forw_call_qor_attempt_indicator",
        FT_BOOLEAN, 16, TFS(&isup_ISDN_qor_attempt_ind_value), N_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_calling_partys_category,
      { "Calling Party's category",  "isup.calling_partys_category",
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &isup_calling_partys_category_value_ext, 0x0,
        NULL, HFILL }},

    { &hf_russian_isup_calling_partys_category,
      { "Calling Party's category",  "isup.russian.calling_partys_category",
        FT_UINT8, BASE_HEX, VALS(isup_calling_partys_category_value), 0x0,
        NULL, HFILL }},

    { &hf_isup_transmission_medium_requirement,
      { "Transmission medium requirement",  "isup.transmission_medium_requirement",
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &isup_transmission_medium_requirement_value_ext, 0x0,
        NULL, HFILL }},

    { &hf_isup_odd_even_indicator,
      { "Odd/even indicator",  "isup.isdn_odd_even_indicator",
        FT_BOOLEAN, 8, TFS(&isup_odd_even_ind_value), ISUP_ODD_EVEN_MASK,
        NULL, HFILL }},

    { &hf_isup_generic_name_presentation,
      { "Presentation indicator",  "isup.isdn_generic_name_presentation",
        FT_UINT8, BASE_DEC, VALS(isup_generic_name_presentation_value), BA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_generic_name_availability,
      { "Availability indicator",  "isup.isdn_generic_name_availability",
        FT_BOOLEAN, 8, TFS(&isup_generic_name_availability_value), E_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_generic_name_type,
      { "Type indicator",  "isup.isdn_generic_name_type",
        FT_UINT8, BASE_DEC, VALS(isup_generic_name_type_value), HGF_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_generic_name_ia5,
      { "Generic Name",  "isup.isdn_generic_name_ia5",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_called_party_nature_of_address_indicator,
      { "Nature of address indicator",  "isup.called_party_nature_of_address_indicator",
        FT_UINT8, BASE_DEC, VALS(isup_called_party_nature_of_address_ind_value), ISUP_NATURE_OF_ADDRESS_IND_MASK,
        NULL, HFILL }},

    { &hf_isup_calling_party_nature_of_address_indicator,
      { "Nature of address indicator",  "isup.calling_party_nature_of_address_indicator",
        FT_UINT8, BASE_DEC, VALS(isup_calling_party_nature_of_address_ind_value), ISUP_NATURE_OF_ADDRESS_IND_MASK,
        NULL, HFILL }},

    { &hf_isup_charge_number_nature_of_address_indicator,
      { "Nature of address indicator",  "isup.charge_number_nature_of_address_indicator",
        FT_UINT8, BASE_DEC, VALS(isup_charge_number_nature_of_address_ind_value), ISUP_NATURE_OF_ADDRESS_IND_MASK,
        NULL, HFILL }},

    { &hf_isup_inn_indicator,
      { "INN indicator",  "isup.inn_indicator",
        FT_BOOLEAN, 8, TFS(&isup_INN_ind_value), ISUP_INN_MASK,
        NULL, HFILL }},

    { &hf_isup_ni_indicator,
      { "NI indicator",  "isup.ni_indicator",
        FT_BOOLEAN, 8, TFS(&isup_NI_ind_value), ISUP_NI_MASK,
        NULL, HFILL }},

    { &hf_isup_numbering_plan_indicator,
      { "Numbering plan indicator",  "isup.numbering_plan_indicator",
        FT_UINT8, BASE_DEC, VALS(isup_numbering_plan_ind_value), ISUP_NUMBERING_PLAN_IND_MASK,
        NULL, HFILL }},

    { &hf_isup_address_presentation_restricted_indicator,
      { "Address presentation restricted indicator",  "isup.address_presentation_restricted_indicator",
        FT_UINT8, BASE_DEC, VALS(isup_address_presentation_restricted_ind_value), ISUP_ADDRESS_PRESENTATION_RESTR_IND_MASK,
        NULL, HFILL }},

    { &hf_isup_number_different_meaning,
      { "Different meaning for number",  "isup.number_different_meaning",
        FT_UINT8, BASE_HEX, NULL, 0,
        NULL, HFILL }},

    { &hf_isup_screening_indicator,
      { "Screening indicator",  "isup.screening_indicator",
        FT_UINT8, BASE_DEC, VALS(isup_screening_ind_value), ISUP_SCREENING_IND_MASK,
        NULL, HFILL }},

    { &hf_isup_screening_indicator_enhanced,
      { "Screening indicator",  "isup.screening_indicator_enhanced",
        FT_UINT8, BASE_DEC, VALS(isup_screening_ind_enhanced_value), ISUP_SCREENING_IND_MASK,
        NULL, HFILL }},

    { &hf_isup_called_party_odd_address_signal_digit,
      { "Address signal digit",  "isup.called_party_odd_address_signal_digit",
        FT_UINT8, BASE_DEC | BASE_EXT_STRING, &isup_called_party_address_digit_value_ext, ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK,
        NULL, HFILL }},

    { &hf_isup_calling_party_odd_address_signal_digit,
      { "Address signal digit",  "isup.calling_party_odd_address_signal_digit",
        FT_UINT8, BASE_DEC | BASE_EXT_STRING, &isup_calling_party_address_digit_value_ext, ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK,
        NULL, HFILL }},

    { &hf_isup_called_party_even_address_signal_digit,
      { "Address signal digit",  "isup.called_party_even_address_signal_digit",
        FT_UINT8, BASE_DEC | BASE_EXT_STRING, &isup_called_party_address_digit_value_ext, ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK,
        NULL, HFILL }},

    { &hf_isup_calling_party_even_address_signal_digit,
      { "Address signal digit",  "isup.calling_party_even_address_signal_digit",
        FT_UINT8, BASE_DEC | BASE_EXT_STRING, &isup_calling_party_address_digit_value_ext, ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK,
        NULL, HFILL }},

    { &hf_isup_calling_party_address_request_indicator,
      { "Calling party address request indicator",  "isup.calling_party_address_request_indicator",
        FT_BOOLEAN, 16, TFS(&isup_calling_party_address_request_ind_value), A_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_info_req_holding_indicator,
      { "Holding indicator",  "isup.info_req_holding_indicator",
        FT_BOOLEAN, 16, TFS(&isup_holding_ind_value), B_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_calling_partys_category_request_indicator,
      { "Calling party's category request indicator",  "isup.calling_partys_category_request_indicator",
        FT_BOOLEAN, 16, TFS(&isup_calling_partys_category_request_ind_value), D_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_charge_information_request_indicator,
      { "Charge information request indicator",  "isup.charge_information_request_indicator",
        FT_BOOLEAN, 16, TFS(&isup_charge_information_request_ind_value), E_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_malicious_call_identification_request_indicator,
      { "Malicious call identification request indicator (ISUP'88)",  "isup.malicious_call_ident_request_indicator",
        FT_BOOLEAN, 16, TFS(&isup_malicious_call_identification_request_ind_value), H_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_calling_party_address_response_indicator,
      { "Calling party address response indicator",  "isup.calling_party_address_response_indicator",
        FT_UINT16, BASE_HEX, VALS(isup_calling_party_address_response_ind_value), BA_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_OECD_inf_ind,
      { "OECD information indicator",  "isup.OECD_inf_ind_vals",
        FT_UINT8, BASE_HEX, VALS(OECD_inf_ind_vals), BA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_IECD_inf_ind,
      { "IECD information indicator",  "isup.IECD_inf_ind_vals",
        FT_UINT8, BASE_HEX, VALS(IECD_inf_ind_vals), DC_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_OECD_req_ind,
      { "OECD request indicator",  "isup.OECD_req_ind_vals",
        FT_UINT8, BASE_HEX, VALS(OECD_req_ind_vals), FE_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_IECD_req_ind,
      { "IECD request indicator",  "isup.IECD_req_ind_vals",
        FT_UINT8, BASE_HEX, VALS(IECD_req_ind_vals), HG_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_hold_provided_indicator,
      { "Hold provided indicator",  "isup.hold_provided_indicator",
        FT_BOOLEAN, 16, TFS(&isup_hold_provided_ind_value), C_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_calling_partys_category_response_indicator,
      { "Calling party's category response indicator",  "isup.calling_partys_category_response_indicator",
        FT_BOOLEAN, 16, TFS(&isup_calling_partys_category_response_ind_value), F_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_charge_information_response_indicator,
      { "Charge information response indicator",  "isup.charge_information_response_indicator",
        FT_BOOLEAN, 16, TFS(&isup_charge_information_response_ind_value), G_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_solicited_indicator,
      { "Solicited indicator",  "isup.solicited_indicator",
        FT_BOOLEAN, 16, TFS(&isup_solicited_information_ind_value), H_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_continuity_indicator,
      { "Continuity indicator",  "isup.continuity_indicator",
        FT_BOOLEAN, 8, TFS(&isup_continuity_ind_value), A_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_backw_call_charge_ind,
      { "Charge indicator",  "isup.charge_indicator",
        FT_UINT16, BASE_HEX, VALS(isup_charge_ind_value), BA_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_backw_call_called_partys_status_ind,
      { "Called party's status indicator",  "isup.called_partys_status_indicator",
        FT_UINT16, BASE_HEX, VALS(isup_called_partys_status_ind_value), DC_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_backw_call_called_partys_category_ind,
      { "Called party's category indicator",  "isup.called_partys_category_indicator",
        FT_UINT16, BASE_HEX, VALS(isup_called_partys_category_ind_value), FE_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_backw_call_end_to_end_method_ind,
      { "End-to-end method indicator",  "isup.backw_call_end_to_end_method_indicator",
        FT_UINT16, BASE_HEX, VALS(isup_end_to_end_method_ind_value), HG_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_backw_call_interworking_ind,
      { "Interworking indicator",  "isup.backw_call_interworking_indicator",
        FT_BOOLEAN, 16, TFS(&isup_interworking_ind_value), I_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_backw_call_end_to_end_info_ind,
      { "End-to-end information indicator",  "isup.backw_call_end_to_end_information_indicator",
        FT_BOOLEAN, 16, TFS(&isup_end_to_end_info_ind_value), J_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_backw_call_iam_seg_ind,
      { "IAM segmentation indicator",  "isup.backw_call_iam_seg_ind",
        FT_BOOLEAN, 16, TFS(&ansi_isup_iam_seg_ind_value), J_16BIT_MASK,
        NULL, HFILL } },

    { &hf_isup_backw_call_isdn_user_part_ind,
      { "ISDN user part indicator",  "isup.backw_call_isdn_user_part_indicator",
        FT_BOOLEAN, 16, TFS(&isup_ISDN_user_part_ind_value), K_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_backw_call_holding_ind,
      { "Holding indicator",  "isup.backw_call_holding_indicator",
        FT_BOOLEAN, 16, TFS(&isup_holding_ind_value), L_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_backw_call_isdn_access_ind,
      { "ISDN access indicator",  "isup.backw_call_isdn_access_indicator",
        FT_BOOLEAN, 16, TFS(&isup_ISDN_terminating_access_ind_value), M_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_backw_call_echo_control_device_ind,
      { "Echo Control Device Indicator",  "isup.backw_call_echo_control_device_indicator",
        FT_BOOLEAN, 16, TFS(&isup_echo_control_device_ind_value), N_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_backw_call_sccp_method_ind,
      { "SCCP method indicator",  "isup.backw_call_sccp_method_indicator",
        FT_UINT16, BASE_HEX, VALS(isup_SCCP_method_ind_value), PO_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_cause_indicator,
      { "Cause indicator",  "isup.cause_indicator",
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &q850_cause_code_vals_ext, 0x7f,
        NULL, HFILL }},

    { &hf_ansi_isup_cause_indicator,
      { "Cause indicator",  "ansi_isup.cause_indicator",
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &ansi_isup_cause_code_vals_ext, 0x7f,
        NULL, HFILL }},

    { &hf_isup_suspend_resume_indicator,
      { "Suspend/Resume indicator",  "isup.suspend_resume_indicator",
        FT_BOOLEAN, 8, TFS(&isup_suspend_resume_ind_value), A_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_range_indicator,
      { "Range indicator",  "isup.range_indicator",
        FT_UINT8, BASE_DEC, NULL , 0x0,
        NULL, HFILL }},

    { &hf_isup_bitbucket,
      { "Bit",  "isup.bitbucket",
        FT_UINT8, BASE_DEC, NULL , 0x0,
        NULL, HFILL }},

    { &hf_isup_cgs_message_type,
      { "Circuit group supervision message type",  "isup.cgs_message_type",
        FT_UINT8, BASE_DEC, VALS(isup_cgs_message_type_value), BA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_mtc_blocking_state1,
      { "Maintenance blocking state",  "isup.mtc_blocking_state",
        FT_UINT8, BASE_DEC, VALS(isup_mtc_blocking_state_DC00_value), BA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_mtc_blocking_state2,
      { "Maintenance blocking state",  "isup.mtc_blocking_state",
        FT_UINT8, BASE_DEC, VALS(isup_mtc_blocking_state_DCnot00_value), BA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_call_proc_state,
      { "Call processing state",  "isup.call_processing_state",
        FT_UINT8, BASE_DEC, VALS(isup_call_processing_state_value), DC_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_hw_blocking_state,
      { "HW blocking state",  "isup.hw_blocking_state",
        FT_UINT8, BASE_DEC, VALS(isup_HW_blocking_state_value), FE_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_event_ind,
      { "Event indicator",  "isup.event_ind",
        FT_UINT8, BASE_DEC, VALS(isup_event_ind_value), GFEDCBA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_event_presentation_restricted_ind,
      { "Event presentation restricted indicator",  "isup.event_presentation_restr_ind",
        FT_BOOLEAN, 8, TFS(&isup_event_presentation_restricted_ind_value), H_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_cug_call_ind,
      { "Closed user group call indicator",  "isup.clg_call_ind",
        FT_UINT8, BASE_DEC, VALS(isup_CUG_call_ind_value), BA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_simple_segmentation_ind,
      { "Simple segmentation indicator",  "isup.simple_segmentation_ind",
        FT_BOOLEAN, 8, TFS(&isup_simple_segmentation_ind_value), C_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_connected_line_identity_request_ind,
      { "Connected line identity request indicator",  "isup.connected_line_identity_request_ind",
        FT_BOOLEAN, 8, TFS(&tfs_requested_not_requested), H_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_redirecting_ind,
      { "Redirection indicator",  "isup.redirecting_ind",
        FT_UINT16, BASE_DEC, VALS(isup_redirecting_ind_value), CBA_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_original_redirection_reason,
      { "Original redirection reason",  "isup.original_redirection_reason",
        FT_UINT16, BASE_DEC, VALS(isup_original_redirection_reason_value), HGFE_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_redirection_counter,
      { "Redirection counter",  "isup.redirection_counter",
        FT_UINT16, BASE_DEC, NULL, KJI_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_redirection_reason,
      { "Redirection reason",  "isup.redirection_reason",
        FT_UINT16, BASE_DEC, VALS(isup_redirection_reason_value), PONM_16BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_type_of_network_identification,
      { "Type of network identification",  "isup.type_of_network_identification",
        FT_UINT8, BASE_DEC, VALS(isup_type_of_network_identification_value), GFE_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_network_identification_plan,
      { "Network identification plan",  "isup.network_identification_plan",
        FT_UINT8, BASE_DEC, VALS(isup_network_identification_plan_value), DCBA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_map_type,
      { "Map Type",  "isup.map_type",
        FT_UINT8, BASE_DEC, VALS(isup_map_type_value), FEDCBA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_automatic_congestion_level,
      { "Automatic congestion level",  "isup.automatic_congestion_level",
        FT_UINT8, BASE_DEC, VALS(isup_auto_congestion_level_value), 0x0,
        NULL, HFILL }},

    { &hf_isup_inband_information_ind,
      { "In-band information indicator",  "isup.inband_information_ind",
        FT_BOOLEAN, 8, TFS(&isup_inband_information_ind_value), A_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_call_diversion_may_occur_ind,
      { "Call diversion may occur indicator",  "isup.call_diversion_may_occur_ind",
        FT_BOOLEAN, 8, TFS(&isup_call_diversion_may_occur_ind_value), B_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_mlpp_user_ind,
      { "MLPP user indicator",  "isup.mlpp_user",
        FT_BOOLEAN, 8, TFS(&isup_MLPP_user_ind_value), D_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_UUI_type,
      { "User-to-User indicator type",  "isup.UUI_type",
        FT_BOOLEAN, 8, TFS(&tfs_response_request), A_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_UUI_req_service1,
      { "User-to-User indicator request service 1",  "isup.UUI_req_service1",
        FT_UINT8, BASE_DEC, VALS(isup_UUI_request_service_values), CB_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_UUI_req_service2,
      { "User-to-User indicator request service 2",  "isup.UUI_req_service2",
        FT_UINT8, BASE_DEC, VALS(isup_UUI_request_service_values), ED_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_UUI_req_service3,
      { "User-to-User indicator request service 3",  "isup.UUI_req_service3",
        FT_UINT8, BASE_DEC, VALS(isup_UUI_request_service_values), GF_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_UUI_res_service1,
      { "User-to-User indicator response service 1",  "isup.UUI_res_service1",
        FT_UINT8, BASE_DEC, VALS(isup_UUI_response_service_values), CB_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_UUI_res_service2,
      { "User-to-User indicator response service 2",  "isup.UUI_res_service2",
        FT_UINT8, BASE_DEC, VALS(isup_UUI_response_service_values), ED_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_UUI_res_service3,
      { "User-to-User response service 3",  "isup.UUI_res_service3",
        FT_UINT8, BASE_DEC, VALS(isup_UUI_response_service_values), GF_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_notification_indicator,
      { "Notification indicator",  "isup.notification_indicator",
        FT_UINT8, BASE_DEC | BASE_EXT_STRING, &q763_generic_notification_indicator_vals_ext, 0x7f,
        NULL, HFILL }},

    { &hf_isup_UUI_network_discard_ind,
      { "User-to-User indicator network discard indicator",  "isup.UUI_network_discard_ind",
        FT_BOOLEAN, 8, TFS(&isup_UUI_network_discard_ind_value), H_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_access_delivery_ind,
      { "Access delivery indicator",  "isup.access_delivery_ind",
        FT_BOOLEAN, 8, TFS(&isup_access_delivery_ind_value), A_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_transmission_medium_requirement_prime,
      { "Transmission medium requirement prime",  "isup.transmission_medium_requirement_prime",
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &isup_transmission_medium_requirement_prime_value_ext, 0x0,
        NULL, HFILL }},

    { &hf_isup_loop_prevention_response_ind,
      { "Response indicator",  "isup.loop_prevention_response_ind",
        FT_UINT8, BASE_DEC, VALS(isup_loop_prevention_response_ind_value), CB_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_temporary_alternative_routing_ind,
      { "Temporary alternative routing indicator",  "isup.temporary_alternative_routing_ind",
        FT_BOOLEAN, 8, TFS(&isup_temporary_alternative_routing_ind_value), A_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_extension_ind,
      { "Extension indicator",  "isup.extension_ind",
        FT_BOOLEAN, 8, TFS(&isup_extension_ind_value), H_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_call_to_be_diverted_ind,
      { "Call to be diverted indicator",  "isup.call_to_be_diverted_ind",
        FT_UINT8, BASE_DEC, VALS(isup_call_to_be_diverted_ind_value), BA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_call_to_be_offered_ind,
      { "Call to be offered indicator",  "isup.call_to_be_offered_ind",
        FT_UINT8, BASE_DEC, VALS(isup_call_to_be_offered_ind_value), BA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_conference_acceptance_ind,
      { "Conference acceptance indicator",  "isup.conference_acceptance_ind",
        FT_UINT8, BASE_DEC, VALS(isup_conference_acceptance_ind_value), BA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_transit_at_intermediate_exchange_ind,
      { "Transit at intermediate exchange indicator", "isup.transit_at_intermediate_exchange_ind",
        FT_BOOLEAN, 8, TFS(&isup_transit_at_intermediate_exchange_ind_value), A_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_Release_call_ind,
      { "Release call indicator", "isup.Release_call_ind",
        FT_BOOLEAN, 8, TFS(&isup_Release_call_indicator_value), B_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_Send_notification_ind,
      { "Send notification indicator", "isup.Send_notification_ind",
        FT_BOOLEAN, 8, TFS(&isup_Send_notification_ind_value), C_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_Discard_message_ind_value,
      { "Discard message indicator", "isup.Discard_message_ind_value",
        FT_BOOLEAN, 8, TFS(&isup_Discard_message_ind_value), D_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_Discard_parameter_ind,
      { "Discard parameter indicator", "isup.Discard_parameter_ind",
        FT_BOOLEAN, 8, TFS(&isup_Discard_parameter_ind_value), E_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_Pass_on_not_possible_indicator,
      { "Pass on not possible indicator",  "isup.Pass_on_not_possible_ind",
        FT_UINT8, BASE_HEX, VALS(isup_Pass_on_not_possible_indicator_vals), GF_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_pass_on_not_possible_indicator2,
      { "Pass on not possible indicator",  "isup.Pass_on_not_possible_val",
        FT_BOOLEAN, 8, TFS(&isup_pass_on_not_possible_indicator_value), E_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_Broadband_narrowband_interworking_ind,
      { "Broadband narrowband interworking indicator Bits JF",  "isup.broadband_narrowband_interworking_ind",
        FT_UINT8, BASE_HEX, VALS(ISUP_Broadband_narrowband_interworking_indicator_vals), BA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_Broadband_narrowband_interworking_ind2,
      { "Broadband narrowband interworking indicator Bits GF",  "isup.broadband_narrowband_interworking_ind2",
        FT_UINT8, BASE_HEX, VALS(ISUP_Broadband_narrowband_interworking_indicator_vals), GF_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_app_cont_ident,
      { "Application context identifier",  "isup.app_context_identifier",
        FT_UINT16, BASE_DEC, VALS(isup_application_transport_parameter_value), GFEDCBA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_app_Release_call_ind,
      { "Release call indicator (RCI)",  "isup.app_Release_call_indicator",
        FT_BOOLEAN, 8, TFS(&isup_Release_call_indicator_value), A_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_app_Send_notification_ind,
      { "Send notification indicator (SNI)",  "isup.app_Send_notification_ind",
        FT_BOOLEAN, 8, TFS(&isup_Send_notification_ind_value), B_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_apm_segmentation_ind,
      { "APM segmentation indicator",  "isup.apm_segmentation_ind",
        FT_UINT8, BASE_DEC, VALS(isup_APM_segmentation_ind_value), FEDCBA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_apm_si_ind,
      { "Sequence indicator (SI)",  "isup.APM_Sequence_ind",
        FT_BOOLEAN, 8, TFS(&isup_Sequence_ind_value), G_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_orig_addr_len,
      { "Originating Address length",  "isup.orig_addr_len",
        FT_UINT8, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_dest_addr_len,
      { "Destination Address length",  "isup.dest_addr_len",
        FT_UINT8, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_apm_slr,
      { "Segmentation local reference (SLR)",  "isup.APM_slr",
        FT_UINT8, BASE_DEC, NULL, GFEDCBA_8BIT_MASK,
        NULL, HFILL }},
    { &hf_isup_cause_location,
      { "Cause location", "isup.cause_location",
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &q931_cause_location_vals_ext, 0x0f,
        NULL, HFILL }},

    { &hf_ansi_isup_coding_standard,
      { "Coding standard", "ansi_isup.coding_standard",
        FT_UINT8, BASE_HEX, VALS(ansi_isup_coding_standard_vals), 0x60,
        NULL, HFILL }},
    { &hf_ansi_isup_spare_b7,
      { "Spare", "ansi_isup.spare.b7",
      FT_UINT8, BASE_DEC, NULL, 0x80,
      NULL, HFILL }},
    { &hf_ansi_isup_type_of_nw_id,
      { "Type of network identification", "ansi_isup.type_of_nw_id",
        FT_UINT8, BASE_DEC, VALS(ansi_isup_type_of_nw_id_vals), 0x70,
        NULL, HFILL } },
    { &hf_ansi_isup_nw_id_plan,
      { "Network identification plan", "ansi_isup.nw_id_plan",
        FT_UINT8, BASE_DEC, VALS(ansi_isup_nw_id_plan_vals), 0x0f,
        NULL, HFILL } },
    { &hf_ansi_isup_tns_nw_id_plan,
      { "Network identification plan", "ansi_isup.tns.nw_id_plan",
        FT_UINT8, BASE_DEC, VALS(ansi_isup_tns_nw_id_plan_vals), 0x0f,
        NULL, HFILL } },
    { &hf_ansi_isup_nw_id,
      { "Network id",  "ansi_isup.nw_id",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL } },
    { &hf_ansi_isup_circuit_code,
      { "Circuit code", "ansi_isup.circuit_code",
        FT_UINT8, BASE_DEC, NULL, 0xf0,
        NULL, HFILL } },

      { &hf_bat_ase_identifier,
      { "BAT ASE Identifiers",  "bicc.bat_ase_identifier",
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &bat_ase_list_of_Identifiers_vals_ext, 0x0,
        NULL, HFILL }},

    { &hf_length_indicator,
      { "BAT ASE Element length indicator",  "bicc.bat_ase_length_indicator",
        FT_UINT16, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_Action_Indicator,
      { "BAT ASE action indicator field",  "bicc.bat_ase_bat_ase_action_indicator_field",
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &bat_ase_action_indicator_field_vals_ext, 0x00,
        NULL, HFILL }},

    { &hf_Instruction_ind_for_general_action,
      { "BAT ASE Instruction indicator for general action",  "bicc.bat_ase_Instruction_ind_for_general_action",
        FT_UINT8, BASE_HEX, VALS(Instruction_indicator_for_general_action_vals), 0x03,
        NULL, HFILL }},

    { &hf_Send_notification_ind_for_general_action,
      { "Send notification indicator for general action",  "bicc.bat_ase_Send_notification_ind_for_general_action",
        FT_BOOLEAN, 8, TFS(&isup_Send_notification_ind_value), 0x04,
        NULL, HFILL }},

    { &hf_Instruction_ind_for_pass_on_not_possible,
      { "Instruction ind for pass-on not possible",  "bicc.bat_ase_Instruction_ind_for_pass_on_not_possible",
        FT_UINT8, BASE_HEX, VALS(Instruction_indicator_for_pass_on_not_possible_vals), 0x30,
        NULL, HFILL }},

    { &hf_Send_notification_ind_for_pass_on_not_possible,
      { "Send notification indication for pass-on not possible",  "bicc.bat_ase_Send_notification_ind_for_pass_on_not_possible",
        FT_BOOLEAN, 8, TFS(&isup_Send_notification_ind_value), 0x40,
        NULL, HFILL }},

    { &hf_BCTP_Version_Indicator,
      { "BCTP Version Indicator",  "bicc.bat_ase_BCTP_Version_Indicator",
        FT_UINT8, BASE_DEC, NULL, 0x1f,
        NULL, HFILL }},

    { &hf_BVEI,
      { "BVEI",  "bicc.bat_ase_BCTP_BVEI",
        FT_BOOLEAN, 8, TFS(&BCTP_BVEI_value), 0x40,
        NULL, HFILL }},

    { &hf_Tunnelled_Protocol_Indicator,
      { "Tunnelled Protocol Indicator",  "bicc.bat_ase_BCTP_Tunnelled_Protocol_Indicator",
        FT_UINT8, BASE_DEC, VALS(BCTP_Tunnelled_Protocol_Indicator_vals), 0x3f,
        NULL, HFILL }},

    { &hf_TPEI,
      { "TPEI",  "bicc.bat_ase_BCTP_tpei",
        FT_BOOLEAN, 8, TFS(&BCTP_TPEI_value), 0x40,
        NULL, HFILL }},

    { &hf_bncid,
      { "Backbone Network Connection Identifier (BNCId)", "bat_ase.bncid",
        FT_UINT32, BASE_HEX, NULL, 0x0,
        NULL, HFILL }},

    { &hf_bat_ase_biwfa,
      { "Interworking Function Address(X.213 NSAP encoded)", "bat_ase.biwfa",
        FT_BYTES, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_afi,
      { "X.213 Address Format Information (AFI)",  "x213.afi",
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &x213_afi_value_ext, 0x0,
        NULL, HFILL }},

    { &hf_bicc_nsap_dsp,
      { "X.213 Address Format Information (DSP)",  "x213.dsp",
        FT_BYTES, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_bicc_nsap_dsp_length,
      { "DSP Length",  "x213.dsp_length",
        FT_UINT32, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_characteristics,
      { "Backbone network connection characteristics", "bat_ase.char",
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &bearer_network_connection_characteristics_vals_ext, 0x0,
        NULL, HFILL }},

    { &hf_Organization_Identifier,
      { "Organization identifier subfield",  "bat_ase.organization_identifier_subfield",
        FT_UINT8, BASE_DEC, VALS(bat_ase_organization_identifier_subfield_vals), 0x0,
        NULL, HFILL }},

    { &hf_codec_type,
      { "ITU-T codec type subfield",  "bat_ase.ITU_T_codec_type_subfield",
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &ITU_T_codec_type_subfield_vals_ext, 0x0,
        NULL, HFILL }},

    { &hf_etsi_codec_type,
      { "ETSI codec type subfield",  "bat_ase.ETSI_codec_type_subfield",
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &ETSI_codec_type_subfield_vals_ext, 0x0,
        NULL, HFILL }},

    { &hf_active_code_set,
      { "Active Code Set",  "bat_ase.acs",
        FT_UINT8, BASE_HEX, NULL, 0x0,
        NULL, HFILL }},

    { &hf_active_code_set_12_2,
      { "12.2 kbps rate",  "bat_ase.acs.12_2",
        FT_UINT8, BASE_HEX, NULL, 0x80,
        NULL, HFILL }},

    { &hf_active_code_set_10_2,
      { "10.2 kbps rate",  "bat_ase.acs.10_2",
        FT_UINT8, BASE_HEX, NULL, 0x40,
        NULL, HFILL }},

    { &hf_active_code_set_7_95,
      { "7.95 kbps rate",  "bat_ase.acs.7_95",
        FT_UINT8, BASE_HEX, NULL, 0x20,
        NULL, HFILL }},

    { &hf_active_code_set_7_40,
      { "7.40 kbps rate",  "bat_ase.acs.7_40",
        FT_UINT8, BASE_HEX, NULL, 0x10,
        NULL, HFILL }},

    { &hf_active_code_set_6_70,
      { "6.70 kbps rate",  "bat_ase.acs.6_70",
        FT_UINT8, BASE_HEX, NULL, 0x08,
        NULL, HFILL }},

    { &hf_active_code_set_5_90,
      { "5.90 kbps rate",  "bat_ase.acs.5_90",
        FT_UINT8, BASE_HEX, NULL, 0x04,
        NULL, HFILL }},

    { &hf_active_code_set_5_15,
      { "5.15 kbps rate",  "bat_ase.acs.5_15",
        FT_UINT8, BASE_HEX, NULL, 0x02,
        NULL, HFILL }},

    { &hf_active_code_set_4_75,
      { "4.75 kbps rate",  "bat_ase.acs.4_75",
        FT_UINT8, BASE_HEX, NULL, 0x01,
        NULL, HFILL }},

    { &hf_supported_code_set,
      { "Supported Code Set",  "bat_ase.scs",
        FT_UINT8, BASE_HEX, NULL, 0x0,
        NULL, HFILL }},

    { &hf_supported_code_set_12_2,
      { "12.2 kbps rate",  "bat_ase.scs.12_2",
        FT_UINT8, BASE_HEX, NULL, 0x80,
        NULL, HFILL }},

    { &hf_supported_code_set_10_2,
      { "10.2 kbps rate",  "bat_ase.scs.10_2",
        FT_UINT8, BASE_HEX, NULL, 0x40,
        NULL, HFILL }},

    { &hf_supported_code_set_7_95,
      { "7.95 kbps rate",  "bat_ase.scs.7_95",
        FT_UINT8, BASE_HEX, NULL, 0x20,
        NULL, HFILL }},

    { &hf_supported_code_set_7_40,
      { "7.40 kbps rate",  "bat_ase.scs.7_40",
        FT_UINT8, BASE_HEX, NULL, 0x10,
        NULL, HFILL }},

    { &hf_supported_code_set_6_70,
      { "6.70 kbps rate",  "bat_ase.scs.6_70",
        FT_UINT8, BASE_HEX, NULL, 0x08,
        NULL, HFILL }},

    { &hf_supported_code_set_5_90,
      { "5.90 kbps rate",  "bat_ase.scs.5_90",
        FT_UINT8, BASE_HEX, NULL, 0x04,
        NULL, HFILL }},

    { &hf_supported_code_set_5_15,
      { "5.15 kbps rate",  "bat_ase.scs.5_15",
        FT_UINT8, BASE_HEX, NULL, 0x02,
        NULL, HFILL }},

    { &hf_supported_code_set_4_75,
      { "4.75 kbps rate",  "bat_ase.scs.4_75",
        FT_UINT8, BASE_HEX, NULL, 0x01,
        NULL, HFILL }},

    { &hf_optimisation_mode,
      { "Optimisation Mode for ACS , OM",  "bat_ase.optimisation_mode",
        FT_UINT8, BASE_HEX, VALS(optimisation_mode_vals), 0x8,
        NULL, HFILL }},

    { &hf_max_codec_modes,
      { "Maximal number of Codec Modes, MACS",  "bat_ase.macs",
        FT_UINT8, BASE_DEC, NULL, 0x07,
        NULL, HFILL }},


    { &hf_bearer_control_tunneling,
      { "Bearer control tunneling",  "bat_ase.bearer_control_tunneling",
        FT_BOOLEAN, 8, TFS(&Bearer_Control_Tunnelling_ind_value), 0x01,
        NULL, HFILL }},

    { &hf_BAT_ASE_Comp_Report_Reason,
      { "Compatibility report reason",  "bat_ase.Comp_Report_Reason",
        FT_UINT8, BASE_HEX, VALS(BAT_ASE_Report_Reason_vals), 0x0,
        NULL, HFILL }},


    { &hf_BAT_ASE_Comp_Report_ident,
      { "Compatibility report ident",  "bat_ase.Comp_Report_ident",
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &bat_ase_list_of_Identifiers_vals_ext, 0x0,
        NULL, HFILL }},

    { &hf_BAT_ASE_Comp_Report_diagnostic,
      { "Diagnostics",  "bat_ase.Comp_Report_diagnostic",
        FT_UINT16, BASE_HEX, NULL, 0x0,
        NULL, HFILL }},

    { &hf_Local_BCU_ID,
      { "Local BCU ID",  "bat_ase.Local_BCU_ID",
        FT_UINT32, BASE_HEX, NULL, 0x0,
        NULL, HFILL }},

    { &hf_late_cut_through_cap_ind,
      { "Late Cut-through capability indicator",  "bat_ase.late_cut_through_cap_ind",
        FT_BOOLEAN, 8, TFS(&late_cut_through_cap_ind_value), 0x01,
        NULL, HFILL }},

    { &hf_bat_ase_signal,
      { "Q.765.5 - Signal Type",  "bat_ase.signal_type",
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &BAT_ASE_Signal_Type_vals_ext, 0x0,
        NULL, HFILL }},

    { &hf_bat_ase_duration,
      { "Duration in ms",  "bat_ase.duration",
        FT_UINT16, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_bat_ase_default,
      { "Default",  "bat_ase.default",
        FT_BYTES, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_bat_ase_bearer_redir_ind,
      { "Redirection Indicator",  "bat_ase.bearer_redir_ind",
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &Bearer_Redirection_Indicator_vals_ext, 0x0,
        NULL, HFILL }},

    { &hf_nsap_ipv4_addr,
      { "IWFA IPv4 Address", "nsap.ipv4_addr",
        FT_IPv4, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_nsap_ipv6_addr,
      { "IWFA IPv6 Address", "nsap.ipv6_addr",
        FT_IPv6, BASE_NONE, NULL, 0x0,
        NULL, HFILL}},

    { &hf_iana_icp,
      { "IANA ICP",  "nsap.iana_icp",
        FT_UINT16, BASE_HEX, VALS(iana_icp_values), 0x0,
        NULL, HFILL }},

    { &hf_isup_called,
      { "Called Party Number",  "isup.called",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_calling,
      { "Calling Party Number",  "isup.calling",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_redirecting,
      { "Redirecting Number",  "isup.redirecting",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_redirection_number,
      { "Redirection Number",  "isup.redirection_number",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_subsequent_number,
      { "Subsequent Number",  "isup.subsequent_number",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_connected_number,
      { "Connected Number",  "isup.connected_number",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_transit_network_selection,
      { "Transit Network Selection",  "isup.transit_network_selection",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_original_called_number,
      { "Original Called Number",  "isup.original_called_number",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_location_number,
      { "Location Number",  "isup.location_number",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_call_transfer_number,
      { "Call Transfer Number",  "isup.call_transfer_number",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_called_in_number,
      { "Called IN Number",  "isup.called_in_number",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_generic_number,
      { "Generic Number",  "isup.generic_number",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_jurisdiction,
      { "Jurisdiction",  "isup.jurisdiction",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_charge_number,
      { "Charge Number",  "isup.charge_number",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_apm_msg_fragments,
     { "Message fragments", "isup.apm.msg.fragments",
      FT_NONE, BASE_NONE, NULL, 0x00,
      NULL, HFILL }},

    { &hf_isup_apm_msg_fragment,
      { "Message fragment", "isup.apm.msg.fragment",
        FT_FRAMENUM, BASE_NONE, NULL, 0x00,
        NULL, HFILL }},

    { &hf_isup_apm_msg_fragment_overlap,
      { "Message fragment overlap", "isup.apm.msg.fragment.overlap",
        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_apm_msg_fragment_overlap_conflicts,
      { "Message fragment overlapping with conflicting data", "isup.apm.msg.fragment.overlap.conflicts",
        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_apm_msg_fragment_multiple_tails,
      { "Message has multiple tail fragments", "isup.apm.msg.fragment.multiple_tails",
        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_apm_msg_fragment_too_long_fragment,
      { "Message fragment too long", "isup.apm.msg.fragment.too_long_fragment",
        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_apm_msg_fragment_error,
      { "Message defragmentation error", "isup.apm.msg.fragment.error",
        FT_FRAMENUM, BASE_NONE, NULL, 0x00,
        NULL, HFILL }},

    { &hf_isup_apm_msg_fragment_count,
      { "Message fragment count", "isup.apm.msg.fragment.count",
        FT_UINT32, BASE_DEC, NULL, 0x00,
        NULL, HFILL }},

    { &hf_isup_apm_msg_reassembled_in,
      { "Reassembled in", "isup.apm.msg.reassembled.in",
        FT_FRAMENUM, BASE_NONE, NULL, 0x00,
        NULL, HFILL }},

    { &hf_isup_apm_msg_reassembled_length,
      { "Reassembled ISUP length", "isup.apm.msg.reassembled.length",
        FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL }},

    { &hf_isup_cvr_rsp_ind,
      { "CVR Response Ind", "isup.conn_rsp_ind",
        FT_UINT8, BASE_DEC, VALS(isup_cvr_rsp_ind_value), BA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_cvr_cg_car_ind,
      { "CVR Circuit Group Carrier", "isup.cg_carrier_ind",
        FT_UINT8, BASE_HEX, VALS(isup_cvr_cg_car_ind_value), BA_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_cvr_cg_double_seize,
      { "Double Seize Control", "isup.cg_char_ind.doubleSeize",
        FT_UINT8, BASE_HEX, VALS(isup_cvr_cg_double_seize_value), DC_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_cvr_cg_alarm_car_ind,
      { "Alarm Carrier Indicator", "isup.cg_alarm_car_ind",
        FT_UINT8, BASE_HEX, VALS(isup_cvr_alarm_car_ind_value), FE_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_cvr_cont_chk_ind,
      { "Continuity Check Indicator", "isup.cg_alarm_cnt_chk",
        FT_UINT8, BASE_HEX, VALS(isup_cvr_cont_chk_ind_value), HG_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_geo_loc_presentation_restricted_ind,
      { "Calling Geodetic Location presentation restricted indicator",  "isup.location_presentation_restr_ind",
        FT_UINT8, BASE_DEC, VALS(isup_location_presentation_restricted_ind_value), DC_8BIT_MASK,
        NULL, HFILL }},

    { &hf_isup_geo_loc_screening_ind,
      { "Calling Geodetic Location screening indicator",  "isup.location_screening_ind",
        FT_UINT8, BASE_DEC, VALS(isup_screening_ind_enhanced_value), BA_8BIT_MASK,        /* using previously defined screening values */
        NULL, HFILL }},

    /* French ISUP parameters */
    { &hf_isup_french_coll_field,
      { "Collection field",  "isup.french.coll_field",
        FT_UINT8, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_french_msg_num,
      { "Message number",  "isup.french.msg_num",
        FT_UINT8, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    /* Israeli ISUP parameters */
    { &hf_isup_israeli_charging_message_indicators_current,
      { "Current Tariff",  "isup.israeli.cmi_current",
        FT_UINT8, BASE_DEC, VALS(israeli_cmi_current_rate), 0x03,
        NULL, HFILL }},

    { &hf_isup_israeli_charging_message_indicators_next,
      { "Next Tariff",  "isup.israeli.cmi_next",
        FT_UINT8, BASE_DEC, VALS(israeli_cmi_next_rate), 0x0C,
        NULL, HFILL }},

    { &hf_isup_israeli_current_rate,
      { "Current Rate",  "isup.israeli.current_rate",
        FT_UINT16, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_israeli_time_indicator,
      { "Time Indicator",  "isup.israeli.time_indicator",
        FT_UINT8, BASE_DEC | BASE_EXT_STRING, &israeli_time_indicators_ext, 0x0,
        NULL, HFILL }},

    { &hf_isup_israeli_next_rate,
      { "Next Rate",  "isup.israeli.next_ratej",
        FT_UINT16, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    /* Japan ISUP */
    { &hf_japan_isup_redirect_capability,
      { "Redirect possible indicator",  "isup.jpn.redirect_capability",
        FT_UINT8, BASE_DEC, VALS(isup_jpn_redirect_capabilit_vals), 0x07,
        NULL, HFILL }},

    { &hf_japan_isup_redirect_counter,
      { "Redirect counter",  "isup.jpn.redirect_counter",
        FT_UINT8, BASE_DEC, NULL, 0x0f,
        NULL, HFILL }},

    { &hf_japan_isup_rfi_info_type,
      { "Information Type Tag",  "isup.rfi.info_type",
        FT_UINT8, BASE_DEC, VALS(isup_rfi_info_type_values), 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_rfi_info_len,
      { "Length",  "isup.rfi.info_len",
        FT_UINT8, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_perf_redir_reason,
      { "Performing redirect reason",  "isup.rfi.perf_redir_reason",
        FT_UINT8, BASE_DEC, VALS(perf_redir_reason_vals), 0x7f,
        NULL, HFILL }},

    { &hf_japan_isup_redir_pos_ind,
      { "Redirect possible indicator at performing exchange",  "isup.rfi.redir_pos_ind",
        FT_UINT8, BASE_DEC, VALS(redir_pos_ind_vals), 0x07,
        NULL, HFILL }},

    { &hf_japan_isup_emerg_call_type,
      { "Emergency Call Type",  "isup.jpn.emerg_call_type",
        FT_UINT8, BASE_DEC, VALS(japan_isup_emerg_call_type_vals), 0x03,
        NULL, HFILL }},

    { &hf_japan_isup_hold_at_emerg_call_disc_ind,
      { "Hold at emergency Call Disconnection Indicators",  "isup.jpn.hold_at_emerg_call_disc_ind",
        FT_UINT16, BASE_DEC, VALS(hold_at_emerg_call_disc_ind_vals), 0x0300,
        NULL, HFILL }},

    /* Value string values the same as perf_redir_reason_vals */
    { &hf_japan_isup_inv_redir_reason,
      { "Invoking redirect reason",  "isup.rfi.inv_redir_reason",
        FT_UINT8, BASE_DEC, VALS(perf_redir_reason_vals), 0x7f,
        NULL, HFILL }},

    { &hf_japan_isup_bwd_info_type,
      { "Information Type Tag",  "isup.jpn.bwd_info_type",
        FT_UINT8, BASE_DEC, VALS(japan_isup_bwd_info_type_vals), 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_tag_len,
      { "Length",  "isup.jpn.tag_len",
        FT_UINT8, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_add_user_cat_type,
      { "Type of Additional User/Service Information",  "isup.jpn.add_user_cat_type",
        FT_UINT8, BASE_DEC|BASE_RANGE_STRING, RVALS(jpn_isup_add_user_cat_type_vals), 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_type_1_add_fixed_serv_inf,
      { "Type 1 of additional fixed service information",  "isup.jpn.type_1_add_fixed_serv_inf",
        FT_UINT8, BASE_DEC, VALS(jpn_isup_type_1_add_fixed_serv_inf_vals), 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_type_1_add_mobile_serv_inf,
      { "Type 1 of additional mobile service information",  "isup.jpn.type_1_add_mobile_serv_inf",
        FT_UINT8, BASE_DEC, VALS(jpn_isup_type_1_add_mobile_serv_inf_vals), 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_type_2_add_mobile_serv_inf,
      { "Type 2 of additional mobile service information (Communication Method)",  "isup.jpn.type_2_add_mobile_serv_inf",
        FT_UINT8, BASE_DEC | BASE_EXT_STRING, &jpn_isup_type_2_add_mobile_serv_inf_vals_ext, 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_type_3_add_mobile_serv_inf,
      { "Type 3 of additional mobile service information (Charging Method)",  "isup.jpn.type_3_add_mobile_serv_inf",
        FT_UINT8, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_reason_for_clip_fail,
      { "Reason for CLIP failure",  "isup.jpn.reason_for_clip_fail",
        FT_UINT8, BASE_DEC, VALS(jpn_isup_reason_for_clip_fail_vals), 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_contractor_number,
      { "Contractor Number",  "isup.jpn.contractor_number",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    /* CHARGE AREA INFORMATION */
    { &hf_japan_isup_charge_area_nat_of_info_value,
      { "Nature of Information indicator",  "isup.charg_area_info.oddeven_indic",
        FT_UINT8, BASE_DEC, VALS(isup_charge_area_info_nat_of_info_value), 0x7F,
        NULL, HFILL }},

    { &hf_japan_isup_charging_info_nc_odd_digits,
      { "NC",  "isup.charg_area_info.nc_odd_digit",
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0x0F,
        NULL, HFILL }},

    { &hf_japan_isup_charging_info_nc_even_digits,
      { "NC", "isup.charg_area_info.nc_even_digit",
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0xF0,
        NULL, HFILL }},

    { &hf_isup_charging_info_maca_odd_digits,
      { "MA/CA", "isup.charg_area_info.maca_odd_digit",
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0x0F,
        NULL, HFILL }},

    { &hf_isup_charging_info_maca_even_digits,
      { "MA/CA", "isup.charg_area_info.maca_even_digit",
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0xF0,
        NULL, HFILL }},

    /* CARRIER INFORMATION */
    { &hf_isup_carrier_info_iec,
      { "IEC Indicator", "isup.carrier_info.iec",
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_iec_indic_value), 0x00,
        NULL, HFILL }},

#if 0 /* TODO: tools/checkhf.pl reported these as unused */
    { &hf_isup_carrier_info_cat_of_carrier,
      { "Category of Carrier", "isup.carrier_info.cat_of_carrier",
        FT_UINT8, BASE_HEX, VALS(isup_carrier_info_category_value), 0x00,
        NULL, HFILL }},

    { &hf_isup_carrier_info_type_of_carrier_info,
      { "Type of Carrier", "isup.carrier_info.type_of_carrier",
        FT_UINT8, BASE_HEX, VALS(isup_carrier_info_type_of_carrier_value), 0x00,
        NULL, HFILL }},
#endif

    { &hf_japan_isup_carrier_info_length,
      { "Length of Carrier Information", "isup.jpn.carrier_info_length",
        FT_UINT8, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_isup_carrier_info_odd_no_digits,
      { "CID", "isup.carrier_info.cid_odd_digit",
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0x0F,
        NULL, HFILL }},

    { &hf_isup_carrier_info_even_no_digits,
      { "CID", "isup.carrier_info.cid_even_digit",
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0xF0,
        NULL, HFILL }},

    { &hf_isup_carrier_info_ca_odd_no_digits,
      { "CA", "isup.carrier_info.ca_odd_digit",
      FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0x0F,
      NULL, HFILL }},

    { &hf_isup_carrier_info_ca_even_no_digits,
      { "CA", "isup.carrier_info.ca_even_digit",
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0xF0,
        NULL, HFILL }},

    { &hf_isup_carrier_info_poi_exit_HEI,
      { "Exit POI Hierarchy", "isup.carrier_info_exit_hierarchy",
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_poihie_value), 0x0F,
        NULL, HFILL }},

    { &hf_isup_carrier_info_poi_entry_HEI,
      { "Entry POI Hierarchy", "isup.carrier_info_entry_hierarchy",
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_poihie_value), 0xF0,
        NULL, HFILL }},

    { &hf_japan_isup_charge_delay_type,
      { "Type of delayed charging information", "isup.japan.charge_delay_type",
        FT_UINT8, BASE_DEC|BASE_RANGE_STRING, RVALS(japan_isup_charge_delay_type_value), 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_charge_info_type,
      { "Charge information type", "isup.japan.chg_inf_type",
        FT_UINT8, BASE_DEC, VALS(japan_isup_chg_info_type_value), 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_sig_elem_type,
      { "Signal element type", "isup.japan.sig_elem_type",
        FT_UINT8, BASE_DEC, VALS(japan_isup_sig_elem_type_values), 0x7f,
        NULL, HFILL }},

    { &hf_japan_isup_activation_id,
      { "Activation id", "isup.japan.activation_id",
        FT_UINT8, BASE_DEC, NULL, 0x7F,
        NULL, HFILL }},

    { &hf_japan_isup_op_cls,
      { "Operation class", "isup.japan.op_cls",
        FT_UINT8, BASE_DEC, VALS(japan_isup_op_cls_values), 0x60,
        NULL, HFILL }},

    { &hf_japan_isup_op_type,
      { "Operation type", "isup.japan.op_type",
        FT_UINT8, BASE_DEC, VALS(japan_isup_op_type_values), 0x1f,
        NULL, HFILL }},

    { &hf_japan_isup_charging_party_type,
      { "Charging party type", "isup.japan.charging_party_type",
        FT_UINT8, BASE_DEC, VALS(japan_isup_charging_party_type_values), 0x70,
        NULL, HFILL }},

    { &hf_japan_isup_utp,
      { "Unit per Time Period (UTP)", "isup.japan.utp",
        FT_UINT8, BASE_DEC, VALS(japan_isup_utp_values), 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_crci1,
      { "Charge rate information category 1 (CRIC 1)", "isup.japan.crci1",
        FT_UINT8, BASE_DEC, VALS(japan_isup_crci1_values), 0x7f,
        NULL, HFILL }},

    { &hf_japan_isup_crci2,
      { "Charge rate information category 2 (CRIC 2)", "isup.japan.crci2",
        FT_UINT8, BASE_DEC, VALS(japan_isup_crci1_values), 0x7f,
        NULL, HFILL }},

    { &hf_japan_isup_crci1_len,
      { "Length",  "isup.japan.crci1_len",
        FT_UINT8, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_iu,
      { "Initial units (IU)",  "isup.japan.iu",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_dcr,
      { "Daytime Charge rate (DCR)",  "isup.japan.dcr",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_ecr,
      { "Evening Charge rate (ECR)",  "isup.japan.ecr",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_ncr,
      { "Nighttime Charge rate (NCR)",  "isup.japan.ncr",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_scr,
      { "Spare charge rate (SCR)",  "isup.japan.scr",
        FT_STRING, BASE_NONE, NULL, 0x0,
        NULL, HFILL }},

    { &hf_japan_isup_collecting_method,
      { "Charging party type", "isup.japan.collecting_method",
        FT_UINT8, BASE_DEC, VALS(japan_isup_collecting_method_values), 0x0f,
        NULL, HFILL }},

    { &hf_japan_isup_tariff_rate_pres,
      { "Tariff rate presentation", "isup.japan.tariff_rate_pres",
        FT_UINT8, BASE_DEC, VALS(japan_isup_tariff_rate_pres_values), 0x7f,
        NULL, HFILL }},

      /* Generated from convert_proto_tree_add_text.pl */
      { &hf_isup_cause_indicators, { "Cause indicators (-> Q.850)", "isup.cause_indicators", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_diagnostic, { "Diagnostic", "isup.diagnostic", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_user_to_user_info, { "User-to-user info (-> Q.931)", "isup.user_to_user_info", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_call_identity, { "Call identity", "isup.call_identity", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_signalling_point_code, { "Signalling Point Code", "isup.signalling_point_code", FT_UINT16, BASE_DEC, NULL, 0x3FFF, NULL, HFILL }},
      { &hf_isup_access_transport_parameter_field, { "Access transport parameter field (-> Q.931)", "isup.access_transport_parameter_field", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_idp, { "IDP", "isup.idp", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_dsp, { "DSP", "isup.dsp", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_idi, { "IDI", "isup.idi", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_configuration_data, { "Configuration data", "isup.configuration_data", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_unknown_organisation_identifier, { "Unknown organisation Identifier (Non ITU-T/ETSI codec)", "isup.unknown_organisation_identifier", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_tunnelled_protocol_data, { "Tunnelled Protocol Data", "isup.tunnelled_protocol_data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_network_id_length_indicator, { "Network ID Length indicator", "isup.network_id_length_indicator", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_network_id, { "Network ID", "isup.network_id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_app_transport_param_field8, { "Application transport parameter fields", "isup.app_transport_param_field", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_app_transport_param_field16, { "Application transport parameter fields", "isup.app_transport_param_field", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_app_transport_instruction_indicator, { "Application transport instruction indicators", "isup.app_transport_instruction_indicator", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_apm_seg_indicator, { "APM segmentation indicator", "isup.apm_seg_indicator", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_address_digits, { "Address digits", "isup.address_digits", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_apm_user_info_field, { "APM-user information field", "isup.apm_user_info_field", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_local_reference, { "Local Reference", "isup.local_reference", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_protocol_class, { "Protocol Class", "isup.protocol_class", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_credit, { "Credit", "isup.credit", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_network_identity, { "Network Identity", "isup.network_identity", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_binary_code, { "Binary Code", "isup.binary_code", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_user_service_information, { "User service information (-> Q.931 Bearer_capability)", "isup.user_service_information", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_circuit_assignment_map, { "Circuit assignment map (bit position indicates usage of corresponding circuit->3.69/Q.763)", "isup.circuit_assignment_map", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_origination_isc_point_code, { "Origination ISC Point Code", "isup.origination_isc_point_code", FT_UINT16, BASE_DEC, NULL, 0x3FFF, NULL, HFILL }},
      { &hf_isup_call_history_info, { "Call history info", "isup.call_history_info", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_network_specific_facility, { "Network specific facility (refer to 3.36/Q.763 for detailed decoding)", "isup.network_specific_facility", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_user_service_information_prime, { "User service information prime (-> Q.931 Bearer capability information IE)", "isup.user_service_information_prime", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_propagation_delay_counter, { "Propagation delay counter", "isup.propagation_delay_counter", FT_UINT16, BASE_DEC|BASE_UNIT_STRING, UNS(&units_milliseconds), 0x0, NULL, HFILL }},
      { &hf_isup_remote_operations, { "Remote operations", "isup.remote_operations", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_feature_code, { "Feature Code", "isup.feature_code", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_user_teleservice_information, { "User teleservice information (-> Q.931 High Layer Compatibility IE)", "isup.user_teleservice_information", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_call_diversion_information, { "Call diversion information", "isup.call_diversion_information", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_echo_control_information, { "Echo control information", "isup.echo_control_information", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_message_compatibility_information, { "Message compatibility information", "isup.message_compatibility_information", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_upgraded_parameter, { "Upgraded parameter", "isup.upgraded_parameter", FT_UINT8, BASE_DEC|BASE_EXT_STRING, &isup_parameter_type_value_ext, 0x0, NULL, HFILL }},
      { &hf_isup_instruction_indicators, { "Instruction indicators", "isup.instruction_indicators", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_look_forward_busy, { "Look forward busy", "isup.look_forward_busy", FT_UINT8, BASE_DEC, VALS(isup_mlpp_precedence_look_forward_busy_vals), 0x60, NULL, HFILL }},
      { &hf_isup_precedence_level, { "Precedence Level", "isup.precedence_level", FT_UINT8, BASE_DEC, VALS(isup_mlpp_precedence_level_vals), 0x0F, NULL, HFILL }},
      { &hf_isup_mlpp_service_domain, { "MLPP service domain", "isup.mlpp_service_domain", FT_UINT24, BASE_HEX, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_mcid_request_indicators, { "MCID request indicators", "isup.mcid_request_indicators", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_mcid_response_indicators, { "MCID response indicators", "isup.mcid_response_indicators", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_hop_counter, { "Hop counter", "isup.hop_counter", FT_UINT8, BASE_DEC, NULL, EDCBA_8BIT_MASK, NULL, HFILL }},
      { &hf_isup_originating_line_info, { "Originating line info", "isup.originating_line_info", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_presentation_indicator, { "Presentation indicator", "isup.presentation_indicator", FT_UINT8, BASE_DEC, VALS(isup_redirection_presentation_indicator_vals), BA_8BIT_MASK, NULL, HFILL }},
      { &hf_isup_call_transfer_identity, { "Call transfer identity", "isup.call_transfer_identity", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_loop_prevention_indicator_type, { "Type", "isup.loop_prevention_indicator_type", FT_BOOLEAN, 8, TFS(&tfs_response_request), A_8BIT_MASK, NULL, HFILL }},
      { &hf_isup_ccss_call_indicator, { "CCSS call indicator", "isup.ccss_call_indicator", FT_BOOLEAN, 8, TFS(&tfs_ccss_call_no_indication), A_8BIT_MASK, NULL, HFILL }},
      { &hf_isup_forward_gvns, { "Forward GVNS (refer to 3.66/Q.763 for detailed decoding)", "isup.forward_gvns", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_redirect_capability, { "Redirect capability", "isup.redirect_capability", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_backward_gvns, { "Backward GVNS", "isup.backward_gvns", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_correlation_id, { "Correlation ID (-> Q.1281)", "isup.correlation_id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_scf_id, { "SCF ID (-> Q.1281)", "isup.scf_id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_charged_party_identification, { "Charged party identification (format is national network specific)", "isup.charged_party_identification", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_display_information, { "Display information (-> Q.931)", "isup.display_information", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_uid_action_indicators, { "UID action indicators", "isup.uid_action_indicators", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_uid_capability_indicators, { "UID capability indicators", "isup.uid_capability_indicators", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_redirect_counter, { "Redirect counter", "isup.redirect_counter", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_collect_call_request_indicator, { "Collect call request indicator", "isup.collect_call_request_indicator", FT_BOOLEAN, 8, TFS(&tfs_collect_call_req_no_indication), A_8BIT_MASK, NULL, HFILL }},
      { &hf_isup_geo_loc_shape, { "Calling geodetic location type of shape", "isup.geo_loc_shape", FT_UINT8, BASE_DEC, VALS(isup_location_type_of_shape_value), GFEDCBA_8BIT_MASK, NULL, HFILL }},
      { &hf_isup_geo_loc_shape_description, { "Shape description", "isup.shape_description", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
      { &hf_isup_number_qualifier_indicator, { "Number qualifier indicator", "isup.number_qualifier_indicator", FT_UINT8, BASE_HEX|BASE_RANGE_STRING, RVALS(number_qualifier_indicator_vals), 0x0, NULL, HFILL }},
      { &hf_isup_generic_digits, { "Generic digits (refer to 3.24/Q.673 for detailed decoding)", "isup.generic_digits", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
  };

/* Setup protocol subtree array */
  static int *ett[] = {
    &ett_isup,
    &ett_isup_parameter,
    &ett_isup_address_digits,
    &ett_isup_carrier_info,
    &ett_isup_pass_along_message,
    &ett_isup_circuit_state_ind,
    &ett_bat_ase,
    &ett_bat_ase_element,
    &ett_bat_ase_iwfa,
    &ett_scs,
    &ett_acs,
    &ett_isup_apm_msg_fragment,
    &ett_isup_apm_msg_fragments,
    &ett_isup_range,
    &ett_app_transport_fields,
    &ett_app_transport,
    &ett_apm_seg_indicator,
    &ett_echo_control_information,
    &ett_instruction_indicators,
    &ett_message_compatibility_information,
  };

  static ei_register_info ei[] = {
    { &ei_isup_format_national_matter, { "isup.format_national_matter", PI_PROTOCOL, PI_NOTE, "Format is a national matter", EXPFILL }},
    { &ei_isup_message_type_unknown, { "isup.message_type.unknown", PI_PROTOCOL, PI_WARN, "Unknown Message type (possibly reserved/used in former ISUP version)", EXPFILL }},
    { &ei_isup_not_dissected_yet, { "isup.not_dissected_yet", PI_UNDECODED, PI_WARN, "Not dissected yet", EXPFILL }},
    { &ei_isup_status_subfield_not_present, { "isup.status_subfield_not_present", PI_PROTOCOL, PI_NOTE, "Status subfield is not present with this message type", EXPFILL }},
    { &ei_isup_message_type_no_optional_parameters, { "isup.message_type.no_optional_parameters", PI_PROTOCOL, PI_NOTE, "No optional parameters are possible with this message type", EXPFILL }},
    { &ei_isup_empty_number, { "isup.empty_number", PI_PROTOCOL, PI_NOTE, "(empty) number", EXPFILL }},
    { &ei_isup_too_many_digits, { "isup.too_many_digits", PI_MALFORMED, PI_ERROR, "Too many digits", EXPFILL }},
    { &ei_isup_opt_par_length_err, { "isup.opt_par_length_err", PI_MALFORMED, PI_ERROR, "Optional parameter length is wrong", EXPFILL }}
  };

  static const enum_val_t isup_variants[] = {
    {"ITU Standard",              "ITU Standard",              ISUP_ITU_STANDARD_VARIANT},
    {"French National Standard",  "French National Standard",  ISUP_FRENCH_VARIANT},
    {"Israeli National Standard", "Israeli National Standard", ISUP_ISRAELI_VARIANT},
    {"Russian National Standard", "Russian National Standard", ISUP_RUSSIAN_VARIANT},
    {"Japan National Standard",   "Japan National Standard",   ISUP_JAPAN_VARIANT},
    {"Japan National Standard (TTC)",   "Japan National Standard (TTC)",   ISUP_JAPAN_TTC_VARIANT},
    {NULL, NULL, -1}
  };

  module_t *isup_module;
  expert_module_t* expert_isup;

/* Register the protocol name and description */
  proto_isup = proto_register_protocol("ISDN User Part",
                                       "ISUP", "isup");

  isup_handle = register_dissector("isup", dissect_isup, proto_isup);

/* Required function calls to register the header fields and subtrees used */
  proto_register_field_array(proto_isup, hf, array_length(hf));
  proto_register_subtree_array(ett, array_length(ett));
  expert_isup = expert_register_protocol(proto_isup);
  expert_register_field_array(expert_isup, ei, array_length(ei));

  isup_tap = register_tap("isup");

  isup_module = prefs_register_protocol(proto_isup, NULL);

  prefs_register_enum_preference(isup_module, "variant",
                    "Select Standard or national ISUP variant",
                    "Note national variants may not be fully supported",
                    &g_isup_variant, isup_variants, false);


  prefs_register_bool_preference(isup_module, "show_cic_in_info", "Show CIC in Info column",
                                 "Show the CIC value (in addition to the message type) in the Info column",
                                 &isup_show_cic_in_info);

  prefs_register_bool_preference(isup_module, "defragment_apm",
                                 "Reassemble APM messages",
                                 "Whether APM messages datagrams should be reassembled",
                                 &isup_apm_desegment);

  /* Register the stats_tree */
  stats_tree_cfg *st_config = stats_tree_register("isup", "isup_msg", "_ISUP Messages",
                                 0, msg_stats_tree_packet, msg_stats_tree_init, NULL);
  stats_tree_set_group(st_config, REGISTER_TELEPHONY_GROUP_UNSORTED);
}


/* ------------------------------------------------------------------ */
/* Register isup with the sub-laying MTP L3 dissector */
void
proto_reg_handoff_isup(void)
{
  dissector_handle_t application_isup_handle;

  application_isup_handle = create_dissector_handle(dissect_application_isup, proto_isup);
  dissector_add_uint("mtp3.service_indicator", MTP_SI_ISUP, isup_handle);
  dissector_add_string("media_type", "application/isup", application_isup_handle);
  dissector_add_string("tali.opcode", "isot", isup_handle);

}

void
proto_register_bicc(void)
{
/* Setup list of header fields  See Section 1.6.1 for details*/
  static hf_register_info hf[] = {
    { &hf_bicc_cic,
      { "Call identification Code (CIC)",           "bicc.cic",
        FT_UINT32, BASE_DEC, NULL, 0x0,
        NULL, HFILL }},
    { &hf_bicc_continuity_check_indicator,
      { "Continuity Indicator",  "bicc.continuity_check_indicator",
        FT_UINT8, BASE_HEX, VALS(bicc_continuity_check_ind_value), DC_8BIT_MASK,
        NULL, HFILL }},
    { &hf_bicc_forw_call_end_to_end_method_indicator,
      { "End-to-end method indicator",  "bicc.forw_call_end_to_end_method_indicator",
        FT_UINT16, BASE_HEX, VALS(bicc_end_to_end_method_ind_value), CB_16BIT_MASK,
        NULL, HFILL }},
    { &hf_bicc_backw_call_end_to_end_method_ind,
      { "End-to-end method indicator",  "bicc.backw_call_end_to_end_method_indicator",
        FT_UINT16, BASE_HEX, VALS(bicc_end_to_end_method_ind_value), HG_16BIT_MASK,
        NULL, HFILL }},
    { &hf_bicc_backw_call_end_to_end_info_ind,
      { "End-to-end information indicator",  "bicc.backw_call_end_to_end_information_indicator",
        FT_BOOLEAN, 16, TFS(&bicc_end_to_end_info_ind_value), J_16BIT_MASK,
        NULL, HFILL }},
    { &hf_bicc_backw_call_isdn_user_part_ind,
      { "BICC indicator",  "bicc.backw_call_isdn_user_part_indicator",
        FT_BOOLEAN, 16, TFS(&bicc_ISDN_user_part_ind_value), K_16BIT_MASK,
        NULL, HFILL }},
    { &hf_bicc_backw_call_sccp_method_ind,
      { "SCCP method indicator",  "bicc.backw_call_sccp_method_indicator",
        FT_UINT16, BASE_HEX, VALS(bicc_SCCP_method_ind_value), PO_16BIT_MASK,
        NULL, HFILL }},
    { &hf_bicc_forw_call_end_to_end_info_indicator,
      { "End-to-end information indicator",  "bicc.forw_call_end_to_end_information_indicator",
        FT_BOOLEAN, 16, TFS(&bicc_end_to_end_info_ind_value), E_16BIT_MASK,
        NULL, HFILL }},
    { &hf_bicc_forw_call_isdn_user_part_indicator,
      { "BICC indicator",  "bicc.forw_call_isdn_user_part_indicator",
        FT_BOOLEAN, 16, TFS(&bicc_ISDN_user_part_ind_value), F_16BIT_MASK,
        NULL, HFILL }},
    { &hf_bicc_forw_call_preferences_indicator,
      { "BICC preference indicator",  "bicc.forw_call_preferences_indicator",
        FT_UINT16, BASE_HEX, VALS(bicc_preferences_ind_value), HG_16BIT_MASK,
        NULL, HFILL }},
    { &hf_bicc_forw_call_sccp_method_indicator,
      { "SCCP method indicator",  "bicc.forw_call_sccp_method_indicator",
        FT_UINT16, BASE_HEX, VALS(bicc_SCCP_method_ind_value), KJ_16BIT_MASK,
        NULL, HFILL }},
  };

/* Setup protocol subtree array */
  static int *ett[] = {
    &ett_bicc
  };

  proto_bicc = proto_register_protocol("Bearer Independent Call Control",
                                       "BICC", "bicc");

  bicc_handle = register_dissector("bicc", dissect_bicc, proto_bicc);

/* Required function calls to register the header fields and subtrees used */
  proto_register_field_array(proto_bicc, hf, array_length(hf));
  proto_register_subtree_array(ett, array_length(ett));

  reassembly_table_register(&isup_apm_msg_reassembly_table,
                         &addresses_reassembly_table_functions);

}

/* Register isup with the sub-laying MTP L3 dissector */
void
proto_reg_handoff_bicc(void)
{
  sdp_handle     = find_dissector_add_dependency("sdp", proto_isup);
  q931_ie_handle = find_dissector_add_dependency("q931.ie", proto_isup);

  dissector_add_uint("mtp3.service_indicator", MTP_SI_BICC, bicc_handle);
  dissector_add_uint("sctp.ppi", BICC_PAYLOAD_PROTOCOL_ID, bicc_handle);
}

/*
 * Editor modelines
 *
 * Local Variables:
 * c-basic-offset: 2
 * tab-width: 8
 * indent-tabs-mode: nil
 * End:
 *
 * ex: set shiftwidth=2 tabstop=8 expandtab:
 * :indentSize=2:tabSize=8:noTabs=true:
 */
