WARNING: the argument --multi-file is deprecated. This is not fatal, as GenProg can handle certain deprecated options as of the March 2012 refactor.
However, you may want to consult the GenProg documentation to avoid using 
deprecated options in the future, and verify that your config is doing what you
think it is doing.WARNING: the argument --suffix-extension is deprecated. This is not fatal, as GenProg can handle certain deprecated options as of the March 2012 refactor.
However, you may want to consult the GenProg documentation to avoid using 
deprecated options in the future, and verify that your config is doing what you
think it is doing.WARNING: the argument --mutp is deprecated. This is not fatal, as GenProg can handle certain deprecated options as of the March 2012 refactor.
However, you may want to consult the GenProg documentation to avoid using 
deprecated options in the future, and verify that your config is doing what you
think it is doing.--allow-coverage-fail false
--appp 0.33333
--asm-code-only false
--best-edit-rule "1 * fault_loc_weight ; 1 * max_test_fail_prob ; -1 * num_tests"
--best-test-rule "1 * test_fail_prob ; 1 * test_fail_count ; -1 * test_pass_count"
--compiler "gcc"
--compiler-command "perl compile.pl __EXE_NAME__ > /dev/null"
--compiler-opts ""
--continue false
--coverage-info ""
--coverage-per-test false
--crossover "subset"
--crossp 0.5
--delp 0.33333
--describe-machine true
--diversity-selection 0
--edit-script false
--elf-risc false
--exp-diff false
--fault-file ""
--fault-path "coverage.path.neg"
--fault-scheme "path"
--fitness-in-parallel 1
--fix-file ""
--fix-oracle ""
--fix-path "coverage.path.pos"
--fix-scheme "default"
--flatten-path ""
--format "txt"
--gen-per-exchange 1
--generations 10
--gui false
--hostname "127.0.0.1"
--ignore-dead-code true
--ignore-equiv-appends true
--ignore-standard-headers true
--ignore-string-equiv-fixes true
--ignore-untyped-returns true
--incoming-pop ""
--keep-source false
--label-repair false
--max-evals 0
--minimization false
--mt-cov false
--multiopt-minimize false
--multiopt-no-inf false
--neg-tests 52
--neg-weight 1
--negative-test-weight 2
--neutral-walk-max-size 0
--neutral-walk-weight ""
--nht-id "global"
--nht-port 51000
--nht-server ""
--no-rep-cache false
--no-test-cache false
--num-comps 2
--num-objectives 2
--oracle-genome ""
--popsize 40
--port 60000
--pos-tests 5
--pos-weight 0.1
--prefix "preprocessed"
--preprocessor ""
--print-incremental-evals false
--print-source-name false
--program "bugged-program.txt"
--promut 1
--quiet false
--regen-paths false
--rep "cilpatch"
--rep-cache "default.cache"
--repp 0
--samp-strat "variant"
--sample 1
--sample-runs 100
--sanity "yes"
--search "ww"
--seed 1
--semantic-check "scope"
--single-fitness false
--skip-failed-sanity-tests true
--skip-tests ""
--split-search 0
--sport 65000
--subatom-constp 0.5
--subatom-mutp 0
--super-mutant true
--super-mutant-size 50
--swap-bug false
--swapp 0.33333
--template-cache ""
--templates ""
--test-command "__TEST_SCRIPT__ __TEST_NAME__ >& /dev/null"
--test-script "./test.sh"
--tournament-size 2
--tweet false
--uniq false
--valgrind false
--variants-exchanged 50
uname -a: Linux ip-10-66-7-230 2.6.34.7-61.fc13.i686.PAE #1 SMP Tue Oct 19 04:24:06 UTC 2010 i686 i686 i386 GNU/Linux
date: Tue May  7 23:32:22 EDT 2013
id: uid=0(root) gid=0(root) groups=0(root),1(bin),2(daemon),3(sys),4(adm),6(disk),10(wheel) context=system_u:system_r:kernel_t:s0
cat /etc/redhat-release: Fedora release 13 (Goddard)
grep 'model name' /proc/cpuinfo: model name	: Intel(R) Xeon(R) CPU           E5506  @ 2.13GHz
grep 'MemTotal' /proc/meminfo: MemTotal:        1747596 kB
grep 'SwapTotal' /proc/meminfo: SwapTotal:             0 kB
cilRep: preprocessing IO function signatures: /tmp/tmpbfbb4a.c /tmp/tmpe37b37.c
cilRep: done preprocessing IO function signatures
Exception in loading: Sys_error("default.cache: No such file or directory")
cilrep: from_source: pre: stmt_count = 1
cilRep: preprocessed/epan/dissectors/packet-dns.c: parsing
cilRep: preprocessed/epan/dissectors/packet-dns.c: parsed (0.565659 MB)
cilRep: computing liveness
Bug: BF(Liveness): stmtStartData is not initialized for -1: bad_rr: 
#line 3003 "packet-dns.c"
proto_item_append_text(trr, ", bad RR length %d, too short", data_len);
#line 3007
data_offset += (int )data_len;
Liveness failed on function:
 static int dissect_dns_answer(tvbuff_t *tvb , int offsetx ,
                               int dns_data_offset , column_info *cinfo ,
                               proto_tree *dns_tree , packet_info *pinfo ,
                               gboolean is_mdns ) 
{ int len ;
  guchar const   *name ;
  gchar *name_out ;
  int name_len ;
  int type ;
  int class ;
  int flush ;
  char const   *class_name ;
  char const   *type_name ;
  int data_offset ;
  int cur_offset ;
  int data_start ;
  guint ttl ;
  gushort data_len ;
  proto_tree *rr_tree ;
  proto_item *trr ;
  size_t tmp ;
  guint8 const   *addr ;
  guint32 addr_int ;
  gchar const   *tmp___0 ;
  gchar const   *tmp___1 ;
  guchar const   *ns_name ;
  int ns_name_len ;
  size_t tmp___2 ;
  guchar const   *cname ;
  int cname_len ;
  size_t tmp___3 ;
  guchar const   *mname ;
  int mname_len ;
  guchar const   *rname ;
  int rname_len ;
  guint32 serial ;
  guint32 refresh ;
  guint32 retry ;
  guint32 expire ;
  guint32 minimum ;
  size_t tmp___4 ;
  size_t tmp___5 ;
  gchar *tmp___6 ;
  gchar *tmp___7 ;
  gchar *tmp___8 ;
  gchar *tmp___9 ;
  guchar const   *pname ;
  int pname_len ;
  size_t tmp___10 ;
  int rr_len ;
  guint8 const   *wks_addr ;
  guint8 protocol ;
  guint8 bits ;
  int mask ;
  int port_num ;
  int i ;
  emem_strbuf_t *bitnames ;
  emem_strbuf_t *tmp___11 ;
  gchar const   *tmp___12 ;
  gchar const   *tmp___13 ;
  gchar const   *tmp___14 ;
  char const   *tmp___15 ;
  gchar *tmp___16 ;
  gchar *tmp___17 ;
  int cpu_offset ;
  int cpu_len ;
  guint8 const   *cpu ;
  int os_offset ;
  int os_len ;
  guint8 const   *os ;
  guint8 tmp___18 ;
  guint8 tmp___19 ;
  guint16 preference ;
  guchar const   *mx_name ;
  int mx_name_len ;
  size_t tmp___20 ;
  int rr_len___0 ;
  int txt_offset ;
  int txt_len ;
  guint8 tmp___21 ;
  guint8 const   *tmp___22 ;
  int rr_len___1 ;
  guint16 type_covered ;
  nstime_t nstime ;
  guchar const   *signer_name ;
  int signer_name_len ;
  char *tmp___23 ;
  guint8 tmp___24 ;
  gchar const   *tmp___25 ;
  guint8 tmp___26 ;
  guint32 tmp___27 ;
  gchar *tmp___28 ;
  guint32 tmp___29 ;
  gchar *tmp___30 ;
  guint32 tmp___31 ;
  gchar *tmp___32 ;
  guint16 tmp___33 ;
  size_t tmp___34 ;
  gchar *tmp___35 ;
  int rr_len___2 ;
  guint16 flags ;
  proto_item *tf ;
  proto_tree *flags_tree ;
  guint8 algo ;
  guint16 key_id ;
  char const   *tmp___36 ;
  char const   *tmp___37 ;
  char const   *tmp___38 ;
  guint8 tmp___39 ;
  gchar const   *tmp___40 ;
  int rr_len___3 ;
  guint16 flags___0 ;
  proto_item *tf___0 ;
  proto_tree *flags_tree___0 ;
  guint8 algo___0 ;
  guint16 key_id___0 ;
  char const   *tmp___41 ;
  char const   *tmp___42 ;
  char const   *tmp___43 ;
  char const   *tmp___44 ;
  char const   *tmp___45 ;
  char const   *tmp___46 ;
  char const   *tmp___47 ;
  char const   *tmp___48 ;
  guint8 tmp___49 ;
  gchar const   *tmp___50 ;
  int rr_len___4 ;
  guint8 gw_type ;
  guint8 algo___1 ;
  guint8 const   *addr___0 ;
  guchar const   *gw ;
  int gw_name_len ;
  guint8 tmp___51 ;
  gchar const   *tmp___52 ;
  gchar const   *tmp___53 ;
  gchar *tmp___54 ;
  size_t tmp___55 ;
  gchar *tmp___56 ;
  guint8 const   *addr6 ;
  struct e_in6_addr addr_in6 ;
  gchar *tmp___57 ;
  gchar *tmp___58 ;
  gchar *tmp___59 ;
  unsigned short pre_len ;
  unsigned short suf_len ;
  unsigned short suf_octet_count ;
  guchar const   *pname___0 ;
  int pname_len___0 ;
  int a6_offset ;
  int suf_offset ;
  struct e_in6_addr suffix ;
  guint8 tmp___60 ;
  size_t tmp___61 ;
  gchar *tmp___62 ;
  gchar *tmp___63 ;
  gchar *tmp___64 ;
  guchar const   *dname ;
  int dname_len ;
  size_t tmp___65 ;
  guint8 version ;
  double tmp___66 ;
  double tmp___67 ;
  double tmp___68 ;
  char *tmp___69 ;
  char *tmp___70 ;
  guint32 tmp___71 ;
  int rr_len___5 ;
  guchar const   *next_domain_name ;
  int next_domain_name_len ;
  size_t tmp___72 ;
  int tmp___73 ;
  int rr_len___6 ;
  int initial_offset ;
  guint8 salt_len ;
  guint8 hash_len ;
  proto_item *flags_item ;
  proto_tree *flags_tree___1 ;
  int tmp___74 ;
  int tmp___75 ;
  int tmp___76 ;
  int tmp___77 ;
  int salt_len___0 ;
  guint8 tmp___78 ;
  int rr_len___7 ;
  guchar const   *next_domain_name___0 ;
  int next_domain_name_len___0 ;
  int rr_type ;
  guint8 bits___0 ;
  int mask___0 ;
  int i___0 ;
  size_t tmp___79 ;
  char *tmp___80 ;
  guint16 preference___0 ;
  guchar const   *kx_name ;
  int kx_name_len ;
  size_t tmp___81 ;
  guint16 cert_type ;
  guint16 cert_keytag ;
  guint8 cert_keyalg ;
  int rr_len___8 ;
  gchar const   *tmp___82 ;
  gchar const   *tmp___83 ;
  guint16 keytag ;
  guint16 digest_data_size ;
  guint8 ds_algorithm ;
  guint8 ds_digest ;
  int rr_len___9 ;
  gchar const   *tmp___84 ;
  gchar const   *tmp___85 ;
  guchar const   *tkey_algname ;
  int tkey_algname_len ;
  guint16 tkey_mode ;
  guint16 tkey_error ;
  guint16 tkey_keylen ;
  guint16 tkey_otherlen ;
  int rr_len___10 ;
  nstime_t nstime___0 ;
  proto_tree *key_tree ;
  proto_item *key_item ;
  size_t tmp___86 ;
  gchar *tmp___87 ;
  guint32 tmp___88 ;
  gchar *tmp___89 ;
  guint32 tmp___90 ;
  gchar *tmp___91 ;
  gchar const   *tmp___92 ;
  gchar const   *tmp___93 ;
  gchar const   *tmp___94 ;
  tvbuff_t *gssapi_tvb ;
  gint tmp___95 ;
  guint16 tsig_error ;
  guint16 tsig_timehi ;
  guint16 tsig_siglen ;
  guint16 tsig_otherlen ;
  guint32 tsig_timelo ;
  guchar const   *tsig_raw_algname ;
  char *tsig_algname ;
  int tsig_algname_len ;
  nstime_t nstime___1 ;
  int rr_len___11 ;
  size_t tmp___96 ;
  char const   *tmp___97 ;
  gchar *tmp___98 ;
  proto_item *mac_item ;
  proto_tree *mac_tree ;
  tvbuff_t *sub_tvb ;
  guint tmp___99 ;
  gboolean tmp___100 ;
  gchar const   *tmp___101 ;
  gchar const   *tmp___102 ;
  int rr_len___12 ;
  guint32 local_flag ;
  guint32 lookup_timeout ;
  guint32 cache_timeout ;
  guint32 nservers ;
  char const   *tmp___103 ;
  guint8 const   *tmp___104 ;
  gchar const   *tmp___105 ;
  int rr_len___13 ;
  guint32 local_flag___0 ;
  guint32 lookup_timeout___0 ;
  guint32 cache_timeout___0 ;
  guchar const   *dname___0 ;
  int dname_len___0 ;
  char const   *tmp___106 ;
  size_t tmp___107 ;
  guint16 priority ;
  guint16 weight ;
  guint16 port ;
  guchar const   *target ;
  int target_len ;
  size_t tmp___108 ;
  int offset ;
  guint16 order ;
  guint16 preference___1 ;
  gchar *flags___1 ;
  guint8 flags_len ;
  guchar *service ;
  guint8 service_len ;
  guchar *regex ;
  guint8 regex_len ;
  guchar const   *replacement ;
  int replacement_len ;
  guint8 *tmp___109 ;
  size_t tmp___110 ;
  guint8 sshfp_algorithm ;
  guint8 sshfp_type ;
  int rr_len___14 ;
  gchar const   *tmp___111 ;
  gchar const   *tmp___112 ;
  guint8 hit_len ;
  guint8 algo___2 ;
  guint16 pk_len ;
  int rr_len___15 ;
  int rendezvous_len ;
  guchar const   *rend_server_dns_name ;
  gchar const   *tmp___113 ;
  size_t tmp___114 ;
  gchar *tmp___115 ;
  int rr_len___16 ;
  guint16 afamily ;
  guint8 afdpart_len ;
  guint8 *addr_copy ;
  gchar const   *tmp___116 ;
  guint8 tmp___117 ;
  void *tmp___118 ;
  void *tmp___119 ;
  gchar *tmp___120 ;
  gchar const   *tmp___121 ;
  gchar const   *tmp___122 ;
  gchar const   *tmp___123 ;
  guint8 long_len ;
  guint8 lat_len ;
  guint8 alt_len ;
  guint8 const   *tmp___124 ;
  guint8 const   *tmp___125 ;
  guint8 const   *tmp___126 ;
  int mbox_dname_len ;
  int txt_dname_len ;
  guchar const   *mbox_dname ;
  guchar const   *txt_dname ;
  size_t tmp___127 ;
  gchar *tmp___128 ;
  size_t tmp___129 ;
  gchar *tmp___130 ;
  guint16 subtype ;
  guchar const   *host_name ;
  int host_name_len ;
  char const   *tmp___131 ;
  size_t tmp___132 ;
  gchar *tmp___133 ;
  char const   *tmp___134 ;
  guint8 x25_len ;
  guint8 const   *tmp___135 ;
  guint8 isdn_address_len ;
  guint8 isdn_sa_len ;
  int rr_len___17 ;
  guint8 const   *tmp___136 ;
  guint8 const   *tmp___137 ;
  int px_map822_len ;
  int px_mapx400_len ;
  guchar const   *px_map822_dnsname ;
  guchar const   *px_mapx400_dnsname ;
  guint16 tmp___138 ;
  size_t tmp___139 ;
  gchar *tmp___140 ;
  size_t tmp___141 ;
  gchar *tmp___142 ;
  int nsap_ptr_owner_len ;
  guchar const   *nsap_ptr_owner ;
  size_t tmp___143 ;
  gchar *tmp___144 ;
  int hostname_len ;
  guchar const   *hostname_str ;
  size_t tmp___145 ;
  gchar *tmp___146 ;
  int rmailbx_len ;
  int emailbx_len ;
  guchar const   *rmailbx_str ;
  guchar const   *emailbx_str ;
  size_t tmp___147 ;
  gchar *tmp___148 ;
  size_t tmp___149 ;
  gchar *tmp___150 ;

  {
   1692: /* CIL Label */ 
#line 1200
  rr_tree = (proto_tree *)((void *)0);
   1693: /* CIL Label */ 
#line 1201
  trr = (proto_item *)((void *)0);
   1694: /* CIL Label */ 
#line 1203
  data_offset = offsetx;
   1695: /* CIL Label */ 
#line 1203
  data_start = data_offset;
   1696: /* CIL Label */ 
#line 1204
  cur_offset = offsetx;
   1697: /* CIL Label */ 
#line 1206
  len = get_dns_name_type_class(tvb, offsetx, dns_data_offset, & name,
                                & name_len, & type, & class);
   1698: /* CIL Label */ 
#line 1208
  data_offset += len;
   1699: /* CIL Label */ 
#line 1209
  cur_offset += len;
   1700: /* CIL Label */ 
#line 1210
  if (is_mdns) {
#line 1212
    flush = class & (1 << 15);
#line 1213
    class &= ~ (1 << 15);
  } else {
#line 1215
    flush = 0;
  }
   1701: /* CIL Label */ 
#line 1217
  type_name = dns_type_name((unsigned int )type);
   1702: /* CIL Label */ 
#line 1218
  class_name = dns_class_name(class);
   1703: /* CIL Label */ 
#line 1220
  ttl = tvb_get_ntohl(tvb, data_offset);
   1704: /* CIL Label */ 
#line 1221
  data_offset += 4;
   1705: /* CIL Label */ 
#line 1222
  cur_offset += 4;
   1706: /* CIL Label */ 
#line 1224
  data_len = tvb_get_ntohs(tvb, data_offset);
   1707: /* CIL Label */ 
#line 1225
  data_offset += 2;
   1708: /* CIL Label */ 
#line 1226
  cur_offset += 2;
   1709: /* CIL Label */ 
#line 1228
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 1229
    col_append_fstr(cinfo, 38, " %s", type_name);
#line 1230
    if (is_mdns) {
#line 1230
      if (flush) {
#line 1231
        col_append_str(cinfo, 38, ", cache flush");
      } else {

      }
    } else {

    }
  } else {

  }
   1710: /* CIL Label */ 
#line 1233
  if ((unsigned int )dns_tree != (unsigned int )((void *)0)) {
#line 1238
    tmp = strlen((char const   *)name);
#line 1238
    name_out = format_text(name, tmp);
#line 1239
    if (type != 41) {
#line 1240
      trr = proto_tree_add_text(dns_tree, tvb, offsetx,
                                (data_offset - data_start) + (int )data_len,
                                "%s: type %s, class %s", name_out, type_name,
                                class_name);
#line 1244
      rr_tree = add_rr_to_tree(trr, ett_dns_rr, tvb, offsetx, name, name_len,
                               type, class, flush, ttl, data_len, is_mdns);
    } else {
#line 1247
      trr = proto_tree_add_text(dns_tree, tvb, offsetx,
                                (data_offset - data_start) + (int )data_len,
                                "%s: type %s", name_out, type_name);
#line 1250
      rr_tree = add_opt_rr_to_tree(trr, ett_dns_rr, tvb, offsetx,
                                   (char const   *)name, name_len, type, class,
                                   flush, ttl, data_len, is_mdns);
    }
#line 1253
    if (is_mdns) {
#line 1253
      if (flush) {
#line 1254
        proto_item_append_text(trr, ", cache flush");
      } else {

      }
    } else {

    }
  } else {

  }
   1711: /* CIL Label */ 
#line 1257
  if ((int )data_len == 0) {
#line 1258
    return (data_offset - data_start);
  } else {

  }
   0: /* CIL Label */ 
#line 1260
  switch (type) {
  case 1: 
#line 1267
  addr = tvb_get_ptr(tvb, cur_offset, 4);
#line 1268
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 1269
    tmp___0 = ip_to_str(addr);
#line 1269
    col_append_fstr(cinfo, 38, " %s", tmp___0);
  } else {

  }
#line 1271
  tmp___1 = ip_to_str(addr);
#line 1271
  proto_item_append_text(trr, ", addr %s", tmp___1);
#line 1272
  proto_tree_add_item(rr_tree, hf_dns_rr_addr, tvb, cur_offset, 4, 0U);
#line 1274
  if ((class & 0x7f) == 1) {
#line 1275
    memcpy((void */* __restrict  */)(& addr_int),
           (void const   */* __restrict  */)addr, sizeof(addr_int));
#line 1276
    add_ipv4_name(addr_int, (gchar const   *)name);
  } else {

  }
#line 1279
  break;
  case 2: 
#line 1286
  ns_name_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset, & ns_name);
#line 1287
  tmp___2 = strlen((char const   *)ns_name);
#line 1287
  name_out = format_text(ns_name, tmp___2);
#line 1288
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 1289
    col_append_fstr(cinfo, 38, " %s", name_out);
  } else {

  }
#line 1291
  proto_item_append_text(trr, ", ns %s", name_out);
#line 1292
  proto_tree_add_string(rr_tree, hf_dns_rr_ns, tvb, cur_offset, ns_name_len,
                        (char const   *)name_out);
#line 1295
  break;
  case 5: 
#line 1302
  cname_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset, & cname);
#line 1303
  tmp___3 = strlen((char const   *)cname);
#line 1303
  name_out = format_text(cname, tmp___3);
#line 1304
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 1305
    col_append_fstr(cinfo, 38, " %s", name_out);
  } else {

  }
#line 1307
  proto_item_append_text(trr, ", cname %s", name_out);
#line 1308
  proto_tree_add_string(rr_tree, hf_dns_rr_primaryname, tvb, cur_offset,
                        cname_len, (char const   *)name_out);
#line 1311
  break;
  case 6: 
#line 1326
  mname_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset, & mname);
#line 1327
  tmp___4 = strlen((char const   *)mname);
#line 1327
  name_out = format_text(mname, tmp___4);
#line 1328
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 1329
    col_append_fstr(cinfo, 38, " %s", name_out);
  } else {

  }
#line 1331
  proto_item_append_text(trr, ", mname %s", name_out);
#line 1332
  proto_tree_add_text(rr_tree, tvb, cur_offset, mname_len,
                      "Primary name server: %s", name_out);
#line 1334
  cur_offset += mname_len;
#line 1337
  rname_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset, & rname);
#line 1338
  tmp___5 = strlen((char const   *)rname);
#line 1338
  name_out = format_text(rname, tmp___5);
#line 1339
  proto_tree_add_text(rr_tree, tvb, cur_offset, rname_len,
                      "Responsible authority\'s mailbox: %s", name_out);
#line 1341
  cur_offset += rname_len;
#line 1343
  serial = tvb_get_ntohl(tvb, cur_offset);
#line 1344
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Serial number: %u", serial);
#line 1346
  cur_offset += 4;
#line 1348
  refresh = tvb_get_ntohl(tvb, cur_offset);
#line 1349
  tmp___6 = time_secs_to_str((int )refresh);
#line 1349
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Refresh interval: %s",
                      tmp___6);
#line 1351
  cur_offset += 4;
#line 1353
  retry = tvb_get_ntohl(tvb, cur_offset);
#line 1354
  tmp___7 = time_secs_to_str((int )retry);
#line 1354
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Retry interval: %s", tmp___7);
#line 1356
  cur_offset += 4;
#line 1358
  expire = tvb_get_ntohl(tvb, cur_offset);
#line 1359
  tmp___8 = time_secs_to_str((int )expire);
#line 1359
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Expiration limit: %s",
                      tmp___8);
#line 1361
  cur_offset += 4;
#line 1363
  minimum = tvb_get_ntohl(tvb, cur_offset);
#line 1364
  tmp___9 = time_secs_to_str((int )minimum);
#line 1364
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Minimum TTL: %s", tmp___9);
#line 1368
  break;
  case 12: 
#line 1376
  pname_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset, & pname);
#line 1377
  tmp___10 = strlen((char const   *)pname);
#line 1377
  name_out = format_text(pname, tmp___10);
#line 1378
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 1379
    col_append_fstr(cinfo, 38, " %s", name_out);
  } else {

  }
#line 1381
  proto_item_append_text(trr, ", %s", name_out);
#line 1382
  proto_tree_add_text(rr_tree, tvb, cur_offset, pname_len, "Domain name: %s",
                      name_out);
#line 1386
  break;
  case 11: 
#line 1390
  rr_len = (int )data_len;
#line 1397
  tmp___11 = ep_strbuf_new_label((gchar const   *)((void *)0));
#line 1397
  bitnames = tmp___11;
#line 1399
  if (rr_len < 4) {
    goto bad_rr;
#line 1402
    break;
  } else {

  }
#line 1404
  wks_addr = tvb_get_ptr(tvb, cur_offset, 4);
#line 1405
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 1406
    tmp___12 = ip_to_str(wks_addr);
#line 1406
    col_append_fstr(cinfo, 38, " %s", tmp___12);
  } else {

  }
#line 1408
  tmp___13 = ip_to_str(wks_addr);
#line 1408
  proto_item_append_text(trr, ", addr %s", tmp___13);
#line 1409
  tmp___14 = ip_to_str(wks_addr);
#line 1409
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Addr: %s", tmp___14);
#line 1411
  cur_offset += 4;
#line 1412
  rr_len -= 4;
#line 1414
  if (rr_len < 1) {
    goto bad_rr;
  } else {

  }
#line 1416
  protocol = tvb_get_guint8(tvb, cur_offset);
#line 1417
  tmp___15 = ipprotostr((int )protocol);
#line 1417
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Protocol: %s", tmp___15);
#line 1419
  cur_offset ++;
#line 1420
  rr_len --;
#line 1422
  port_num = 0;
#line 1423
  while (rr_len != 0) {
#line 1424
    bits = tvb_get_guint8(tvb, cur_offset);
#line 1425
    if ((int )bits != 0) {
#line 1426
      mask = 1 << 7;
#line 1427
      ep_strbuf_truncate(bitnames, 0U);
#line 1428
      i = 0;
#line 1428
      while (i < 8) {
#line 1429
        if ((int )bits & mask) {
#line 1430
          if (bitnames->len > 0U) {
#line 1431
            ep_strbuf_append(bitnames, ", ");
          } else {

          }
#line 1433
          switch ((int )protocol) {
          case 6: 
#line 1436
          tmp___16 = get_tcp_port((unsigned int )port_num);
#line 1436
          ep_strbuf_append(bitnames, (gchar const   *)tmp___16);
#line 1437
          break;
          case 17: 
#line 1440
          tmp___17 = get_udp_port((unsigned int )port_num);
#line 1440
          ep_strbuf_append(bitnames, (gchar const   *)tmp___17);
#line 1441
          break;
          default: 
#line 1444
          ep_strbuf_append_printf(bitnames, "%u", port_num);
#line 1445
          break;
          }
        } else {

        }
#line 1448
        mask >>= 1;
#line 1449
        port_num ++;
#line 1428
        i ++;
      }
#line 1451
      proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Bits: 0x%02x (%s)",
                          bits, bitnames->str);
    } else {
#line 1454
      port_num += 8;
    }
#line 1455
    cur_offset ++;
#line 1456
    rr_len --;
  }
#line 1460
  break;
  case 13: 
#line 1471
  cpu_offset = cur_offset;
#line 1472
  tmp___18 = tvb_get_guint8(tvb, cpu_offset);
#line 1472
  cpu_len = (int )tmp___18;
#line 1473
  cpu = tvb_get_ptr(tvb, cpu_offset + 1, cpu_len);
#line 1474
  os_offset = (cpu_offset + 1) + cpu_len;
#line 1475
  tmp___19 = tvb_get_guint8(tvb, os_offset);
#line 1475
  os_len = (int )tmp___19;
#line 1476
  os = tvb_get_ptr(tvb, os_offset + 1, os_len);
#line 1477
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 1478
    col_append_fstr(cinfo, 38, " %.*s %.*s", cpu_len, cpu, os_len, os);
  } else {

  }
#line 1481
  proto_item_append_text(trr, ", CPU %.*s, OS %.*s", cpu_len, cpu, os_len, os);
#line 1483
  proto_tree_add_text(rr_tree, tvb, cpu_offset, 1 + cpu_len, "CPU: %.*s",
                      cpu_len, cpu);
#line 1485
  proto_tree_add_text(rr_tree, tvb, os_offset, 1 + os_len, "OS: %.*s", os_len,
                      os);
#line 1489
  break;
  case 15: 
#line 1493
  preference = (guint16 )0;
#line 1497
  preference = tvb_get_ntohs(tvb, cur_offset);
#line 1499
  mx_name_len = get_dns_name(tvb, cur_offset + 2, 0, dns_data_offset, & mx_name);
#line 1500
  tmp___20 = strlen((char const   *)mx_name);
#line 1500
  name_out = format_text(mx_name, tmp___20);
#line 1501
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 1502
    col_append_fstr(cinfo, 38, " %u %s", preference, name_out);
  } else {

  }
#line 1504
  proto_item_append_text(trr, ", preference %u, mx %s", preference, name_out);
#line 1506
  proto_tree_add_text(rr_tree, tvb, cur_offset, 2, "Preference: %u", preference);
#line 1507
  proto_tree_add_text(rr_tree, tvb, cur_offset + 2, mx_name_len,
                      "Mail exchange: %s", name_out);
#line 1511
  break;
  case 16: 
  case 99: 
#line 1516
  rr_len___0 = (int )data_len;
#line 1521
  txt_offset = cur_offset;
#line 1522
  while (rr_len___0 != 0) {
#line 1523
    tmp___21 = tvb_get_guint8(tvb, txt_offset);
#line 1523
    txt_len = (int )tmp___21;
#line 1524
    tmp___22 = tvb_get_ptr(tvb, txt_offset + 1, txt_len);
#line 1524
    proto_tree_add_text(rr_tree, tvb, txt_offset, 1 + txt_len, "Text: %.*s",
                        txt_len, tmp___22);
#line 1526
    txt_offset += 1 + txt_len;
#line 1527
    rr_len___0 -= 1 + txt_len;
  }
#line 1531
  break;
  case 46: 
  case 24: 
#line 1536
  rr_len___1 = (int )data_len;
#line 1543
  if (rr_len___1 < 2) {
    goto bad_rr;
  } else {

  }
#line 1545
  type_covered = tvb_get_ntohs(tvb, cur_offset);
#line 1546
  tmp___23 = dns_type_description((unsigned int )type_covered);
#line 1546
  proto_tree_add_text(rr_tree, tvb, cur_offset, 2, "Type covered: %s", tmp___23);
#line 1548
  cur_offset += 2;
#line 1549
  rr_len___1 -= 2;
#line 1551
  if (rr_len___1 < 1) {
    goto bad_rr;
  } else {

  }
#line 1553
  tmp___24 = tvb_get_guint8(tvb, cur_offset);
#line 1553
  tmp___25 = val_to_str((unsigned int )tmp___24, algo_vals, "Unknown (0x%02X)");
#line 1553
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Algorithm: %s", tmp___25);
#line 1556
  cur_offset ++;
#line 1557
  rr_len___1 --;
#line 1559
  if (rr_len___1 < 1) {
    goto bad_rr;
  } else {

  }
#line 1561
  tmp___26 = tvb_get_guint8(tvb, cur_offset);
#line 1561
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Labels: %u", tmp___26);
#line 1563
  cur_offset ++;
#line 1564
  rr_len___1 --;
#line 1566
  if (rr_len___1 < 4) {
    goto bad_rr;
  } else {

  }
#line 1568
  tmp___27 = tvb_get_ntohl(tvb, cur_offset);
#line 1568
  tmp___28 = time_secs_to_str((int )tmp___27);
#line 1568
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Original TTL: %s", tmp___28);
#line 1570
  cur_offset += 4;
#line 1571
  rr_len___1 -= 4;
#line 1573
  if (rr_len___1 < 4) {
    goto bad_rr;
  } else {

  }
#line 1575
  tmp___29 = tvb_get_ntohl(tvb, cur_offset);
#line 1575
  nstime.secs = (long )tmp___29;
#line 1576
  nstime.nsecs = 0;
#line 1577
  tmp___30 = abs_time_to_str((nstime_t const   *)(& nstime),
                             (enum __anonenum_absolute_time_display_e_100 )1000,
                             1);
#line 1577
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Signature expiration: %s",
                      tmp___30);
#line 1579
  cur_offset += 4;
#line 1580
  rr_len___1 -= 4;
#line 1582
  if (rr_len___1 < 4) {
    goto bad_rr;
  } else {

  }
#line 1584
  tmp___31 = tvb_get_ntohl(tvb, cur_offset);
#line 1584
  nstime.secs = (long )tmp___31;
#line 1585
  nstime.nsecs = 0;
#line 1586
  tmp___32 = abs_time_to_str((nstime_t const   *)(& nstime),
                             (enum __anonenum_absolute_time_display_e_100 )1000,
                             1);
#line 1586
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Time signed: %s", tmp___32);
#line 1588
  cur_offset += 4;
#line 1589
  rr_len___1 -= 4;
#line 1591
  if (rr_len___1 < 2) {
    goto bad_rr;
  } else {

  }
#line 1593
  tmp___33 = tvb_get_ntohs(tvb, cur_offset);
#line 1593
  proto_tree_add_text(rr_tree, tvb, cur_offset, 2,
                      "Id of signing key(footprint): %u", tmp___33);
#line 1595
  cur_offset += 2;
#line 1596
  rr_len___1 -= 2;
#line 1599
  signer_name_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset,
                                 & signer_name);
#line 1600
  tmp___34 = strlen((char const   *)signer_name);
#line 1600
  tmp___35 = format_text(signer_name, tmp___34);
#line 1600
  proto_tree_add_text(rr_tree, tvb, cur_offset, signer_name_len,
                      "Signer\'s name: %s", tmp___35);
#line 1603
  cur_offset += signer_name_len;
#line 1604
  rr_len___1 -= signer_name_len;
#line 1606
  if (rr_len___1 != 0) {
#line 1607
    proto_tree_add_text(rr_tree, tvb, cur_offset, rr_len___1, "Signature");
  } else {

  }
#line 1610
  break;
  case 48: 
#line 1614
  rr_len___2 = (int )data_len;
#line 1622
  if (rr_len___2 < 2) {
    goto bad_rr;
  } else {

  }
#line 1624
  flags = tvb_get_ntohs(tvb, cur_offset);
#line 1625
  tf = proto_tree_add_text(rr_tree, tvb, cur_offset, 2, "Flags: 0x%04X", flags);
#line 1626
  flags_tree = proto_item_add_subtree(tf, ett_t_key_flags);
#line 1627
  tmp___36 = decode_boolean_bitfield((unsigned int )flags, 256U, 16,
                                     "This is the zone key for the specified zone",
                                     "This is not a zone key");
#line 1627
  proto_tree_add_text(flags_tree, tvb, cur_offset, 2, "%s", tmp___36);
#line 1631
  tmp___37 = decode_boolean_bitfield((unsigned int )flags, 128U, 16,
                                     "Key is revoked", "Key is not revoked");
#line 1631
  proto_tree_add_text(flags_tree, tvb, cur_offset, 2, "%s", tmp___37);
#line 1635
  tmp___38 = decode_boolean_bitfield((unsigned int )flags, 1U, 16,
                                     "Key is a Key Signing Key",
                                     "Key is a Zone Signing Key");
#line 1635
  proto_tree_add_text(flags_tree, tvb, cur_offset, 2, "%s", tmp___38);
#line 1640
  cur_offset += 2;
#line 1641
  rr_len___2 -= 2;
#line 1643
  if (rr_len___2 < 1) {
    goto bad_rr;
  } else {

  }
#line 1645
  tmp___39 = tvb_get_guint8(tvb, cur_offset);
#line 1645
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Protocol: %u", tmp___39);
#line 1647
  cur_offset ++;
#line 1648
  rr_len___2 --;
#line 1650
  if (rr_len___2 < 1) {
    goto bad_rr;
  } else {

  }
#line 1652
  algo = tvb_get_guint8(tvb, cur_offset);
#line 1653
  tmp___40 = val_to_str((unsigned int )algo, algo_vals, "Unknown (0x%02X)");
#line 1653
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Algorithm: %s", tmp___40);
#line 1655
  cur_offset ++;
#line 1656
  rr_len___2 --;
#line 1658
  key_id = compute_key_id(tvb, cur_offset - 4, rr_len___2 + 4, algo);
#line 1659
  proto_tree_add_text(rr_tree, tvb, 0, 0, "Key id: %u", key_id);
#line 1661
  if (rr_len___2 != 0) {
#line 1662
    proto_tree_add_text(rr_tree, tvb, cur_offset, rr_len___2, "Public key");
  } else {

  }
#line 1665
  break;
  case 25: 
#line 1669
  rr_len___3 = (int )data_len;
#line 1677
  if (rr_len___3 < 2) {
    goto bad_rr;
  } else {

  }
#line 1679
  flags___0 = tvb_get_ntohs(tvb, cur_offset);
#line 1680
  tf___0 = proto_tree_add_text(rr_tree, tvb, cur_offset, 2, "Flags: 0x%04X",
                               flags___0);
#line 1681
  flags_tree___0 = proto_item_add_subtree(tf___0, ett_t_key_flags);
#line 1682
  tmp___41 = decode_boolean_bitfield((unsigned int )flags___0, 32768U, 16,
                                     "Key prohibited for authentication",
                                     "Key allowed for authentication");
#line 1682
  proto_tree_add_text(flags_tree___0, tvb, cur_offset, 2, "%s", tmp___41);
#line 1686
  tmp___42 = decode_boolean_bitfield((unsigned int )flags___0, 16384U, 16,
                                     "Key prohibited for confidentiality",
                                     "Key allowed for confidentiality");
#line 1686
  proto_tree_add_text(flags_tree___0, tvb, cur_offset, 2, "%s", tmp___42);
#line 1690
  if (((int )flags___0 & 0xC000) != 0xC000) {
#line 1692
    tmp___43 = decode_boolean_bitfield((unsigned int )flags___0, 8192U, 16,
                                       "Key is experimental or optional",
                                       "Key is required");
#line 1692
    proto_tree_add_text(flags_tree___0, tvb, cur_offset, 2, "%s", tmp___43);
#line 1696
    tmp___44 = decode_boolean_bitfield((unsigned int )flags___0, 1024U, 16,
                                       "Key is associated with a user",
                                       "Key is not associated with a user");
#line 1696
    proto_tree_add_text(flags_tree___0, tvb, cur_offset, 2, "%s", tmp___44);
#line 1700
    tmp___45 = decode_boolean_bitfield((unsigned int )flags___0, 512U, 16,
                                       "Key is associated with the named entity",
                                       "Key is not associated with the named entity");
#line 1700
    proto_tree_add_text(flags_tree___0, tvb, cur_offset, 2, "%s", tmp___45);
#line 1704
    tmp___46 = decode_boolean_bitfield((unsigned int )flags___0, 128U, 16,
                                       "Key is valid for use with IPSEC",
                                       "Key is not valid for use with IPSEC");
#line 1704
    proto_tree_add_text(flags_tree___0, tvb, cur_offset, 2, "%s", tmp___46);
#line 1708
    tmp___47 = decode_boolean_bitfield((unsigned int )flags___0, 64U, 16,
                                       "Key is valid for use with MIME security multiparts",
                                       "Key is not valid for use with MIME security multiparts");
#line 1708
    proto_tree_add_text(flags_tree___0, tvb, cur_offset, 2, "%s", tmp___47);
#line 1712
    tmp___48 = decode_numeric_bitfield((unsigned int )flags___0, 15U, 16,
                                       "Signatory = %u");
#line 1712
    proto_tree_add_text(flags_tree___0, tvb, cur_offset, 2, "%s", tmp___48);
  } else {

  }
#line 1716
  cur_offset += 2;
#line 1717
  rr_len___3 -= 2;
#line 1719
  if (rr_len___3 < 1) {
    goto bad_rr;
  } else {

  }
#line 1721
  tmp___49 = tvb_get_guint8(tvb, cur_offset);
#line 1721
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Protocol: %u", tmp___49);
#line 1723
  cur_offset ++;
#line 1724
  rr_len___3 --;
#line 1726
  if (rr_len___3 < 1) {
    goto bad_rr;
  } else {

  }
#line 1728
  algo___0 = tvb_get_guint8(tvb, cur_offset);
#line 1729
  tmp___50 = val_to_str((unsigned int )algo___0, algo_vals, "Unknown (0x%02X)");
#line 1729
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Algorithm: %s", tmp___50);
#line 1731
  cur_offset ++;
#line 1732
  rr_len___3 --;
#line 1734
  key_id___0 = compute_key_id(tvb, cur_offset - 4, rr_len___3 + 4, algo___0);
#line 1735
  proto_tree_add_text(rr_tree, tvb, 0, 0, "Key id: %u", key_id___0);
#line 1737
  if (rr_len___3 != 0) {
#line 1738
    proto_tree_add_text(rr_tree, tvb, cur_offset, rr_len___3, "Public key");
  } else {

  }
#line 1741
  break;
  case 45: 
#line 1744
  rr_len___4 = (int )data_len;
#line 1757
  if (rr_len___4 < 3) {
    goto bad_rr;
  } else {

  }
#line 1760
  tmp___51 = tvb_get_guint8(tvb, cur_offset);
#line 1760
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Gateway precedence: %u",
                      tmp___51);
#line 1762
  cur_offset ++;
#line 1763
  rr_len___4 --;
#line 1765
  gw_type = tvb_get_guint8(tvb, cur_offset);
#line 1766
  cur_offset ++;
#line 1767
  rr_len___4 --;
#line 1769
  algo___1 = tvb_get_guint8(tvb, cur_offset);
#line 1770
  tmp___52 = val_to_str((unsigned int )algo___1, gw_algo, "Unknown (0x%02X)");
#line 1770
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Algorithm: %s", tmp___52);
#line 1772
  cur_offset ++;
#line 1773
  rr_len___4 --;
#line 1774
  switch ((int )gw_type) {
  case 0: 
#line 1776
  proto_tree_add_text(rr_tree, tvb, cur_offset, 0, "Gateway: no gateway");
#line 1777
  break;
  case 1: 
#line 1779
  addr___0 = tvb_get_ptr(tvb, cur_offset, 4);
#line 1780
  tmp___53 = ip_to_str(addr___0);
#line 1780
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Gateway: %s", tmp___53);
#line 1783
  cur_offset += 4;
#line 1784
  rr_len___4 -= 4;
#line 1785
  break;
  case 2: 
#line 1787
  addr___0 = tvb_get_ptr(tvb, cur_offset, 16);
#line 1788
  tmp___54 = ip6_to_str((struct e_in6_addr  const  *)addr___0);
#line 1788
  proto_tree_add_text(rr_tree, tvb, cur_offset, 16, "Gateway: %s", tmp___54);
#line 1791
  cur_offset += 16;
#line 1792
  rr_len___4 -= 16;
#line 1793
  break;
  case 3: 
#line 1796
  gw_name_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset, & gw);
#line 1797
  tmp___55 = strlen((char const   *)gw);
#line 1797
  tmp___56 = format_text(gw, tmp___55);
#line 1797
  proto_tree_add_text(rr_tree, tvb, cur_offset, gw_name_len, "Gateway: %s",
                      tmp___56);
#line 1800
  cur_offset += gw_name_len;
#line 1801
  rr_len___4 -= gw_name_len;
#line 1802
  break;
  default: 
#line 1804
  proto_tree_add_text(rr_tree, tvb, cur_offset, 0,
                      "Gateway: Unknown gateway type(%u)", gw_type);
#line 1805
  break;
  }
#line 1807
  if (rr_len___4 != 0) {
#line 1808
    proto_tree_add_text(rr_tree, tvb, cur_offset, rr_len___4, "Public key");
  } else {

  }
#line 1811
  break;
  case 28: 
#line 1818
  addr6 = tvb_get_ptr(tvb, cur_offset, 16);
#line 1819
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 1820
    tmp___57 = ip6_to_str((struct e_in6_addr  const  *)addr6);
#line 1820
    col_append_fstr(cinfo, 38, " %s", tmp___57);
  } else {

  }
#line 1824
  tmp___58 = ip6_to_str((struct e_in6_addr  const  *)addr6);
#line 1824
  proto_item_append_text(trr, ", addr %s", tmp___58);
#line 1826
  tmp___59 = ip6_to_str((struct e_in6_addr  const  *)addr6);
#line 1826
  proto_tree_add_text(rr_tree, tvb, cur_offset, 16, "Addr: %s", tmp___59);
#line 1829
  if ((class & 0x7f) == 1) {
#line 1830
    memcpy((void */* __restrict  */)(& addr_in6),
           (void const   */* __restrict  */)addr6, sizeof(addr_in6));
#line 1831
    add_ipv6_name((struct e_in6_addr  const  *)(& addr_in6),
                  (gchar const   *)name);
  } else {

  }
#line 1834
  break;
  case 38: 
#line 1847
  a6_offset = cur_offset;
#line 1848
  tmp___60 = tvb_get_guint8(tvb, cur_offset);
#line 1848
  pre_len = (unsigned short )tmp___60;
#line 1849
  cur_offset ++;
#line 1850
  suf_len = (unsigned short )(128 - (int )pre_len);
#line 1851
  if (suf_len) {
#line 1851
    suf_octet_count = (unsigned short )(((int )suf_len - 1) / 8 + 1);
  } else {
#line 1851
    suf_octet_count = (unsigned short)0;
  }
#line 1853
  suf_offset = 0;
#line 1853
  while (suf_offset < 16 - (int )suf_octet_count) {
#line 1854
    suffix.bytes[suf_offset] = (unsigned char)0;
#line 1853
    suf_offset ++;
  }
#line 1856
  while (suf_offset < 16) {
#line 1857
    suffix.bytes[suf_offset] = tvb_get_guint8(tvb, cur_offset);
#line 1858
    cur_offset ++;
#line 1856
    suf_offset ++;
  }
#line 1861
  if ((int )pre_len > 0) {
#line 1863
    pname_len___0 = get_dns_name(tvb, cur_offset, 0, dns_data_offset,
                                 & pname___0);
  } else {
#line 1866
    pname___0 = (guchar const   *)"";
#line 1867
    pname_len___0 = 0;
  }
#line 1869
  tmp___61 = strlen((char const   *)pname___0);
#line 1869
  name_out = format_text(pname___0, tmp___61);
#line 1871
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 1872
    tmp___62 = ip6_to_str((struct e_in6_addr  const  *)(& suffix));
#line 1872
    col_append_fstr(cinfo, 38, " %d %s %s", pre_len, tmp___62, name_out);
  } else {

  }
#line 1878
  proto_tree_add_text(rr_tree, tvb, a6_offset, 1, "Prefix len: %u", pre_len);
#line 1880
  a6_offset ++;
#line 1881
  if (suf_len) {
#line 1882
    tmp___63 = ip6_to_str((struct e_in6_addr  const  *)(& suffix));
#line 1882
    proto_tree_add_text(rr_tree, tvb, a6_offset, (int )suf_octet_count,
                        "Address suffix: %s", tmp___63);
#line 1885
    a6_offset += (int )suf_octet_count;
  } else {

  }
#line 1887
  if ((int )pre_len > 0) {
#line 1888
    proto_tree_add_text(rr_tree, tvb, a6_offset, pname_len___0,
                        "Prefix name: %s", name_out);
  } else {

  }
#line 1891
  tmp___64 = ip6_to_str((struct e_in6_addr  const  *)(& suffix));
#line 1891
  proto_item_append_text(trr, ", addr %d %s %s", pre_len, tmp___64, name_out);
#line 1897
  break;
  case 39: 
#line 1905
  dname_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset, & dname);
#line 1907
  tmp___65 = strlen((char const   *)dname);
#line 1907
  name_out = format_text(dname, tmp___65);
#line 1908
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 1909
    col_append_fstr(cinfo, 38, " %s", name_out);
  } else {

  }
#line 1911
  proto_item_append_text(trr, ", dname %s", name_out);
#line 1912
  proto_tree_add_text(rr_tree, tvb, cur_offset, dname_len, "Target name: %s",
                      name_out);
#line 1916
  break;
  case 29: 
#line 1923
  version = tvb_get_guint8(tvb, cur_offset);
#line 1924
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Version: %u", version);
#line 1925
  if ((int )version == 0) {
#line 1927
    cur_offset ++;
#line 1929
    tmp___66 = rfc1867_size(tvb, cur_offset);
#line 1929
    proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Size: %g m", tmp___66);
#line 1931
    cur_offset ++;
#line 1933
    tmp___67 = rfc1867_size(tvb, cur_offset);
#line 1933
    proto_tree_add_text(rr_tree, tvb, cur_offset, 1,
                        "Horizontal precision: %g m", tmp___67);
#line 1935
    cur_offset ++;
#line 1937
    tmp___68 = rfc1867_size(tvb, cur_offset);
#line 1937
    proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Vertical precision: %g m",
                        tmp___68);
#line 1939
    cur_offset ++;
#line 1941
    tmp___69 = rfc1867_angle(tvb, cur_offset, "NS");
#line 1941
    proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Latitude: %s", tmp___69);
#line 1943
    cur_offset += 4;
#line 1945
    tmp___70 = rfc1867_angle(tvb, cur_offset, "EW");
#line 1945
    proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Longitude: %s", tmp___70);
#line 1947
    cur_offset += 4;
#line 1949
    tmp___71 = tvb_get_ntohl(tvb, cur_offset);
#line 1949
    proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Altitude: %g m",
                        (double )((int )tmp___71 - 10000000) / 100.0);
  } else {
#line 1952
    proto_tree_add_text(rr_tree, tvb, cur_offset, (int )data_len, "Data");
  }
#line 1955
  break;
  case 47: 
#line 1959
  rr_len___5 = (int )data_len;
#line 1964
  next_domain_name_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset,
                                      & next_domain_name);
#line 1966
  tmp___72 = strlen((char const   *)next_domain_name);
#line 1966
  name_out = format_text(next_domain_name, tmp___72);
#line 1967
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 1968
    col_append_fstr(cinfo, 38, " %s", name_out);
  } else {

  }
#line 1970
  proto_item_append_text(trr, ", next domain name %s", name_out);
#line 1971
  proto_tree_add_text(rr_tree, tvb, cur_offset, next_domain_name_len,
                      "Next domain name: %s", name_out);
#line 1973
  cur_offset += next_domain_name_len;
#line 1974
  rr_len___5 -= next_domain_name_len;
#line 1975
  tmp___73 = dissect_type_bitmap(rr_tree, tvb, cur_offset, rr_len___5);
#line 1975
  cur_offset += tmp___73;
#line 1978
  break;
  case 50: 
#line 1982
  initial_offset = cur_offset;
#line 1988
  tmp___74 = cur_offset;
#line 1988
  cur_offset ++;
#line 1988
  proto_tree_add_item(rr_tree, hf_dns_nsec3_algo, tvb, tmp___74, 1, 0U);
#line 1989
  flags_item = proto_tree_add_item(rr_tree, hf_dns_nsec3_flags, tvb, cur_offset,
                                   1, 0U);
#line 1990
  flags_tree___1 = proto_item_add_subtree(flags_item, ett_nsec3_flags);
#line 1991
  proto_tree_add_item(flags_tree___1, hf_dns_nsec3_flag_optout, tvb, cur_offset,
                      1, 0U);
#line 1992
  cur_offset ++;
#line 1993
  proto_tree_add_item(rr_tree, hf_dns_nsec3_iterations, tvb, cur_offset, 2, 0U);
#line 1994
  cur_offset += 2;
#line 1995
  salt_len = tvb_get_guint8(tvb, cur_offset);
#line 1996
  tmp___75 = cur_offset;
#line 1996
  cur_offset ++;
#line 1996
  proto_tree_add_item(rr_tree, hf_dns_nsec3_salt_length, tvb, tmp___75, 1, 0U);
#line 1997
  proto_tree_add_item(rr_tree, hf_dns_nsec3_salt_value, tvb, cur_offset,
                      (int )salt_len, 0U);
#line 1998
  cur_offset += (int )salt_len;
#line 1999
  hash_len = tvb_get_guint8(tvb, cur_offset);
#line 2000
  tmp___76 = cur_offset;
#line 2000
  cur_offset ++;
#line 2000
  proto_tree_add_item(rr_tree, hf_dns_nsec3_hash_length, tvb, tmp___76, 1, 0U);
#line 2001
  proto_tree_add_item(rr_tree, hf_dns_nsec3_hash_value, tvb, cur_offset,
                      (int )hash_len, 0U);
#line 2002
  cur_offset += (int )hash_len;
#line 2003
  rr_len___6 = (int )data_len - (cur_offset - initial_offset);
#line 2004
  tmp___77 = dissect_type_bitmap(rr_tree, tvb, cur_offset, rr_len___6);
#line 2004
  cur_offset += tmp___77;
#line 2007
  break;
  case 51: 
#line 2012
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2013
    col_append_fstr(cinfo, 38, " %s", name);
  } else {

  }
#line 2016
  proto_tree_add_item(rr_tree, hf_dns_nsec3_algo, tvb, cur_offset, 1, 0U);
#line 2017
  cur_offset ++;
#line 2018
  proto_tree_add_item(rr_tree, hf_dns_nsec3_flags, tvb, cur_offset, 1, 0U);
#line 2019
  cur_offset ++;
#line 2020
  proto_tree_add_item(rr_tree, hf_dns_nsec3_iterations, tvb, cur_offset, 2, 0U);
#line 2021
  cur_offset += 2;
#line 2022
  tmp___78 = tvb_get_guint8(tvb, cur_offset);
#line 2022
  salt_len___0 = (int )tmp___78;
#line 2023
  proto_tree_add_item(rr_tree, hf_dns_nsec3_salt_length, tvb, cur_offset, 1, 0U);
#line 2024
  cur_offset ++;
#line 2025
  proto_tree_add_item(rr_tree, hf_dns_nsec3_salt_value, tvb, cur_offset,
                      salt_len___0, 0U);
#line 2028
  break;
  case 30: 
#line 2032
  rr_len___7 = (int )data_len;
#line 2041
  next_domain_name_len___0 = get_dns_name(tvb, cur_offset, 0, dns_data_offset,
                                          & next_domain_name___0);
#line 2043
  tmp___79 = strlen((char const   *)next_domain_name___0);
#line 2043
  name_out = format_text(next_domain_name___0, tmp___79);
#line 2044
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2045
    col_append_fstr(cinfo, 38, " %s", name_out);
  } else {

  }
#line 2047
  proto_item_append_text(trr, ", next domain name %s", name_out);
#line 2048
  proto_tree_add_text(rr_tree, tvb, cur_offset, next_domain_name_len___0,
                      "Next domain name: %s", name_out);
#line 2050
  cur_offset += next_domain_name_len___0;
#line 2051
  rr_len___7 -= next_domain_name_len___0;
#line 2052
  rr_type = 0;
#line 2053
  while (rr_len___7 != 0) {
#line 2054
    bits___0 = tvb_get_guint8(tvb, cur_offset);
#line 2055
    mask___0 = 1 << 7;
#line 2056
    i___0 = 0;
#line 2056
    while (i___0 < 8) {
#line 2057
      if ((int )bits___0 & mask___0) {
#line 2058
        tmp___80 = dns_type_description((unsigned int )rr_type);
#line 2058
        proto_tree_add_text(rr_tree, tvb, cur_offset, 1,
                            "RR type in bit map: %s", tmp___80);
      } else {

      }
#line 2062
      mask___0 >>= 1;
#line 2063
      rr_type ++;
#line 2056
      i___0 ++;
    }
#line 2065
    cur_offset ++;
#line 2066
    rr_len___7 --;
  }
#line 2070
  break;
  case 36: 
#line 2074
  preference___0 = (guint16 )0;
#line 2079
  kx_name_len = get_dns_name(tvb, cur_offset + 2, 0, dns_data_offset, & kx_name);
#line 2080
  tmp___81 = strlen((char const   *)kx_name);
#line 2080
  name_out = format_text(kx_name, tmp___81);
#line 2081
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2082
    col_append_fstr(cinfo, 38, " %u %s", preference___0, name_out);
  } else {

  }
#line 2084
  proto_item_append_text(trr, ", preference %u, kx %s", preference___0, name_out);
#line 2086
  proto_tree_add_text(rr_tree, tvb, cur_offset, 2, "Preference: %u",
                      preference___0);
#line 2087
  proto_tree_add_text(rr_tree, tvb, cur_offset + 2, kx_name_len,
                      "Key exchange: %s", name_out);
#line 2091
  break;
  case 37: 
#line 2097
  rr_len___8 = (int )data_len;
#line 2100
  if (rr_len___8 < 2) {
    goto bad_rr;
  } else {

  }
#line 2102
  cert_type = tvb_get_ntohs(tvb, cur_offset);
#line 2103
  tmp___82 = val_to_str((unsigned int )cert_type, cert_vals, "Unknown (0x%02X)");
#line 2103
  proto_tree_add_text(rr_tree, tvb, cur_offset, 2, "Type: %s", tmp___82);
#line 2106
  cur_offset += 2;
#line 2107
  rr_len___8 -= 2;
#line 2109
  if (rr_len___8 < 2) {
    goto bad_rr;
  } else {

  }
#line 2111
  cert_keytag = tvb_get_ntohs(tvb, cur_offset);
#line 2112
  proto_tree_add_text(rr_tree, tvb, cur_offset, 2, "Key footprint: 0x%04x",
                      cert_keytag);
#line 2114
  cur_offset += 2;
#line 2115
  rr_len___8 -= 2;
#line 2117
  if (rr_len___8 < 1) {
    goto bad_rr;
  } else {

  }
#line 2119
  cert_keyalg = tvb_get_guint8(tvb, cur_offset);
#line 2120
  tmp___83 = val_to_str((unsigned int )cert_keyalg, algo_vals,
                        "Unknown (0x%02X)");
#line 2120
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Algorithm: %s", tmp___83);
#line 2123
  cur_offset ++;
#line 2124
  rr_len___8 --;
#line 2126
  if (rr_len___8 != 0) {
#line 2127
    proto_tree_add_text(rr_tree, tvb, cur_offset, rr_len___8, "Public key");
  } else {

  }
#line 2130
  break;
  case 41: 
#line 2134
  proto_tree_add_text(rr_tree, tvb, cur_offset, (int )data_len, "Data");
#line 2135
  break;
  case 43: 
  case 32769: 
#line 2142
  rr_len___9 = (int )data_len;
#line 2152
  if (rr_len___9 < 2) {
    goto bad_rr;
  } else {

  }
#line 2154
  keytag = tvb_get_ntohs(tvb, cur_offset);
#line 2155
  proto_tree_add_text(rr_tree, tvb, cur_offset, 2, "Key id: %04u", keytag);
#line 2156
  cur_offset += 2;
#line 2157
  rr_len___9 -= 2;
#line 2159
  if (rr_len___9 < 1) {
    goto bad_rr;
  } else {

  }
#line 2161
  ds_algorithm = tvb_get_guint8(tvb, cur_offset);
#line 2162
  tmp___84 = val_to_str((unsigned int )ds_algorithm, algo_vals,
                        "Unknown (0x%02X)");
#line 2162
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Algorithm: %s", tmp___84);
#line 2163
  cur_offset ++;
#line 2164
  rr_len___9 --;
#line 2166
  if (rr_len___9 < 1) {
    goto bad_rr;
  } else {

  }
#line 2168
  ds_digest = tvb_get_guint8(tvb, cur_offset);
#line 2169
  tmp___85 = val_to_str((unsigned int )ds_digest, tds_digests,
                        "Unknown (0x%02X)");
#line 2169
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Digest type: %s", tmp___85);
#line 2170
  cur_offset ++;
#line 2171
  rr_len___9 --;
#line 2173
  if ((int )ds_digest == 1) {
#line 2174
    digest_data_size = (unsigned short)20;
#line 2175
    if (rr_len___9 < (int )digest_data_size) {
      goto bad_rr;
    } else {

    }
#line 2177
    proto_tree_add_text(rr_tree, tvb, cur_offset, (int )digest_data_size,
                        "Public key");
  } else {

  }
#line 2180
  if ((int )ds_digest == 2) {
#line 2181
    digest_data_size = (unsigned short)32;
#line 2182
    if (rr_len___9 < (int )digest_data_size) {
      goto bad_rr;
    } else {

    }
#line 2184
    proto_tree_add_text(rr_tree, tvb, cur_offset, (int )digest_data_size,
                        "Public key");
  } else {

  }
#line 2188
  break;
  case 249: 
#line 2195
  rr_len___10 = (int )data_len;
#line 2210
  tkey_algname_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset,
                                  & tkey_algname);
#line 2211
  tmp___86 = strlen((char const   *)tkey_algname);
#line 2211
  tmp___87 = format_text(tkey_algname, tmp___86);
#line 2211
  proto_tree_add_text(rr_tree, tvb, cur_offset, tkey_algname_len,
                      "Algorithm name: %s", tmp___87);
#line 2214
  cur_offset += tkey_algname_len;
#line 2215
  rr_len___10 -= tkey_algname_len;
#line 2217
  if (rr_len___10 < 4) {
    goto bad_rr;
  } else {

  }
#line 2219
  tmp___88 = tvb_get_ntohl(tvb, cur_offset);
#line 2219
  nstime___0.secs = (long )tmp___88;
#line 2220
  nstime___0.nsecs = 0;
#line 2221
  tmp___89 = abs_time_to_str((nstime_t const   *)(& nstime___0),
                             (enum __anonenum_absolute_time_display_e_100 )1000,
                             1);
#line 2221
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Signature inception: %s",
                      tmp___89);
#line 2223
  cur_offset += 4;
#line 2224
  rr_len___10 -= 4;
#line 2226
  if (rr_len___10 < 4) {
    goto bad_rr;
  } else {

  }
#line 2228
  tmp___90 = tvb_get_ntohl(tvb, cur_offset);
#line 2228
  nstime___0.secs = (long )tmp___90;
#line 2229
  nstime___0.nsecs = 0;
#line 2230
  tmp___91 = abs_time_to_str((nstime_t const   *)(& nstime___0),
                             (enum __anonenum_absolute_time_display_e_100 )1000,
                             1);
#line 2230
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Signature expiration: %s",
                      tmp___91);
#line 2232
  cur_offset += 4;
#line 2233
  rr_len___10 -= 4;
#line 2235
  if (rr_len___10 < 2) {
    goto bad_rr;
  } else {

  }
#line 2237
  tkey_mode = tvb_get_ntohs(tvb, cur_offset);
#line 2238
  tmp___92 = val_to_str((unsigned int )tkey_mode, tkey_modes, "Unknown (0x%04X)");
#line 2238
  proto_tree_add_text(rr_tree, tvb, cur_offset, 2, "Mode: %s", tmp___92);
#line 2241
  cur_offset += 2;
#line 2242
  rr_len___10 -= 2;
#line 2244
  if (rr_len___10 < 2) {
    goto bad_rr;
  } else {

  }
#line 2246
  tkey_error = tvb_get_ntohs(tvb, cur_offset);
#line 2247
  tmp___93 = val_to_str((unsigned int )tkey_error, tsigerror_vals,
                        "Unknown error (%x)");
#line 2247
  tmp___94 = val_to_str((unsigned int )tkey_error, rcode_vals, tmp___93);
#line 2247
  proto_tree_add_text(rr_tree, tvb, cur_offset, 2, "Error: %s", tmp___94);
#line 2250
  cur_offset += 2;
#line 2251
  rr_len___10 -= 2;
#line 2253
  tkey_keylen = tvb_get_ntohs(tvb, cur_offset);
#line 2254
  proto_tree_add_text(rr_tree, tvb, cur_offset, 2, "Key Size: %u", tkey_keylen);
#line 2256
  cur_offset += 2;
#line 2257
  rr_len___10 -= 2;
#line 2259
  if ((int )tkey_keylen != 0) {
#line 2260
    key_item = proto_tree_add_text(rr_tree, tvb, cur_offset, (int )tkey_keylen,
                                   "Key Data");
#line 2263
    key_tree = proto_item_add_subtree(key_item, ett_t_key);
#line 2265
    switch ((int )tkey_mode) {
    case 3: 
#line 2285
    gssapi_tvb = tvb_new_subset(tvb, cur_offset, (int )tkey_keylen,
                                (int )tkey_keylen);
#line 2287
    tmp___95 = tvb_strneql(gssapi_tvb, 0, "NTLMSSP", 7U);
#line 2287
    if (tmp___95 == 0) {
#line 2288
      call_dissector(ntlmssp_handle, gssapi_tvb, pinfo, key_tree);
    } else {
#line 2290
      call_dissector(gssapi_handle, gssapi_tvb, pinfo, key_tree);
    }
#line 2293
    break;
    default: ;
#line 2299
    break;
    }
#line 2302
    cur_offset += (int )tkey_keylen;
#line 2303
    rr_len___10 -= (int )tkey_keylen;
  } else {

  }
#line 2306
  if (rr_len___10 < 2) {
    goto bad_rr;
  } else {

  }
#line 2308
  tkey_otherlen = tvb_get_ntohs(tvb, cur_offset);
#line 2309
  proto_tree_add_text(rr_tree, tvb, cur_offset, 2, "Other Size: %u",
                      tkey_otherlen);
#line 2311
  cur_offset += 2;
#line 2312
  rr_len___10 -= 2;
#line 2314
  if ((int )tkey_otherlen != 0) {
#line 2315
    if (rr_len___10 < (int )tkey_otherlen) {
      goto bad_rr;
    } else {

    }
#line 2317
    proto_tree_add_text(rr_tree, tvb, cur_offset, (int )tkey_otherlen,
                        "Other Data");
#line 2318
    cur_offset += (int )tkey_otherlen;
#line 2319
    rr_len___10 -= (int )tkey_otherlen;
  } else {

  }
#line 2323
  break;
  case 250: 
#line 2333
  rr_len___11 = (int )data_len;
#line 2336
  tsig_algname_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset,
                                  & tsig_raw_algname);
#line 2337
  tmp___96 = strlen((char const   *)tsig_raw_algname);
#line 2337
  tsig_algname = format_text(tsig_raw_algname, tmp___96);
#line 2338
  proto_tree_add_string(rr_tree, hf_dns_tsig_algorithm_name, tvb, cur_offset,
                        tsig_algname_len, (char const   *)tsig_algname);
#line 2339
  cur_offset += tsig_algname_len;
#line 2340
  rr_len___11 -= tsig_algname_len;
#line 2342
  if (rr_len___11 < 6) {
    goto bad_rr;
  } else {

  }
#line 2344
  tsig_timehi = tvb_get_ntohs(tvb, cur_offset);
#line 2345
  tsig_timelo = tvb_get_ntohl(tvb, cur_offset + 2);
#line 2346
  nstime___1.secs = (long )tsig_timelo;
#line 2347
  nstime___1.nsecs = 0;
#line 2348
  if ((int )tsig_timehi == 0) {
#line 2348
    tmp___97 = "";
  } else {
#line 2348
    tmp___97 = "(high bits set)";
  }
#line 2348
  tmp___98 = abs_time_to_str((nstime_t const   *)(& nstime___1),
                             (enum __anonenum_absolute_time_display_e_100 )1000,
                             1);
#line 2348
  proto_tree_add_text(rr_tree, tvb, cur_offset, 6, "Time signed: %s%s",
                      tmp___98, tmp___97);
#line 2351
  cur_offset += 6;
#line 2352
  rr_len___11 -= 6;
#line 2354
  if (rr_len___11 < 2) {
    goto bad_rr;
  } else {

  }
#line 2357
  proto_tree_add_item(rr_tree, hf_dns_tsig_fudge, tvb, cur_offset, 2, 0U);
#line 2358
  cur_offset += 2;
#line 2359
  rr_len___11 -= 2;
#line 2361
  if (rr_len___11 < 2) {
    goto bad_rr;
  } else {

  }
#line 2363
  tsig_siglen = tvb_get_ntohs(tvb, cur_offset);
#line 2364
  proto_tree_add_item(rr_tree, hf_dns_tsig_mac_size, tvb, cur_offset, 2, 0U);
#line 2365
  cur_offset += 2;
#line 2366
  rr_len___11 -= 2;
#line 2368
  if ((int )tsig_siglen != 0) {
#line 2373
    if (rr_len___11 < (int )tsig_siglen) {
      goto bad_rr;
    } else {

    }
#line 2376
    mac_item = proto_tree_add_item(rr_tree, hf_dns_tsig_mac, tvb, cur_offset,
                                   (int )tsig_siglen, 0U);
#line 2377
    mac_tree = proto_item_add_subtree(mac_item, ett_dns_mac);
#line 2379
    sub_tvb = tvb_new_subset(tvb, cur_offset, (int )tsig_siglen,
                             (int )tsig_siglen);
#line 2381
    tmp___100 = dissector_try_string(dns_tsig_dissector_table,
                                     (gchar const   *)tsig_algname, sub_tvb,
                                     pinfo, mac_tree);
#line 2381
    if (tmp___100) {

    } else {
#line 2382
      tmp___99 = tvb_length((tvbuff_t const   *)sub_tvb);
#line 2382
      proto_tree_add_text(mac_tree, sub_tvb, 0, (int )tmp___99,
                          "No dissector for algorithm:%s", tsig_algname);
    }
#line 2385
    cur_offset += (int )tsig_siglen;
#line 2386
    rr_len___11 -= (int )tsig_siglen;
  } else {

  }
#line 2389
  if (rr_len___11 < 2) {
    goto bad_rr;
  } else {

  }
#line 2391
  proto_tree_add_item(rr_tree, hf_dns_tsig_original_id, tvb, cur_offset, 2, 0U);
#line 2392
  cur_offset += 2;
#line 2393
  rr_len___11 -= 2;
#line 2395
  if (rr_len___11 < 2) {
    goto bad_rr;
  } else {

  }
#line 2397
  tsig_error = tvb_get_ntohs(tvb, cur_offset);
#line 2398
  tmp___101 = val_to_str((unsigned int )tsig_error, tsigerror_vals,
                         "Unknown error");
#line 2398
  tmp___102 = val_to_str((unsigned int )tsig_error, rcode_vals, tmp___101);
#line 2398
  proto_tree_add_uint_format(rr_tree, hf_dns_tsig_error, tvb, cur_offset, 2,
                             (unsigned int )tsig_error, "Error: %s (%d)",
                             tmp___102, tsig_error);
#line 2401
  cur_offset += 2;
#line 2402
  rr_len___11 -= 2;
#line 2404
  if (rr_len___11 < 2) {
    goto bad_rr;
  } else {

  }
#line 2406
  tsig_otherlen = tvb_get_ntohs(tvb, cur_offset);
#line 2407
  proto_tree_add_item(rr_tree, hf_dns_tsig_other_len, tvb, cur_offset, 2, 0U);
#line 2408
  cur_offset += 2;
#line 2409
  rr_len___11 -= 2;
#line 2411
  if ((int )tsig_otherlen != 0) {
#line 2412
    if (rr_len___11 < (int )tsig_otherlen) {
      goto bad_rr;
    } else {

    }
#line 2414
    proto_tree_add_item(rr_tree, hf_dns_tsig_other_data, tvb, cur_offset,
                        (int )tsig_otherlen, 0U);
#line 2415
    cur_offset += (int )tsig_otherlen;
#line 2416
    rr_len___11 -= (int )tsig_otherlen;
  } else {

  }
#line 2420
  break;
  case 65281: 
#line 2424
  rr_len___12 = (int )data_len;
#line 2431
  if (rr_len___12 < 4) {
    goto bad_rr;
  } else {

  }
#line 2433
  local_flag = tvb_get_ntohl(tvb, cur_offset);
#line 2435
  if (local_flag) {
#line 2435
    tmp___103 = "true";
  } else {
#line 2435
    tmp___103 = "false";
  }
#line 2435
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Local flag: %s", tmp___103);
#line 2438
  cur_offset += 4;
#line 2439
  rr_len___12 -= 4;
#line 2441
  if (rr_len___12 < 4) {
    goto bad_rr;
  } else {

  }
#line 2443
  lookup_timeout = tvb_get_ntohl(tvb, cur_offset);
#line 2445
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Lookup timeout: %u seconds",
                      lookup_timeout);
#line 2448
  cur_offset += 4;
#line 2449
  rr_len___12 -= 4;
#line 2451
  if (rr_len___12 < 4) {
    goto bad_rr;
  } else {

  }
#line 2453
  cache_timeout = tvb_get_ntohl(tvb, cur_offset);
#line 2455
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Cache timeout: %u seconds",
                      cache_timeout);
#line 2458
  cur_offset += 4;
#line 2459
  rr_len___12 -= 4;
#line 2461
  if (rr_len___12 < 4) {
    goto bad_rr;
  } else {

  }
#line 2463
  nservers = tvb_get_ntohl(tvb, cur_offset);
#line 2465
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Number of WINS servers: %u",
                      nservers);
#line 2468
  cur_offset += 4;
#line 2469
  rr_len___12 -= 4;
#line 2471
  while (1) {
#line 2471
    if (rr_len___12 != 0) {
#line 2471
      if (nservers != 0U) {

      } else {
#line 2471
        break;
      }
    } else {
#line 2471
      break;
    }
#line 2472
    if (rr_len___12 < 4) {
      goto bad_rr;
    } else {

    }
#line 2475
    tmp___104 = tvb_get_ptr(tvb, cur_offset, 4);
#line 2475
    tmp___105 = ip_to_str(tmp___104);
#line 2475
    proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "WINS server address: %s",
                        tmp___105);
#line 2478
    cur_offset += 4;
#line 2479
    rr_len___12 -= 4;
#line 2480
    nservers --;
  }
#line 2484
  break;
  case 65282: 
#line 2488
  rr_len___13 = (int )data_len;
#line 2495
  if (rr_len___13 < 4) {
    goto bad_rr;
  } else {

  }
#line 2497
  local_flag___0 = tvb_get_ntohl(tvb, cur_offset);
#line 2499
  if (local_flag___0) {
#line 2499
    tmp___106 = "true";
  } else {
#line 2499
    tmp___106 = "false";
  }
#line 2499
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Local flag: %s", tmp___106);
#line 2502
  cur_offset += 4;
#line 2503
  rr_len___13 -= 4;
#line 2505
  if (rr_len___13 < 4) {
    goto bad_rr;
  } else {

  }
#line 2507
  lookup_timeout___0 = tvb_get_ntohl(tvb, cur_offset);
#line 2509
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Lookup timeout: %u seconds",
                      lookup_timeout___0);
#line 2512
  cur_offset += 4;
#line 2513
  rr_len___13 -= 4;
#line 2515
  if (rr_len___13 < 4) {
    goto bad_rr;
  } else {

  }
#line 2517
  cache_timeout___0 = tvb_get_ntohl(tvb, cur_offset);
#line 2519
  proto_tree_add_text(rr_tree, tvb, cur_offset, 4, "Cache timeout: %u seconds",
                      cache_timeout___0);
#line 2522
  cur_offset += 4;
#line 2523
  rr_len___13 -= 4;
#line 2526
  dname_len___0 = get_dns_name(tvb, cur_offset, 0, dns_data_offset, & dname___0);
#line 2527
  tmp___107 = strlen((char const   *)dname___0);
#line 2527
  name_out = format_text(dname___0, tmp___107);
#line 2528
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2529
    col_append_fstr(cinfo, 38, " %s", name_out);
  } else {

  }
#line 2530
  proto_item_append_text(trr, ", name result domain %s", name_out);
#line 2531
  proto_tree_add_text(rr_tree, tvb, cur_offset, dname_len___0,
                      "Name result domain: %s", name_out);
#line 2534
  break;
  case 33: 
#line 2538
  priority = (guint16 )0;
#line 2539
  weight = (guint16 )0;
#line 2540
  port = (guint16 )0;
#line 2544
  priority = tvb_get_ntohs(tvb, cur_offset);
#line 2545
  weight = tvb_get_ntohs(tvb, cur_offset + 2);
#line 2546
  port = tvb_get_ntohs(tvb, cur_offset + 4);
#line 2549
  target_len = get_dns_name(tvb, cur_offset + 6, 0, dns_data_offset, & target);
#line 2550
  tmp___108 = strlen((char const   *)target);
#line 2550
  name_out = format_text(target, tmp___108);
#line 2551
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2552
    col_append_fstr(cinfo, 38, " %u %u %u %s", priority, weight, port, name_out);
  } else {

  }
#line 2554
  proto_item_append_text(trr, ", priority %u, weight %u, port %u, target %s",
                         priority, weight, port, name_out);
#line 2557
  proto_tree_add_text(rr_tree, tvb, cur_offset, 2, "Priority: %u", priority);
#line 2558
  proto_tree_add_text(rr_tree, tvb, cur_offset + 2, 2, "Weight: %u", weight);
#line 2559
  proto_tree_add_text(rr_tree, tvb, cur_offset + 4, 2, "Port: %u", port);
#line 2560
  proto_tree_add_text(rr_tree, tvb, cur_offset + 6, target_len, "Target: %s",
                      name_out);
#line 2564
  break;
  case 35: 
#line 2568
  offset = cur_offset;
#line 2580
  order = tvb_get_ntohs(tvb, offset);
#line 2581
  offset += 2;
#line 2582
  preference___1 = tvb_get_ntohs(tvb, offset);
#line 2583
  offset += 2;
#line 2584
  flags_len = tvb_get_guint8(tvb, offset);
#line 2585
  offset ++;
#line 2586
  tmp___109 = tvb_get_ephemeral_string(tvb, offset, (int )flags_len);
#line 2586
  flags___1 = (gchar *)tmp___109;
#line 2587
  offset += (int )flags_len;
#line 2588
  service_len = tvb_get_guint8(tvb, offset);
#line 2589
  offset ++;
#line 2590
  service = tvb_get_ephemeral_string(tvb, offset, (int )service_len);
#line 2591
  offset += (int )service_len;
#line 2592
  regex_len = tvb_get_guint8(tvb, offset);
#line 2593
  offset ++;
#line 2594
  regex = tvb_get_ephemeral_string(tvb, offset, (int )regex_len);
#line 2595
  offset += (int )regex_len;
#line 2596
  replacement_len = get_dns_name(tvb, offset, 0, dns_data_offset, & replacement);
#line 2597
  offset ++;
#line 2598
  tmp___110 = strlen((char const   *)replacement);
#line 2598
  name_out = format_text(replacement, tmp___110);
#line 2600
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2601
    col_append_fstr(cinfo, 38, " %u %u %s", order, preference___1, flags___1);
  } else {

  }
#line 2604
  proto_item_append_text(trr, ", order %u, preference %u, flags %s", order,
                         preference___1, flags___1);
#line 2606
  offset = cur_offset;
#line 2607
  proto_tree_add_text(rr_tree, tvb, offset, 2, "Order: %u", order);
#line 2608
  offset += 2;
#line 2609
  proto_tree_add_text(rr_tree, tvb, offset, 2, "Preference: %u", preference___1);
#line 2610
  offset += 2;
#line 2611
  proto_tree_add_text(rr_tree, tvb, offset, 1, "Flags length: %u", flags_len);
#line 2612
  offset ++;
#line 2613
  proto_tree_add_text(rr_tree, tvb, offset, (int )flags_len, "Flags: \"%s\"",
                      flags___1);
#line 2614
  offset += (int )flags_len;
#line 2615
  proto_tree_add_text(rr_tree, tvb, offset, 1, "Service length: %u", service_len);
#line 2616
  offset ++;
#line 2617
  proto_tree_add_text(rr_tree, tvb, offset, (int )service_len,
                      "Service: \"%s\"", service);
#line 2618
  offset += (int )service_len;
#line 2619
  proto_tree_add_text(rr_tree, tvb, offset, 1, "Regex length: %u", regex_len);
#line 2620
  offset ++;
#line 2621
  proto_tree_add_text(rr_tree, tvb, offset, (int )regex_len, "Regex: \"%s\"",
                      regex);
#line 2622
  offset += (int )regex_len;
#line 2623
  proto_tree_add_text(rr_tree, tvb, offset, 1, "Replacement length: %u",
                      replacement_len);
#line 2624
  offset ++;
#line 2625
  proto_tree_add_text(rr_tree, tvb, offset, replacement_len, "Replacement: %s",
                      name_out);
#line 2628
  break;
  case 44: 
#line 2633
  rr_len___14 = (int )data_len;
#line 2649
  if (rr_len___14 < 1) {
    goto bad_rr;
  } else {

  }
#line 2651
  sshfp_algorithm = tvb_get_guint8(tvb, cur_offset);
#line 2652
  tmp___111 = val_to_str((unsigned int )sshfp_algorithm, sshfp_algo,
                         "Unknown (0x%02X)");
#line 2652
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Algorithm: %s", tmp___111);
#line 2653
  cur_offset ++;
#line 2654
  rr_len___14 --;
#line 2656
  if (rr_len___14 < 1) {
    goto bad_rr;
  } else {

  }
#line 2658
  sshfp_type = tvb_get_guint8(tvb, cur_offset);
#line 2659
  tmp___112 = val_to_str((unsigned int )sshfp_type, sshfp_fingertype,
                         "Unknown (0x%02X)");
#line 2659
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "Fingerprint type: %s",
                      tmp___112);
#line 2660
  cur_offset ++;
#line 2661
  rr_len___14 --;
#line 2663
  if (rr_len___14 < 1) {
    goto bad_rr;
  } else {

  }
#line 2665
  if (rr_len___14 != 0) {
#line 2666
    proto_tree_add_item(rr_tree, hf_dns_sshfp_fingerprint, tvb, cur_offset,
                        rr_len___14, 0U);
  } else {

  }
#line 2669
  break;
  case 55: 
#line 2675
  rr_len___15 = (int )data_len;
#line 2686
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2687
    col_append_fstr(cinfo, 38, " %s", name);
  } else {

  }
#line 2690
  if (rr_len___15 < 1) {
    goto bad_rr;
  } else {

  }
#line 2692
  hit_len = tvb_get_guint8(tvb, cur_offset);
#line 2693
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "HIT length: %u", hit_len);
#line 2694
  cur_offset ++;
#line 2695
  rr_len___15 --;
#line 2697
  if (rr_len___15 < 1) {
    goto bad_rr;
  } else {

  }
#line 2699
  algo___2 = tvb_get_guint8(tvb, cur_offset);
#line 2700
  tmp___113 = val_to_str((unsigned int )algo___2, hip_algo_vals,
                         "Unknown (0x%02X)");
#line 2700
  proto_tree_add_text(rr_tree, tvb, cur_offset, 1, "PK algorithm: %s", tmp___113);
#line 2701
  cur_offset ++;
#line 2702
  rr_len___15 --;
#line 2704
  if (rr_len___15 < 1) {
    goto bad_rr;
  } else {

  }
#line 2706
  pk_len = tvb_get_ntohs(tvb, cur_offset);
#line 2707
  proto_tree_add_text(rr_tree, tvb, cur_offset, 2, "PK length: %u", pk_len);
#line 2708
  cur_offset += 2;
#line 2709
  rr_len___15 -= 2;
#line 2711
  if (rr_len___15 < 1) {
    goto bad_rr;
  } else {

  }
#line 2713
  proto_tree_add_item(rr_tree, hf_dns_hip_hit, tvb, cur_offset, (int )hit_len,
                      0U);
#line 2714
  cur_offset += (int )hit_len;
#line 2715
  rr_len___15 -= (int )hit_len;
#line 2717
  if (rr_len___15 < 1) {
    goto bad_rr;
  } else {

  }
#line 2719
  proto_tree_add_item(rr_tree, hf_dns_hip_pk, tvb, cur_offset, (int )pk_len, 0U);
#line 2720
  cur_offset += (int )pk_len;
#line 2721
  rr_len___15 -= (int )pk_len;
#line 2723
  if (rr_len___15 < 1) {
    goto bad_rr;
  } else {

  }
#line 2726
  while (rr_len___15 > 1) {
#line 2727
    rendezvous_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset,
                                  & rend_server_dns_name);
#line 2728
    tmp___114 = strlen((char const   *)rend_server_dns_name);
#line 2728
    tmp___115 = format_text(rend_server_dns_name, tmp___114);
#line 2728
    proto_tree_add_text(rr_tree, tvb, cur_offset, rendezvous_len,
                        "Rendezvous Server: %s", tmp___115);
#line 2730
    cur_offset += rendezvous_len;
#line 2731
    rr_len___15 -= rendezvous_len;
  }
#line 2735
  break;
  case 49: 
#line 2739
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2740
    col_append_fstr(cinfo, 38, " %s", name);
  } else {

  }
#line 2743
  if ((int )data_len < 1) {
    goto bad_rr;
  } else {

  }
#line 2745
  proto_tree_add_item(rr_tree, hf_dns_dhcid_rdata, tvb, cur_offset,
                      (int )data_len, 0U);
#line 2749
  break;
  case 42: 
#line 2753
  rr_len___16 = (int )data_len;
#line 2763
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2764
    col_append_fstr(cinfo, 38, " %s", name);
  } else {

  }
#line 2766
  while (rr_len___16 > 1) {
#line 2768
    if (rr_len___16 < 1) {
      goto bad_rr;
    } else {

    }
#line 2770
    afamily = tvb_get_ntohs(tvb, cur_offset);
#line 2771
    tmp___116 = val_to_str((unsigned int )afamily, apl_afamily_vals,
                           "Unknown (0x%02X)");
#line 2771
    proto_tree_add_text(rr_tree, tvb, cur_offset, 2, "Address Family: %s",
                        tmp___116);
#line 2772
    cur_offset += 2;
#line 2773
    rr_len___16 -= 2;
#line 2775
    if (rr_len___16 < 1) {
      goto bad_rr;
    } else {

    }
#line 2777
    proto_tree_add_item(rr_tree, hf_dns_apl_coded_prefix, tvb, cur_offset, 1, 0U);
#line 2778
    cur_offset ++;
#line 2779
    rr_len___16 --;
#line 2781
    if (rr_len___16 < 1) {
      goto bad_rr;
    } else {

    }
#line 2783
    tmp___117 = tvb_get_guint8(tvb, cur_offset);
#line 2783
    afdpart_len = (unsigned char )((int )tmp___117 & 0x7F);
#line 2784
    proto_tree_add_item(rr_tree, hf_dns_apl_negation, tvb, cur_offset, 1, 0U);
#line 2785
    proto_tree_add_item(rr_tree, hf_dns_apl_afdlength, tvb, cur_offset, 1, 0U);
#line 2786
    cur_offset ++;
#line 2787
    rr_len___16 --;
#line 2789
    if (rr_len___16 < 1) {
      goto bad_rr;
    } else {

    }
#line 2791
    if ((int )afamily == 1) {
#line 2791
      if ((int )afdpart_len <= 4) {
#line 2792
        tmp___118 = se_alloc0(4U);
#line 2792
        addr_copy = (guint8 *)tmp___118;
      } else {
        goto _L;
      }
    } else {
      _L: /* CIL Label */ 
#line 2793
      if ((int )afamily == 2) {
#line 2793
        if ((int )afdpart_len <= 16) {
#line 2794
          tmp___119 = se_alloc0(16U);
#line 2794
          addr_copy = (guint8 *)tmp___119;
        } else {
          goto bad_rr;
        }
      } else {
        goto bad_rr;
      }
    }
#line 2798
    tvb_memcpy(tvb, (void *)addr_copy, cur_offset, (unsigned int )afdpart_len);
#line 2799
    if ((int )afamily == 0x02) {
#line 2799
      tmp___120 = ip6_to_str((struct e_in6_addr  const  *)addr_copy);
#line 2799
      tmp___122 = (gchar const   *)tmp___120;
    } else {
#line 2799
      tmp___121 = ip_to_str((guint8 const   *)addr_copy);
#line 2799
      tmp___122 = tmp___121;
    }
#line 2799
    tmp___123 = val_to_str((unsigned int )afamily, apl_afamily_vals, "Unknown");
#line 2799
    proto_tree_add_text(rr_tree, tvb, cur_offset, (int )afdpart_len,
                        "%s address: %s", tmp___123, tmp___122);
#line 2802
    cur_offset += (int )afdpart_len;
#line 2803
    rr_len___16 -= (int )afdpart_len;
  }
#line 2806
  break;
  case 27: 
#line 2812
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2813
    col_append_fstr(cinfo, 38, " %s", name);
  } else {

  }
#line 2814
  if ((int )data_len < 1) {
    goto bad_rr;
  } else {

  }
#line 2816
  long_len = tvb_get_guint8(tvb, cur_offset);
#line 2817
  tmp___124 = tvb_get_ptr(tvb, cur_offset + 1, (int )long_len);
#line 2817
  proto_tree_add_text(rr_tree, tvb, cur_offset + 1, (int )long_len,
                      "Longitude: %.*s", long_len, tmp___124);
#line 2818
  cur_offset += 1 + (int )long_len;
#line 2820
  lat_len = tvb_get_guint8(tvb, cur_offset);
#line 2821
  tmp___125 = tvb_get_ptr(tvb, cur_offset + 1, (int )lat_len);
#line 2821
  proto_tree_add_text(rr_tree, tvb, cur_offset + 1, (int )lat_len,
                      "Latitude: %.*s", lat_len, tmp___125);
#line 2822
  cur_offset += 1 + (int )lat_len;
#line 2824
  alt_len = tvb_get_guint8(tvb, cur_offset);
#line 2825
  tmp___126 = tvb_get_ptr(tvb, cur_offset + 1, (int )alt_len);
#line 2825
  proto_tree_add_text(rr_tree, tvb, cur_offset + 1, (int )alt_len,
                      "Altitude: %.*s", alt_len, tmp___126);
#line 2827
  break;
  case 17: 
#line 2834
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2835
    col_append_fstr(cinfo, 38, " %s", name);
  } else {

  }
#line 2837
  if ((int )data_len < 1) {
    goto bad_rr;
  } else {

  }
#line 2839
  mbox_dname_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset,
                                & mbox_dname);
#line 2840
  tmp___127 = strlen((char const   *)mbox_dname);
#line 2840
  tmp___128 = format_text(mbox_dname, tmp___127);
#line 2840
  proto_tree_add_text(rr_tree, tvb, cur_offset, mbox_dname_len, "Mailbox: %s",
                      tmp___128);
#line 2841
  cur_offset += mbox_dname_len;
#line 2842
  txt_dname_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset, & txt_dname);
#line 2843
  tmp___129 = strlen((char const   *)txt_dname);
#line 2843
  tmp___130 = format_text(txt_dname, tmp___129);
#line 2843
  proto_tree_add_text(rr_tree, tvb, cur_offset, txt_dname_len, "TXT RR: %s",
                      tmp___130);
#line 2845
  break;
  case 18: 
  case 21: 
#line 2850
  subtype = (guint16 )0;
#line 2854
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2855
    col_append_fstr(cinfo, 38, " %s", name);
  } else {

  }
#line 2856
  subtype = tvb_get_ntohs(tvb, cur_offset);
#line 2857
  host_name_len = get_dns_name(tvb, cur_offset + 2, 0, dns_data_offset,
                               & host_name);
#line 2859
  if ((int )data_len < 1) {
    goto bad_rr;
  } else {

  }
#line 2861
  if (type == 18) {
#line 2861
    tmp___131 = "Subtype: %u";
  } else {
#line 2861
    tmp___131 = "Preference: %u";
  }
#line 2861
  proto_tree_add_text(rr_tree, tvb, cur_offset, 2, tmp___131, subtype);
#line 2862
  tmp___132 = strlen((char const   *)host_name);
#line 2862
  tmp___133 = format_text(host_name, tmp___132);
#line 2862
  if (type == 18) {
#line 2862
    tmp___134 = "Hostname: %s";
  } else {
#line 2862
    tmp___134 = "Intermediate-Host: %s";
  }
#line 2862
  proto_tree_add_text(rr_tree, tvb, cur_offset + 2, host_name_len, tmp___134,
                      tmp___133);
#line 2866
  break;
  case 19: 
#line 2872
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2873
    col_append_fstr(cinfo, 38, " %s", name);
  } else {

  }
#line 2874
  if ((int )data_len < 1) {
    goto bad_rr;
  } else {

  }
#line 2876
  x25_len = tvb_get_guint8(tvb, cur_offset);
#line 2877
  tmp___135 = tvb_get_ptr(tvb, cur_offset + 1, (int )x25_len);
#line 2877
  proto_tree_add_text(rr_tree, tvb, cur_offset, (int )x25_len + 1,
                      "PSDN-Address: %.*s", x25_len, tmp___135);
#line 2879
  break;
  case 20: 
#line 2884
  rr_len___17 = (int )data_len;
#line 2886
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2887
    col_append_fstr(cinfo, 38, " %s", name);
  } else {

  }
#line 2888
  if (rr_len___17 < 1) {
    goto bad_rr;
  } else {

  }
#line 2890
  isdn_address_len = tvb_get_guint8(tvb, cur_offset);
#line 2891
  tmp___136 = tvb_get_ptr(tvb, cur_offset + 1, (int )isdn_address_len);
#line 2891
  proto_tree_add_text(rr_tree, tvb, cur_offset, (int )isdn_address_len + 1,
                      "ISDN Address: %.*s", isdn_address_len, tmp___136);
#line 2892
  cur_offset += 1 + (int )isdn_address_len;
#line 2893
  rr_len___17 -= 1 + (int )isdn_address_len;
#line 2895
  if (rr_len___17 > 1) {
#line 2896
    isdn_sa_len = tvb_get_guint8(tvb, cur_offset);
#line 2897
    tmp___137 = tvb_get_ptr(tvb, cur_offset + 1, (int )isdn_sa_len);
#line 2897
    proto_tree_add_text(rr_tree, tvb, cur_offset, (int )isdn_sa_len + 1,
                        "Subaddress: %.*s", isdn_sa_len, tmp___137);
  } else {

  }
#line 2900
  break;
  case 26: 
#line 2907
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2908
    col_append_fstr(cinfo, 38, " %s", name);
  } else {

  }
#line 2909
  if ((int )data_len < 1) {
    goto bad_rr;
  } else {

  }
#line 2911
  tmp___138 = tvb_get_ntohs(tvb, cur_offset);
#line 2911
  proto_tree_add_text(rr_tree, tvb, cur_offset, 2, "Preference: %u", tmp___138);
#line 2912
  cur_offset += 2;
#line 2913
  px_map822_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset,
                               & px_map822_dnsname);
#line 2914
  tmp___139 = strlen((char const   *)px_map822_dnsname);
#line 2914
  tmp___140 = format_text(px_map822_dnsname, tmp___139);
#line 2914
  proto_tree_add_text(rr_tree, tvb, cur_offset, px_map822_len, "MAP822: %s",
                      tmp___140);
#line 2915
  cur_offset += px_map822_len;
#line 2916
  px_mapx400_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset,
                                & px_mapx400_dnsname);
#line 2917
  tmp___141 = strlen((char const   *)px_mapx400_dnsname);
#line 2917
  tmp___142 = format_text(px_mapx400_dnsname, tmp___141);
#line 2917
  proto_tree_add_text(rr_tree, tvb, cur_offset, px_mapx400_len, "MAPX400: %s",
                      tmp___142);
#line 2918
  cur_offset += px_mapx400_len;
#line 2920
  break;
  case 22: 
#line 2924
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2925
    col_append_fstr(cinfo, 38, " %s", name);
  } else {

  }
#line 2926
  if ((int )data_len < 1) {
    goto bad_rr;
  } else {

  }
#line 2928
  proto_tree_add_item(rr_tree, hf_dns_nsap_rdata, tvb, cur_offset,
                      (int )data_len, 0U);
#line 2930
  break;
  case 23: 
#line 2937
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2938
    col_append_fstr(cinfo, 38, " %s", name);
  } else {

  }
#line 2939
  if ((int )data_len < 1) {
    goto bad_rr;
  } else {

  }
#line 2941
  nsap_ptr_owner_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset,
                                    & nsap_ptr_owner);
#line 2942
  tmp___143 = strlen((char const   *)nsap_ptr_owner);
#line 2942
  tmp___144 = format_text(nsap_ptr_owner, tmp___143);
#line 2942
  proto_tree_add_text(rr_tree, tvb, cur_offset, nsap_ptr_owner_len, "Owner: %s",
                      tmp___144);
#line 2944
  break;
  case 7: 
  case 4: 
  case 3: 
  case 8: 
  case 9: 
#line 2955
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2956
    col_append_fstr(cinfo, 38, " %s", name);
  } else {

  }
#line 2957
  if ((int )data_len < 1) {
    goto bad_rr;
  } else {

  }
#line 2959
  hostname_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset,
                              & hostname_str);
#line 2960
  tmp___145 = strlen((char const   *)hostname_str);
#line 2960
  tmp___146 = format_text(hostname_str, tmp___145);
#line 2960
  proto_tree_add_text(rr_tree, tvb, cur_offset, hostname_len, "Host: %s",
                      tmp___146);
#line 2962
  break;
  case 14: 
#line 2969
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2970
    col_append_fstr(cinfo, 38, " %s", name);
  } else {

  }
#line 2971
  if ((int )data_len < 1) {
    goto bad_rr;
  } else {

  }
#line 2973
  rmailbx_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset, & rmailbx_str);
#line 2974
  tmp___147 = strlen((char const   *)rmailbx_str);
#line 2974
  tmp___148 = format_text(rmailbx_str, tmp___147);
#line 2974
  proto_tree_add_text(rr_tree, tvb, cur_offset, rmailbx_len,
                      "Responsible Mailbox: %s", tmp___148);
#line 2975
  cur_offset += rmailbx_len;
#line 2976
  emailbx_len = get_dns_name(tvb, cur_offset, 0, dns_data_offset, & emailbx_str);
#line 2977
  tmp___149 = strlen((char const   *)emailbx_str);
#line 2977
  tmp___150 = format_text(emailbx_str, tmp___149);
#line 2977
  proto_tree_add_text(rr_tree, tvb, cur_offset, emailbx_len,
                      "Error Mailbox: %s", tmp___150);
#line 2979
  break;
  case 10: 
#line 2983
  if ((unsigned int )cinfo != (unsigned int )((void *)0)) {
#line 2984
    col_append_fstr(cinfo, 38, " %s", name);
  } else {

  }
#line 2985
  proto_tree_add_text(rr_tree, tvb, cur_offset, (int )data_len, "Data");
#line 2987
  break;
  default: 
#line 2993
  proto_tree_add_text(rr_tree, tvb, cur_offset, (int )data_len, "Data");
#line 2994
  break;
  }
   1712: /* CIL Label */ 
#line 2997
  data_offset += (int )data_len;
   1713: /* CIL Label */ 
#line 2999
  return (data_offset - data_start);
   1714: /* CIL Label */ 
  bad_rr: 
#line 3003
  proto_item_append_text(trr, ", bad RR length %d, too short", data_len);
   1715: /* CIL Label */ 
#line 3007
  data_offset += (int )data_len;
   1716: /* CIL Label */ 
#line 3009
  return (data_offset - data_start);
}
}

cilRep: liveness failure for dissect_dns_answer: Errormsg.Error
cilRep: computed liveness
cilRep: preprocessed/epan/dissectors/packet-gtpv2.c: parsing
Error: There were parsing errors in preprocessed/epan/dissectors/packet-gtpv2.c
/root/repair aborting: Errormsg.Error
Rep: saving test cache

Variant Test Case Queries: 0
"Test Suite Evaluations": 0

Compile Failures: 0
Wall-Clock Seconds Elapsed: 7.27698
  Activity Name                     Count Seconds = Percent of Total Time
  TOTAL                                     0.000 = 0% (avg CPU usage)
Fatal error: exception Errormsg.Error
wireshark-bug-35419-35414.tar.gz
Tue May  7 23:32:30 EDT 2013
shutting down
