GNU bug report logs - #22149
stack overflow in regexp matcher

Please note: This is a static page, with minimal formatting, updated once a day.
Click here to see this page with the latest information and nicer formatting.

Package: emacs; Reported by: Cheng-An Yang <rhymer123@HIDDEN>; Keywords: confirmed; dated Sat, 12 Dec 2015 06:32:01 UTC; Maintainer for emacs is bug-gnu-emacs@HIDDEN.
Changed bug title to 'stack overflow in regexp matcher' from '24.4; gdb stack overflow in regexp matcher' Request was from npostavs@HIDDEN to control <at> debbugs.gnu.org. Full text available.
bug Marked as found in versions 25.0.95. Request was from npostavs@HIDDEN to control <at> debbugs.gnu.org. Full text available.
Added tag(s) confirmed. Request was from npostavs@HIDDEN to control <at> debbugs.gnu.org. Full text available.

Message received at 22149 <at> debbugs.gnu.org:


Received: (at 22149) by debbugs.gnu.org; 1 Jul 2016 03:16:40 +0000
From debbugs-submit-bounces <at> debbugs.gnu.org Thu Jun 30 23:16:40 2016
Received: from localhost ([127.0.0.1]:32974 helo=debbugs.gnu.org)
	by debbugs.gnu.org with esmtp (Exim 4.84_2)
	(envelope-from <debbugs-submit-bounces <at> debbugs.gnu.org>)
	id 1bIowa-0004se-5j
	for submit <at> debbugs.gnu.org; Thu, 30 Jun 2016 23:16:40 -0400
Received: from mail-it0-f53.google.com ([209.85.214.53]:35521)
 by debbugs.gnu.org with esmtp (Exim 4.84_2)
 (envelope-from <npostavs@HIDDEN>)
 id 1bIowX-0004sM-KC; Thu, 30 Jun 2016 23:16:38 -0400
Received: by mail-it0-f53.google.com with SMTP id g127so8006736ith.0;
 Thu, 30 Jun 2016 20:16:37 -0700 (PDT)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113;
 h=sender:from:to:cc:subject:references:date:in-reply-to:message-id
 :user-agent:mime-version;
 bh=Gq+tNGDO+/GuKD5XKwD62g3W/d6s51zCtVyc3KAZL8I=;
 b=C8l3GWyP3oWtjiknAjN7PtJqZ2M2VKPAqhw5L1TMqTDe2pXIpHzlv2fsBnJKYXdghm
 IeTs8v3FC4uGMJklrD+wZyV7qKZS7t1JhD9mfRjXKTqdRZ2EBkJTqbL9D16FNygMxXne
 SifgEVh3vXyh40Jvczcx5m+uR2VXwaiUHnK0N1u6KO9wPxhfutAMTjD1iPRkOo7LZoS+
 kee+D+JCeTpI4REABOl/OgHcYuHLWUejwkV7FUFbZJZfebNee8rqJ6efdkNC3T3ulkDh
 3xiorXM51VKTFJE2haEnCP4zfEQouBzDOByrT6TAZUEcTXUjvwOR//mAUz4ThOU0svnL
 HiBw==
X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
 d=1e100.net; s=20130820;
 h=x-gm-message-state:sender:from:to:cc:subject:references:date
 :in-reply-to:message-id:user-agent:mime-version;
 bh=Gq+tNGDO+/GuKD5XKwD62g3W/d6s51zCtVyc3KAZL8I=;
 b=TAxmkv/5K5XnjkVnTBTxh0ZsWeG7BFDBC0XIiN/fSzTItJEFRq9TPtRdVAXwwRUxki
 w+wDTl+8ethsbZnJmVq74cPaQUEtDNE/7/0APG6WwS9YKdQyKv+Zo6ZeP/Fw2PDUASUB
 b0uTpnfbfi9lcZPReVUmcnnPPvzQgXSPRQKp8vVdz4tFo6T7Q/5xPt4t0WkOiuT/2bGw
 zxsa10QZaTVMpBuogR7J0szlJG+0pn577B2v+3QAOTXR9GzJQt+XI9r8MZcyj98/MR4B
 cIz9F/A5MqeuDna5ps0CHITupzqDorK1tyOzH+VhQmxh88ajVM4uNjtJ/t1KQs5c/YZE
 P4pg==
X-Gm-Message-State: ALyK8tLygohRJJJkdt3XDKDhY+BdMeb8sqaOSIUwFcqSNbNNNXsMUopfHWJuEK5M8fRlBA==
X-Received: by 10.36.111.81 with SMTP id x78mr28952598itb.6.1467342992162;
 Thu, 30 Jun 2016 20:16:32 -0700 (PDT)
Received: from zony (206-188-64-44.cpe.distributel.net. [206.188.64.44])
 by smtp.googlemail.com with ESMTPSA id s17sm1203922ioi.24.2016.06.30.20.16.28
 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128);
 Thu, 30 Jun 2016 20:16:29 -0700 (PDT)
From: npostavs@HIDDEN
To: Andreas Schwab <schwab@HIDDEN>
Subject: Re: bug#22149: 24.4; gdb stack overflow in regexp matcher
References: <CAKAd=p6_kJUsMmZ=5=SjOJzZDxfmXm8kiKZFzBzJbm0=3QLoig@HIDDEN>
 <m2zixgnfeu.fsf@HIDDEN>
Date: Thu, 30 Jun 2016 23:16:38 -0400
In-Reply-To: <m2zixgnfeu.fsf@HIDDEN> (Andreas Schwab's message of
 "Sat, 12 Dec 2015 11:13:13 +0100")
Message-ID: <87a8i2hwtl.fsf@HIDDEN>
User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/25.0.93 (gnu/linux)
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="=-=-="
X-Spam-Score: -0.7 (/)
X-Debbugs-Envelope-To: 22149
Cc: Cheng-An Yang <rhymer123@HIDDEN>, 22149 <at> debbugs.gnu.org
X-BeenThere: debbugs-submit <at> debbugs.gnu.org
X-Mailman-Version: 2.1.18
Precedence: list
List-Id: <debbugs-submit.debbugs.gnu.org>
List-Unsubscribe: <https://debbugs.gnu.org/cgi-bin/mailman/options/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=unsubscribe>
List-Archive: <https://debbugs.gnu.org/cgi-bin/mailman/private/debbugs-submit/>
List-Post: <mailto:debbugs-submit <at> debbugs.gnu.org>
List-Help: <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=help>
List-Subscribe: <https://debbugs.gnu.org/cgi-bin/mailman/listinfo/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=subscribe>
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
X-Spam-Score: -0.7 (/)

--=-=-=
Content-Type: text/plain

tags 22149 confirmed
found 22149 25.0.95
retitle 22149 stack overflow in regexp matcher
quit

Andreas Schwab <schwab@HIDDEN> writes:

> Cheng-An Yang <rhymer123@HIDDEN> writes:
>
>> I am using Emacs GDB Graphical Interface to debug a large C++ project.
>> When I stop at certain functions, it breaks the GDB interface with the
>> error message "Stack overflow in regexp matcher".
>
> I cannot reproduce that error with Emacs 24.5 when evaluating the
> string-match from the backtrace.

I'm able to reproduce with both 24.5 and 25.0.95.  Attaching testcase as
el file to avoid ambiguity.  Run as

    emacs -Q -l bug-22149-regexp-overflow.el

I'm entirely sure why this regexp triggers an overflow, but one that
doesn't trigger overflow, and I think should match the same is:

    "\\([~@&]\\)\\(\"\\(?:\\\\\"\\|[^\"]\\)*\"\\)\n"


--=-=-=
Content-Type: application/emacs-lisp
Content-Disposition: attachment; filename=bug-22149-regexp-overflow.el
Content-Transfer-Encoding: quoted-printable
Content-Description: testcase to trigger overflow

(string-match "\\([~@&]\\)\\(\"\\(?:[^\\\"]\\|\\\\.\\)*\"\\)\n"
              "~\"5 breakpoint keep y 0x00002aaac4d594fa in SIMULATION_VP::=
ETC_VP_Frontend::chanDecodeComputing
 (boost::shared_ptr<SIMULATION_VP::ETC_V1_DEC_CON>, std::vector<std::vector=
<std::vector<std::vector<finite::complexx, std::allocator<finite::complexx>=
 >, std::allocator<std::vector<finite::complexx,
 std::allocator<finite::complexx> > > >, std::allocator<std::vector<std::ve=
ctor<finite::complexx, std::allocator<finite::complexx> >, std::allocator<s=
td::vector<finite::complexx, std::allocator<finite::complexx>
> > > > >, std::allocator<std::vector<std::vector<std::vector<finite::compl=
exx, std::allocator<finite::complexx> >, std::allocator<std::vector<finite:=
:complexx, std::allocator<finite::complexx> > > >,
 std::allocator<std::vector<std::vector<finite::complexx, std::allocator<fi=
nite::complexx> >, std::allocator<std::vector<finite::complexx, std::alloca=
tor<finite::complexx> > > > > > > >*,
 std::vector<std::vector<std::vector<finite::complexx, std::allocator<finit=
e::complexx> >, std::allocator<std::vector<finite::complexx, std::allocator=
<finite::complexx> > > >,
 std::allocator<std::vector<std::vector<finite::complexx, std::allocator<fi=
nite::complexx> >, std::allocator<std::vector<finite::complexx, std::alloca=
tor<finite::complexx> > > > > > const&,
 std::vector<std::vector<std::vector<finite::complexFinite, std::allocator<=
finite::complexFinite> >, std::allocator<std::vector<finite::complexFinite,=
 std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > >&,
 std::vector<std::vector<std::vector<finite::complexFinite, std::allocator<=
finite::complexFinite> >, std::allocator<std::vector<finite::complexFinite,=
 std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > >&,
 std::vector<std::vector<std::vector<std::vector<finite::Finite, std::alloc=
ator<finite::Finite> >, std::allocator<std::vector<finite::Finite, std::all=
ocator<finite::Finite> > > >,
 std::allocator<std::vector<std::vector<finite::Finite, std::allocator<fini=
te::Finite> >, std::allocator<std::vector<finite::Finite, std::allocator<fi=
nite::Finite> > > > > >,
 std::allocator<std::vector<std::vector<std::vector<finite::Finite, std::al=
locator<finite::Finite> >, std::allocator<std::vector<finite::Finite, std::=
allocator<finite::Finite> > > >,
 std::allocator<std::vector<std::vector<finite::Finite, std::allocator<fini=
te::Finite> >, std::allocator<std::vector<finite::Finite, std::allocator<fi=
nite::Finite> > > > > > > >&, std::vector<finite::complexFinite,
 std::allocator<finite::complexFinite> >&, std::vector<std::vector<finite::=
complexFinite, std::allocator<finite::complexFinite> >, std::allocator<std:=
:vector<finite::complexFinite,
 std::allocator<finite::complexFinite> > > >&, std::vector<unsigned int, st=
d::allocator<unsigned int> >, std::vector<std::vector<std::vector<int, std:=
:allocator<int> >, std::allocator<std::vector<int,
 std::allocator<int> > > >, std::allocator<std::vector<std::vector<int, std=
::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > >=
 > > >,
 std::vector<std::vector<std::vector<std::vector<finite::complexFinite, std=
::allocator<finite::complexFinite> >, std::allocator<std::vector<finite::co=
mplexFinite, std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > >,
 std::allocator<std::vector<std::vector<std::vector<finite::complexFinite, =
std::allocator<finite::complexFinite> >, std::allocator<std::vector<finite:=
:complexFinite, std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > > > >&,
 std::vector<std::vector<std::vector<std::vector<finite::complexFinite, std=
::allocator<finite::complexFinite> >, std::allocator<std::vector<finite::co=
mplexFinite, std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > >,
 std::allocator<std::vector<std::vector<std::vector<finite::complexFinite, =
std::allocator<finite::complexFinite> >, std::allocator<std::vector<finite:=
:complexFinite, std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > > > >&,
 std::vector<std::vector<std::vector<std::vector<finite::complexFinite, std=
::allocator<finite::complexFinite> >, std::allocator<std::vector<finite::co=
mplexFinite, std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > >,
 std::allocator<std::vector<std::vector<std::vector<finite::complexFinite, =
std::allocator<finite::complexFinite> >, std::allocator<std::vector<finite:=
:complexFinite, std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > > > >&,
 std::vector<std::vector<std::vector<finite::complexFinite, std::allocator<=
finite::complexFinite> >, std::allocator<std::vector<finite::complexFinite,=
 std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > >&,
 std::vector<std::vector<std::vector<finite::complexFinite, std::allocator<=
finite::complexFinite> >, std::allocator<std::vector<finite::complexFinite,=
 std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > >&,
 std::vector<std::vector<std::vector<std::vector<finite::complexFinite, std=
::allocator<finite::complexFinite> >, std::allocator<std::vector<finite::co=
mplexFinite, std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > >,
 std::allocator<std::vector<std::vector<std::vector<finite::complexFinite, =
std::allocator<finite::complexFinite> >, std::allocator<std::vector<finite:=
:complexFinite, std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > > > >
 const&, std::vector<std::vector<bool, std::allocator<bool> >, std::allocat=
or<std::vector<bool, std::allocator<bool> > > >&, std::vector<std::vector<s=
td::vector<finite::complexFinite,
 std::allocator<finite::complexFinite> >, std::allocator<std::vector<finite=
::complexFinite, std::allocator<finite::complexFinite> > > >, std::allocato=
r<std::vector<std::vector<finite::complexFinite,
 std::allocator<finite::complexFinite> >, std::allocator<std::vector<finite=
::complexFinite, std::allocator<finite::complexFinite> > > > > >&, std::vec=
tor<std::vector<std::vector<finite::complexFinite,
 std::allocator<finite::complexFinite> >, std::allocator<std::vector<finite=
::complexFinite, std::allocator<finite::complexFinite> > > >, std::allocato=
r<std::vector<std::vector<finite::complexFinite,
 std::allocator<finite::complexFinite> >, std::allocator<std::vector<finite=
::complexFinite, std::allocator<finite::complexFinite> > > > > >&, std::vec=
tor<std::vector<std::vector<finite::Finite,
 std::allocator<finite::Finite> >, std::allocator<std::vector<finite::Finit=
e, std::allocator<finite::Finite> > > >, std::allocator<std::vector<std::ve=
ctor<finite::Finite, std::allocator<finite::Finite> >,
 std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> =
> > > > >&, std::vector<std::vector<std::vector<finite::Finite, std::alloca=
tor<finite::Finite> >, std::allocator<std::vector<finite::Finite,
 std::allocator<finite::Finite> > > >, std::allocator<std::vector<std::vect=
or<finite::Finite, std::allocator<finite::Finite> >, std::allocator<std::ve=
ctor<finite::Finite, std::allocator<finite::Finite> > > > > >&,
 std::vector<std::vector<std::vector<std::vector<finite::complexFinite, std=
::allocator<finite::complexFinite> >, std::allocator<std::vector<finite::co=
mplexFinite, std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > >,
 std::allocator<std::vector<std::vector<std::vector<finite::complexFinite, =
std::allocator<finite::complexFinite> >, std::allocator<std::vector<finite:=
:complexFinite, std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > > > >&,
 std::vector<std::vector<std::vector<finite::complexFinite, std::allocator<=
finite::complexFinite> >, std::allocator<std::vector<finite::complexFinite,=
 std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > >&,
 std::vector<std::vector<std::vector<std::vector<BlockCEParameter_class, st=
d::allocator<BlockCEParameter_class> >, std::allocator<std::vector<BlockCEP=
arameter_class,
 std::allocator<BlockCEParameter_class> > > >, std::allocator<std::vector<s=
td::vector<BlockCEParameter_class, std::allocator<BlockCEParameter_class> >,
 std::allocator<std::vector<BlockCEParameter_class, std::allocator<BlockCEP=
arameter_class> > > > > >, std::allocator<std::vector<std::vector<std::vect=
or<BlockCEParameter_class,
 std::allocator<BlockCEParameter_class> >, std::allocator<std::vector<Block=
CEParameter_class, std::allocator<BlockCEParameter_class> > > >,
 std::allocator<std::vector<std::vector<BlockCEParameter_class, std::alloca=
tor<BlockCEParameter_class> >, std::allocator<std::vector<BlockCEParameter_=
class, std::allocator<BlockCEParameter_class> > > >
> > > >*, std::vector<std::vector<finite::complexFinite, std::allocator<fin=
ite::complexFinite> >, std::allocator<std::vector<finite::complexFinite, st=
d::allocator<finite::complexFinite> > > >&,
 std::vector<std::vector<std::vector<std::vector<std::vector<finite::comple=
xFinite, std::allocator<finite::complexFinite> >, std::allocator<std::vecto=
r<finite::complexFinite, std::allocator<finite::complexFinite> >
> >, std::allocator<std::vector<std::vector<finite::complexFinite, std::all=
ocator<finite::complexFinite> >, std::allocator<std::vector<finite::complex=
Finite, std::allocator<finite::complexFinite> > > > > >,
 std::allocator<std::vector<std::vector<std::vector<finite::complexFinite, =
std::allocator<finite::complexFinite> >, std::allocator<std::vector<finite:=
:complexFinite, std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > > > >,
 std::allocator<std::vector<std::vector<std::vector<std::vector<finite::com=
plexFinite, std::allocator<finite::complexFinite> >, std::allocator<std::ve=
ctor<finite::complexFinite, std::allocator<finite::complexFinite>
> > >, std::allocator<std::vector<std::vector<finite::complexFinite, std::a=
llocator<finite::complexFinite> >, std::allocator<std::vector<finite::compl=
exFinite, std::allocator<finite::complexFinite> > > > > >,
 std::allocator<std::vector<std::vector<std::vector<finite::complexFinite, =
std::allocator<finite::complexFinite> >, std::allocator<std::vector<finite:=
:complexFinite, std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > > > > > >&,
 std::vector<std::vector<std::vector<finite::Finite, std::allocator<finite:=
:Finite> >, std::allocator<std::vector<finite::Finite, std::allocator<finit=
e::Finite> > > >, std::allocator<std::vector<std::vector<finite::Finite,
 std::allocator<finite::Finite> >, std::allocator<std::vector<finite::Finit=
e, std::allocator<finite::Finite> > > > > >, std::vector<finite::Finite, st=
d::allocator<finite::Finite> >, unsigned int, bool, std::vector<int,
 std::allocator<int> >, std::vector<std::vector<int, std::allocator<int> >,=
 std::allocator<std::vector<int, std::allocator<int> > > >, std::vector<int=
, std::allocator<int> >, std::vector<unsigned int,
 std::allocator<unsigned int> > const&, std::vector<unsigned int, std::allo=
cator<unsigned int> > const&, std::vector<std::vector<std::vector<std::vect=
or<finite::complexFinite,
 std::allocator<finite::complexFinite> >, std::allocator<std::vector<finite=
::complexFinite, std::allocator<finite::complexFinite> > > >, std::allocato=
r<std::vector<std::vector<finite::complexFinite,
 std::allocator<finite::complexFinite> >, std::allocator<std::vector<finite=
::complexFinite, std::allocator<finite::complexFinite> > > > > >,
 std::allocator<std::vector<std::vector<std::vector<finite::complexFinite, =
std::allocator<finite::complexFinite> >, std::allocator<std::vector<finite:=
:complexFinite, std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > > > >
 const&, std::vector<std::vector<std::vector<std::vector<finite::complexFin=
ite, std::allocator<finite::complexFinite> >, std::allocator<std::vector<fi=
nite::complexFinite, std::allocator<finite::complexFinite> > >
>, std::allocator<std::vector<std::vector<finite::complexFinite, std::alloc=
ator<finite::complexFinite> >, std::allocator<std::vector<finite::complexFi=
nite, std::allocator<finite::complexFinite> > > > > >,
 std::allocator<std::vector<std::vector<std::vector<finite::complexFinite, =
std::allocator<finite::complexFinite> >, std::allocator<std::vector<finite:=
:complexFinite, std::allocator<finite::complexFinite> > > >,
 std::allocator<std::vector<std::vector<finite::complexFinite, std::allocat=
or<finite::complexFinite> >, std::allocator<std::vector<finite::complexFini=
te, std::allocator<finite::complexFinite> > > > > > > >
 const&, std::vector<std::vector<bool, std::allocator<bool> >, std::allocat=
or<std::vector<bool, std::allocator<bool> > > >, finite::Finite, std::vecto=
r<bool, std::allocator<bool> >, unsigned int, unsigned int,
 bool, bool, std::vector<bool, std::allocator<bool> > const*, std::vector<s=
td::vector<finite::complexFinite, std::allocator<finite::complexFinite> >, =
std::allocator<std::vector<finite::complexFinite,
 std::allocator<finite::complexFinite> > > > const*, unsigned int, bool, st=
d::vector<std::vector<std::vector<unsigned int, std::allocator<unsigned int=
> >, std::allocator<std::vector<unsigned int,
 std::allocator<unsigned int> > > >, std::allocator<std::vector<std::vector=
<unsigned int, std::allocator<unsigned int> >, std::allocator<std::vector<u=
nsigned int, std::allocator<unsigned int> > > > > >
 const*, std::vector<std::vector<std::vector<finite::complexx, std::allocat=
or<finite::complexx> >, std::allocator<std::vector<finite::complexx, std::a=
llocator<finite::complexx> > > >,
 std::allocator<std::vector<std::vector<finite::complexx, std::allocator<fi=
nite::complexx> >, std::allocator<std::vector<finite::complexx, std::alloca=
tor<finite::complexx> > > > > > const*) at
 points/apple/rx_hw/VP/ETC_VP_Frontend.cpp:4520\\n")

--=-=-=--




Information forwarded to bug-gnu-emacs@HIDDEN:
bug#22149; Package emacs. Full text available.

Message received at 22149 <at> debbugs.gnu.org:


Received: (at 22149) by debbugs.gnu.org; 12 Dec 2015 10:13:20 +0000
From debbugs-submit-bounces <at> debbugs.gnu.org Sat Dec 12 05:13:20 2015
Received: from localhost ([127.0.0.1]:35421 helo=debbugs.gnu.org)
	by debbugs.gnu.org with esmtp (Exim 4.84)
	(envelope-from <debbugs-submit-bounces <at> debbugs.gnu.org>)
	id 1a7hB2-0008Gn-Bs
	for submit <at> debbugs.gnu.org; Sat, 12 Dec 2015 05:13:20 -0500
Received: from mail-out.m-online.net ([212.18.0.10]:33715)
 by debbugs.gnu.org with esmtp (Exim 4.84)
 (envelope-from <whitebox@HIDDEN>) id 1a7hB0-0008Gf-NN
 for 22149 <at> debbugs.gnu.org; Sat, 12 Dec 2015 05:13:19 -0500
Received: from frontend01.mail.m-online.net (unknown [192.168.8.182])
 by mail-out.m-online.net (Postfix) with ESMTP id 3pHlDY5zpVz3hht0;
 Sat, 12 Dec 2015 11:13:17 +0100 (CET)
Received: from localhost (dynscan1.mnet-online.de [192.168.6.68])
 by mail.m-online.net (Postfix) with ESMTP id 3pHlDY4LXmzvkM0;
 Sat, 12 Dec 2015 11:13:17 +0100 (CET)
X-Virus-Scanned: amavisd-new at mnet-online.de
Received: from mail.mnet-online.de ([192.168.8.182])
 by localhost (dynscan1.mail.m-online.net [192.168.6.68]) (amavisd-new,
 port 10024)
 with ESMTP id aZZzWEXcJZW3; Sat, 12 Dec 2015 11:13:16 +0100 (CET)
X-Auth-Info: P2g8HIB4S54VTSbD3E+YE+LXrWrQVCgt8HsxnlS2AlXBnD10UXABUtu+uSmvmMmf
Received: from linux.local (ppp-88-217-15-23.dynamic.mnet-online.de
 [88.217.15.23]) by mail.mnet-online.de (Postfix) with ESMTPA;
 Sat, 12 Dec 2015 11:13:16 +0100 (CET)
Received: by linux.local (Postfix, from userid 501)
 id 44F781E5300; Sat, 12 Dec 2015 11:13:13 +0100 (CET)
From: Andreas Schwab <schwab@HIDDEN>
To: Cheng-An Yang <rhymer123@HIDDEN>
Subject: Re: bug#22149: 24.4; gdb stack overflow in regexp matcher
References: <CAKAd=p6_kJUsMmZ=5=SjOJzZDxfmXm8kiKZFzBzJbm0=3QLoig@HIDDEN>
X-Yow: Oh, I get it!!  ``The BEACH goes on,'' huh, SONNY??
Date: Sat, 12 Dec 2015 11:13:13 +0100
In-Reply-To: <CAKAd=p6_kJUsMmZ=5=SjOJzZDxfmXm8kiKZFzBzJbm0=3QLoig@HIDDEN>
 (Cheng-An Yang's message of "Fri, 11 Dec 2015 22:16:35 -0800")
Message-ID: <m2zixgnfeu.fsf@HIDDEN>
User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.5 (gnu/linux)
MIME-Version: 1.0
Content-Type: text/plain
X-Spam-Score: -0.7 (/)
X-Debbugs-Envelope-To: 22149
Cc: 22149 <at> debbugs.gnu.org
X-BeenThere: debbugs-submit <at> debbugs.gnu.org
X-Mailman-Version: 2.1.18
Precedence: list
List-Id: <debbugs-submit.debbugs.gnu.org>
List-Unsubscribe: <https://debbugs.gnu.org/cgi-bin/mailman/options/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=unsubscribe>
List-Archive: <https://debbugs.gnu.org/cgi-bin/mailman/private/debbugs-submit/>
List-Post: <mailto:debbugs-submit <at> debbugs.gnu.org>
List-Help: <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=help>
List-Subscribe: <https://debbugs.gnu.org/cgi-bin/mailman/listinfo/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=subscribe>
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
X-Spam-Score: -0.7 (/)

Cheng-An Yang <rhymer123@HIDDEN> writes:

> I am using Emacs GDB Graphical Interface to debug a large C++ project.
> When I stop at certain functions, it breaks the GDB interface with the
> error message "Stack overflow in regexp matcher".

I cannot reproduce that error with Emacs 24.5 when evaluating the
string-match from the backtrace.

Andreas.

-- 
Andreas Schwab, schwab@HIDDEN
GPG Key fingerprint = 58CA 54C7 6D53 942B 1756  01D3 44D5 214B 8276 4ED5
"And now for something completely different."




Information forwarded to bug-gnu-emacs@HIDDEN:
bug#22149; Package emacs. Full text available.

Message received at submit <at> debbugs.gnu.org:


Received: (at submit) by debbugs.gnu.org; 12 Dec 2015 06:31:13 +0000
From debbugs-submit-bounces <at> debbugs.gnu.org Sat Dec 12 01:31:13 2015
Received: from localhost ([127.0.0.1]:35335 helo=debbugs.gnu.org)
	by debbugs.gnu.org with esmtp (Exim 4.84)
	(envelope-from <debbugs-submit-bounces <at> debbugs.gnu.org>)
	id 1a7di5-0003Hy-NE
	for submit <at> debbugs.gnu.org; Sat, 12 Dec 2015 01:31:13 -0500
Received: from eggs.gnu.org ([208.118.235.92]:58688)
 by debbugs.gnu.org with esmtp (Exim 4.84)
 (envelope-from <rhymer123@HIDDEN>) id 1a7dUw-0002uY-IW
 for submit <at> debbugs.gnu.org; Sat, 12 Dec 2015 01:17:38 -0500
Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71)
 (envelope-from <rhymer123@HIDDEN>) id 1a7dUe-0001w9-8s
 for submit <at> debbugs.gnu.org; Sat, 12 Dec 2015 01:17:32 -0500
X-Spam-Checker-Version: SpamAssassin 3.3.2 (2011-06-06) on eggs.gnu.org
X-Spam-Level: *
X-Spam-Status: No, score=1.1 required=5.0 tests=BAYES_50,
 FREEMAIL_ENVFROM_END_DIGIT,FREEMAIL_FROM,HTML_MESSAGE,T_DKIM_INVALID
 autolearn=disabled version=3.3.2
Received: from lists.gnu.org ([2001:4830:134:3::11]:35362)
 by eggs.gnu.org with esmtp (Exim 4.71)
 (envelope-from <rhymer123@HIDDEN>) id 1a7dUe-0001w0-2s
 for submit <at> debbugs.gnu.org; Sat, 12 Dec 2015 01:17:20 -0500
Received: from eggs.gnu.org ([2001:4830:134:3::10]:40215)
 by lists.gnu.org with esmtp (Exim 4.71)
 (envelope-from <rhymer123@HIDDEN>) id 1a7dUS-0006Zy-Ng
 for bug-gnu-emacs@HIDDEN; Sat, 12 Dec 2015 01:17:20 -0500
Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71)
 (envelope-from <rhymer123@HIDDEN>) id 1a7dUG-0001hO-B3
 for bug-gnu-emacs@HIDDEN; Sat, 12 Dec 2015 01:17:08 -0500
Received: from mail-io0-x22a.google.com ([2607:f8b0:4001:c06::22a]:35305)
 by eggs.gnu.org with esmtp (Exim 4.71)
 (envelope-from <rhymer123@HIDDEN>) id 1a7dUF-0001gu-U2
 for bug-gnu-emacs@HIDDEN; Sat, 12 Dec 2015 01:16:56 -0500
Received: by ioc74 with SMTP id 74so147867183ioc.2
 for <bug-gnu-emacs@HIDDEN>; Fri, 11 Dec 2015 22:16:55 -0800 (PST)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113;
 h=mime-version:from:date:message-id:subject:to:content-type;
 bh=k9HaXWz0GfnB7iydTFhHqStfQv42R0LWgTOE9D6R7cE=;
 b=FjvD0tv3aCfqKVLfvCv8a1EplQSBboSAGVtIHwQJ2QsivVrtLsiicX7Cl4eJLOTaUJ
 LAZWu2UT2/0WGFC3CF1J0mATsDtrJon2ivWLphWC690ZfTbTL+7ncc+uyeYWSq8lzgUm
 wWCR8lC5RZt7T2HOk34sMkEUf/67/r9wS2Yz/e4cMOu3QXe6FiE8KN5jJgiKE0aq6qzz
 BGA7tdIys1Qj9EaL2pAXAWboDBXBVABnDDknWB+5hnA+njMV48Pnb2VaPAbiHkcfs/an
 FEKElYkSPdd6123hybeEnPGwbeMIGlHBZC5V3kf4N2eWgnTjikIZK6a2bj2k11WKzDEB
 yRCQ==
X-Received: by 10.107.160.208 with SMTP id j199mr20040723ioe.23.1449901014991; 
 Fri, 11 Dec 2015 22:16:54 -0800 (PST)
MIME-Version: 1.0
Received: by 10.36.124.133 with HTTP; Fri, 11 Dec 2015 22:16:35 -0800 (PST)
From: Cheng-An Yang <rhymer123@HIDDEN>
Date: Fri, 11 Dec 2015 22:16:35 -0800
Message-ID: <CAKAd=p6_kJUsMmZ=5=SjOJzZDxfmXm8kiKZFzBzJbm0=3QLoig@HIDDEN>
Subject: 24.4; gdb stack overflow in regexp matcher
To: bug-gnu-emacs@HIDDEN
Content-Type: multipart/alternative; boundary=001a1140bfd8f54b870526ad6239
X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic]
X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6.x
X-Received-From: 2001:4830:134:3::11
X-Debbugs-Envelope-To: submit
X-Mailman-Approved-At: Sat, 12 Dec 2015 01:31:12 -0500
X-BeenThere: debbugs-submit <at> debbugs.gnu.org
X-Mailman-Version: 2.1.18
Precedence: list
List-Id: <debbugs-submit.debbugs.gnu.org>
List-Unsubscribe: <https://debbugs.gnu.org/cgi-bin/mailman/options/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=unsubscribe>
List-Archive: <https://debbugs.gnu.org/cgi-bin/mailman/private/debbugs-submit/>
List-Post: <mailto:debbugs-submit <at> debbugs.gnu.org>
List-Help: <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=help>
List-Subscribe: <https://debbugs.gnu.org/cgi-bin/mailman/listinfo/debbugs-submit>, 
 <mailto:debbugs-submit-request <at> debbugs.gnu.org?subject=subscribe>
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>

--001a1140bfd8f54b870526ad6239
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

From: Rhymer Yang <rhymer123@HIDDEN>
To: bug-gnu-emacs@HIDDEN
Subject: 24.4; gdb stack overflow in regexp matcher
--text follows this line--

Hello,

I am using Emacs GDB Graphical Interface to debug a large C++ project.
When I stop at certain functions, it breaks the GDB interface with the
error message "Stack overflow in regexp matcher".

I did some google search and found that quite a few people also have
this problem. However, it's not clear how to solve the problem. Any
suggestions? Thanks!

Best,
Rhymer

Here are the output from backtrace:

Debugger entered--Lisp error: (error "Stack overflow in regexp matcher")
  string-match("\\([~@&]\\)\\(\"\\(?:[^\\\"]\\|\\\\.\\)*\"\\)\n" "~\"5
  breakpoint     keep y   0x00002aaac4d594fa in
SIMULATION_VP::ETC_VP_Frontend::chanDecodeComputing(boost::shared_ptr<SIMUL=
ATION_VP::ETC_V1_DEC_CON>,
std::vector<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > > >*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > const&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::allocator<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > > > >&, std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >&,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&, std::vector<unsigned int,
std::allocator<unsigned int> >, std::vector<std::vector<std::vector<int,
std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int>
> > >, std::allocator<std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > > >,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > > const&,
std::vector<std::vector<bool, std::allocator<bool> >,
std::allocator<std::vector<bool, std::allocator<bool> > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >&, std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> >,
std::allocator<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> > > >,
std::allocator<std::vector<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> >,
std::allocator<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> > > > > >,
std::allocator<std::vector<std::vector<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> >,
std::allocator<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> > > >,
std::allocator<std::vector<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> >,
std::allocator<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> > > > > > > >*,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&,
std::vector<std::vector<std::vector<std::vector<std::vector<finite::complex=
Finite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >,
std::allocator<std::vector<std::vector<std::vector<std::vector<finite::comp=
lexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > > > >&,
std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::vector<finite::Finite, std::allocator<finite::Finite> >,
unsigned int, bool, std::vector<int, std::allocator<int> >,
std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > >, std::vector<int,
std::allocator<int> >, std::vector<unsigned int, std::allocator<unsigned
int> > const&, std::vector<unsigned int, std::allocator<unsigned int> >
const&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > > const&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > > const&,
std::vector<std::vector<bool, std::allocator<bool> >,
std::allocator<std::vector<bool, std::allocator<bool> > > >,
finite::Finite, std::vector<bool, std::allocator<bool> >, unsigned int,
unsigned int, bool, bool, std::vector<bool, std::allocator<bool> > const*,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > const*, unsigned int, bool,
std::vector<std::vector<std::vector<unsigned int, std::allocator<unsigned
int> >, std::allocator<std::vector<unsigned int, std::allocator<unsigned
int> > > >, std::allocator<std::vector<std::vector<unsigned int,
std::allocator<unsigned int> >, std::allocator<std::vector<unsigned int,
std::allocator<unsigned int> > > > > > const*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > const*) at
points/apple/rx_hw/VP/ETC_VP_Frontend.cpp:4520\\n\"\n^done\n(gdb)
\n146^done,frame=3D{level=3D\"0\",addr=3D\"0x00002aaabc5d80ff\",func=3D\"ET=
C_EU::EU_PSD::scheduleAllDecode\",file=3D\"points/apple/psd/eu_psd.cpp\",fu=
llname=3D\"/prj/qct/etc-sys/apple/users/usery/Simu/sim_apple/points/apple/p=
sd/eu_psd.cpp\",line=3D\"13346\"}\n(gdb)
\n147^done,threads=3D[{id=3D\"1\",target-id=3D\"Thread 0x2aaad0e72a20 (LWP
590)\",name=3D\"sim_apple.LGD.\",frame=3D{level=3D\"0\",addr=3D\"0x00002aaa=
bc5d80ff\",func=3D\"ETC_EU::EU_PSD::scheduleAllDecode\",args=3D[{name=3D\"t=
his\",value=3D\"0x55560d500e40\"}],file=3D\"points/apple/psd/eu_psd.cpp\",f=
ullname=3D\"/prj/qct/etc-sys/apple/users/usery/Simu/sim_apple/points/apple/=
psd/eu_psd.cpp\",line=3D\"13346\"},state=3D\"stopped\",core=3D\"7\"}],curre=
nt-thread-id=3D\"1\"\n(gdb)
\n148^done,BreakpointTable=3D{nr_rows=3D\"1\",nr_cols=3D\"6\",hdr=3D[{width=
=3D\"7\",alignment=3D\"-1\",col_name=3D\"number\",colhdr=3D\"Num\"},{width=
=3D\"14\",alignment=3D\"-1\",col_name=3D\"type\",colhdr=3D\"Type\"},{width=
=3D\"4\",alignment=3D\"-1\",col_name=3D\"disp\",colhdr=3D\"Disp\"},{width=
=3D\"3\",alignment=3D\"-1\",col_name=3D\"enabled\",colhdr=3D\"Enb\"},{width=
=3D\"18\",alignment=3D\"-1\",col_name=3D\"addr\",colhdr=3D\"Address\"},{wid=
th=3D\"40\",alignment=3D\"2\",col_name=3D\"what\",colhdr=3D\"What\"}],body=
=3D[bkpt=3D{number=3D\"5\",type=3D\"breakpoint\",disp=3D\"keep\",enabled=3D=
\"y\",addr=3D\"0x00002aaac4d594fa\",func=3D\"SIMULATION_VP::ETC_VP_Frontend=
::chanDecodeComputing(boost::shared_ptr<SIMULATION_VP::ETC_V1_DEC_CON>,
std::vector<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > > >*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > const&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::allocator<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > > > >&, std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >&,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&, std::vector<unsigned int,
std::allocator<unsigned int> >, std::vector<std::vector<std::vector<int,
std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int>
> > >, std::allocator<std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > > >,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > > const&,
std::vector<std::vector<bool, std::allocator<bool> >,
std::allocator<std::vector<bool, std::allocator<bool> > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >&, std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> >,
std::allocator<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> > > >,
std::allocator<std::vector<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> >,
std::allocator<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> > > > > >,
std::allocator<std::vector<std::vector<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> >,
std::allocator<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> > > >,
std::allocator<std::vector<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> >,
std::allocator<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> > > > > > > >*,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&,
std::vector<std::vector<std::vector<std::vector<std::vector<finite::complex=
Finite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >,
std::allocator<std::vector<std::vector<std::vector<std::vector<finite::comp=
lexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > > > >&,
std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::vector<finite::Finite, std::allocator<finite::Finite> >,
unsigned int, bool, std::vector<int, std::allocator<int> >,
std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > >, std::vector<int,
std::allocator<int> >, std::vector<unsigned int, std::allocator<unsigned
int> > const&, std::vector<unsigned int, std::allocator<unsigned int> >
const&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > > const&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > > const&,
std::vector<std::vector<bool, std::allocator<bool> >,
std::allocator<std::vector<bool, std::allocator<bool> > > >,
finite::Finite, std::vector<bool, std::allocator<bool> >, unsigned int,
unsigned int, bool, bool, std::vector<bool, std::allocator<bool> > const*,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > const*, unsigned int, bool,
std::vector<std::vector<std::vector<unsigned int, std::allocator<unsigned
int> >, std::allocator<std::vector<unsigned int, std::allocator<unsigned
int> > > >, std::allocator<std::vector<std::vector<unsigned int,
std::allocator<unsigned int> >, std::allocator<std::vector<unsigned int,
std::allocator<unsigned int> > > > > > const*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > >
const*)\",file=3D\"points/apple/rx_hw/VP/ETC_VP_Frontend.cpp\",fullname=3D\=
"/prj/qct/etc-sys/apple/users/usery/Simu/sim_apple/points/apple/rx_hw/VP/ET=
C_VP_Frontend.cpp\",line=3D\"4520\",times=3D\"0\",original-location=3D\"ETC=
_VP_Frontend.cpp:4520\"}]}\n(gdb)
\n149^done,locals=3D[{name=3D\"pucch_reporting_type\",type=3D\"std::vector<=
unsigned
int, std::allocator<unsigned int>
>\"},{name=3D\"rnnBias_DualDecode\",type=3D\"double\",value=3D\"6.953355807=
0642619e-310\"},{name=3D\"subframeNumMod\",type=3D\"const
int\",value=3D\"10922\"},{name=3D\"CSF_CON_printed\",type=3D\"bool\",value=
=3D\"true\"},{name=3D\"CSF_report_exist\",type=3D\"std::vector<bool,
std::allocator<bool> >\"},{name=3D\"useCSF_L0\",type=3D\"const
bool\",value=3D\"true\"},{name=3D\"enforceTM10Schedule\",type=3D\"bool\",va=
lue=3D\"false\"},{name=3D\"NumSymbPerSlot\",type=3D\"uint\",value=3D\"32767=
\"},{name=3D\"__PRETTY_FUNCTION__\",type=3D\"const
char [40]\"},{name=3D\"chan_type\",type=3D\"std::vector<unsigned int,
std::allocator<unsigned int>
>\"},{name=3D\"doCSF_Proc_DualDecode\",type=3D\"bool\",value=3D\"false\"},{=
name=3D\"scheduledCSF\",type=3D\"std::vector<std::vector<std::vector<bool,
std::allocator<bool> >, std::allocator<std::vector<bool,
std::allocator<bool> > > >, std::allocator<std::vector<std::vector<bool,
std::allocator<bool> >, std::allocator<std::vector<bool,
std::allocator<bool> > > > >
>\"},{name=3D\"isDLSubframe\",type=3D\"bool\",value=3D\"208\"},{name=3D\"to=
tal_subframe_num\",type=3D\"std::vector<unsigned
long long, std::allocator<unsigned long long>
>\"},{name=3D\"bwp_index\",type=3D\"std::vector<std::vector<unsigned int,
std::allocator<unsigned int> >, std::allocator<std::vector<unsigned int,
std::allocator<unsigned int> > >
>\"},{name=3D\"sched_pusch_csf\",type=3D\"std::vector<bool,
std::allocator<bool>
>\"},{name=3D\"issue_SCHED_MSG\",type=3D\"std::vector<bool,
std::allocator<bool>
>\"},{name=3D\"interfBias_DualDecode\",type=3D\"std::vector<double,
std::allocator<double>
>\"},{name=3D\"pmchEnabledThisSF\",type=3D\"bool\",value=3D\"181\"},{name=
=3D\"lastSyminSF\",type=3D\"bool\",value=3D\"110\"}]\n(gdb)
\n150^done,stack=3D[frame=3D{level=3D\"0\",addr=3D\"0x00002aaabc5d80ff\",fu=
nc=3D\"ETC_EU::EU_PSD::scheduleAllDecode\",file=3D\"points/apple/psd/eu_psd=
.cpp\",fullname=3D\"/prj/qct/etc-sys/apple/users/usery/Simu/sim_apple/point=
s/apple/psd/eu_psd.cpp\",line=3D\"13346\"},frame=3D{level=3D\"1\",addr=3D\"=
0x00002aaabc59696f\",func=3D\"ETC_EU::EU_PSD::Update\",file=3D\"points/appl=
e/psd/eu_psd.cpp\",fullname=3D\"/prj/qct/etc-sys/apple/users/usery/Simu/sim=
_apple/points/apple/psd/eu_psd.cpp\",line=3D\"5530\"},frame=3D{level=3D\"2\=
",addr=3D\"0x00002aaac7b3ea55\",func=3D\"ETC_EU::EU::RxxRUpdate\",file=3D\"=
points/apple/top/ue.cpp\",fullname=3D\"/apple/users/usery/Simu/sim_apple/po=
ints/apple/top/ue.cpp\",line=3D\"1273\"},frame=3D{level=3D\"3\",addr=3D\"0x=
00002aaac7b3ce40\",func=3D\"ETC_EU::EU::Update\",file=3D\"points/apple/top/=
ue.cpp\",fullname=3D\"/abc/def/etc-sys/apple/users/usery/Simu/sim_apple/poi=
nts/apple/top/ue.cpp\",line=3D\"1036\"},frame=3D{level=3D\"4\",addr=3D\"0x0=
0002aaacf258e96\",func=3D\"wiltsim::WiltSimTop_class::AdvanceSim\",file=3D\=
"wiltsim/sim/top/WiltSimTop.cpp\",fullname=3D\"/abc/def/etc-sys/apple/users=
/usery/Simu/sim_apple/wiltsim/sim/top/WiltSimTop.cpp\",line=3D\"168\"},fram=
e=3D{level=3D\"5\",addr=3D\"0x00002aaacf97834e\",func=3D\"main\",file=3D\"w=
iltsim/sim/main/main.cpp\",fullname=3D\"/abc/def/etc-sys/apple/users/usery/=
Simu/sim_apple/wiltsim/sim/main/main.cpp\",line=3D\"45\"},frame=3D{level=3D=
\"6\",addr=3D\"0x00002aaad07fdc36\",func=3D\"__libc_start_main\",from=3D\"/=
lib64/libc.so.6\"},frame=3D{level=3D\"7\",addr=3D\"0x000055555556b2e9\",fun=
c=3D\"_start\",file=3D\"../sysdeps/x86_64/elf/start.S\",line=3D\"103\"}]\n(=
gdb)
\n^running\n*running,thread-id=3D\"1\"\n(gdb)
\n*stopped,reason=3D\"end-stepping-range\",frame=3D{addr=3D\"0x00002aaabc5d=
8121\",func=3D\"ETC_EU::EU_PSD::scheduleAllDecode\",args=3D[{name=3D\"this\=
",value=3D\"0x55560d500e40\"}],file=3D\"points/apple/psd/eu_psd.cpp\",fulln=
ame=3D\"/abc/def/etc-sys/apple/users/usery/Simu/sim_apple/points/apple/psd/=
eu_psd.cpp\",line=3D\"13348\"},thread-id=3D\"1\",stopped-threads=3D[\"1\"],=
core=3D\"5\"\n~\"Continuing.\\n\"\n^running\n*running,thread-id=3D\"1\"\n(g=
db)
\n=3Dbreakpoint-modified,bkpt=3D{number=3D\"5\",type=3D\"breakpoint\",disp=
=3D\"keep\",enabled=3D\"y\",addr=3D\"0x00002aaac4d594fa\",func=3D\"SIMULATI=
ON_VP::ETC_VP_Frontend::chanDecodeComputing(boost::shared_ptr<SIMULATION_VP=
::ETC_V1_DEC_CON>,
std::vector<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > > >*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > const&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::allocator<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > > > >&, std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >&,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&, std::vector<unsigned int,
std::allocator<unsigned int> >, std::vector<std::vector<std::vector<int,
std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int>
> > >, std::allocator<std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > > >,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >, std::allocator<std::ve" 0)
  gdbmi-bnf-stream-record()
  gdbmi-bnf-out-of-band-record()
  gdbmi-bnf-output()
  #[0 " \300W\205 \n \205 \202  \207" [42969 gdbmi-bnf-offset
gdbmi-bnf-state] 2 "\n\n(fn)"]()
  funcall(#[0 " \300W\205 \n \205 \202  \207" [42969 gdbmi-bnf-offset
gdbmi-bnf-state] 2 "\n\n(fn)"])

gud-gdbmi-marker-fietcr("=3Dbreakpoint-modified,bkpt=3D{number=3D\"5\",type=
=3D\"breakpoint\",disp=3D\"keep\",enabled=3D\"y\",addr=3D\"0x00002aaac4d594=
fa\",func=3D\"SIMULATION_VP::ETC_VP_Frontend::chanDecodeComputing(boost::sh=
ared_ptr<SIMULATION_VP::ETC_V1_DEC_CON>,
std::vector<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > > >*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > const&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::allocator<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > > > >&, std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >&,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&, std::vector<unsigned int,
std::allocator<unsigned int> >, std::vector<std::vector<std::vector<int,
std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int>
> > >, std::allocator<std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > > >,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >, std::allocator<std::ve")
  apply(gud-gdbmi-marker-fietcr
"=3Dbreakpoint-modified,bkpt=3D{number=3D\"5\",type=3D\"breakpoint\",disp=
=3D\"keep\",enabled=3D\"y\",addr=3D\"0x00002aaac4d594fa\",func=3D\"SIMULATI=
ON_VP::ETC_VP_Frontend::chanDecodeComputing(boost::shared_ptr<SIMULATION_VP=
::ETC_V1_DEC_CON>,
std::vector<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > > >*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > const&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::allocator<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > > > >&, std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >&,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&, std::vector<unsigned int,
std::allocator<unsigned int> >, std::vector<std::vector<std::vector<int,
std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int>
> > >, std::allocator<std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > > >,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >, std::allocator<std::ve")

gud-marker-fietcr("=3Dbreakpoint-modified,bkpt=3D{number=3D\"5\",type=3D\"b=
reakpoint\",disp=3D\"keep\",enabled=3D\"y\",addr=3D\"0x00002aaac4d594fa\",f=
unc=3D\"SIMULATION_VP::ETC_VP_Frontend::chanDecodeComputing(boost::shared_p=
tr<SIMULATION_VP::ETC_V1_DEC_CON>,
std::vector<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > > >*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > const&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::allocator<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > > > >&, std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >&,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&, std::vector<unsigned int,
std::allocator<unsigned int> >, std::vector<std::vector<std::vector<int,
std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int>
> > >, std::allocator<std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > > >,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >, std::allocator<std::ve")
  gud-fietcr(#<process gud-sim_apple.LGD.bin>
"=3Dbreakpoint-modified,bkpt=3D{number=3D\"5\",type=3D\"breakpoint\",disp=
=3D\"keep\",enabled=3D\"y\",addr=3D\"0x00002aaac4d594fa\",func=3D\"SIMULATI=
ON_VP::ETC_VP_Frontend::chanDecodeComputing(boost::shared_ptr<SIMULATION_VP=
::ETC_V1_DEC_CON>,
std::vector<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > > >*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > const&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::allocator<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > > > >&, std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >&,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&, std::vector<unsigned int,
std::allocator<unsigned int> >, std::vector<std::vector<std::vector<int,
std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int>
> > >, std::allocator<std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > > >,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >, std::allocator<std::ve")




In GNU Emacs 24.4.1 (x86_64-unknown-linux-gnu, GTK+ Version 2.18.9)
 of 2014-11-15 on vl-nbharadw-gridsdca
Windowing system distributor `The X.Org Foundation', version 11.0.11202000
System Description: SUSE Linux Enterprise Server 11 (x86_64)

Configured using:
 `configure --prefix=3D/pkg/software/emacs/24.4/sles11 --without-rsvg'

Important settings:
  value of $LANG: en_US.UTF-8
  value of $XMODIFIERS: @im=3Dlocal
  locale-coding-system: utf-8-unix

Major mode: Debugger

Minor modes in effect:
  global-semanticdb-minor-mode: t
  global-semantic-idle-scheduler-mode: t
  global-semantic-idle-summary-mode: t
  global-semantic-stickyfunc-mode: t
  semantic-mode: t
  clean-aindent-mode: t
  show-smartparens-global-mode: t
  yas-global-mode: t
  yas-minor-mode: t
  gdb-many-windows: t
  projectile-global-mode: t
  projectile-mode: t
  helm-descbinds-mode: t
  helm-mode: t
  shell-dirtrack-mode: t
  recentf-mode: t
  winner-mode: t
  window-numbering-mode: t
  volatile-highlights-mode: t
  global-vi-tilde-fringe-mode: t
  vi-tilde-fringe-mode: t
  global-undo-tree-mode: t
  undo-tree-mode: t
  savehist-mode: t
  popwin-mode: t
  global-page-break-lines-mode: t
  Info-breadcrumbs-in-mode-line-mode: t
  ido-vertical-mode: t
  flx-ido-mode: t
  eyebrowse-mode: t
  global-evil-surround-mode: t
  evil-surround-mode: t
  global-evil-search-highlight-persist: t
  evil-search-highlight-persist: t
  evil-jumper-mode: t
  evil-escape-mode: t
  global-anzu-mode: t
  anzu-mode: t
  eval-sexp-fu-flash-mode: t
  global-diff-hl-mode: t
  diff-auto-refine-mode: t
  global-hl-line-mode: t
  xterm-mouse-mode: t
  global-auto-revert-mode: t
  evil-leader-mode: t
  evil-mode: t
  evil-local-mode: t
  which-key-mode: t
  override-global-mode: t
  spacemacs-additional-leader-mode: t
  electric-indent-mode: t
  mouse-wheel-mode: t
  file-name-shadow-mode: t
  global-font-lock-mode: t
  font-lock-mode: t
  auto-composition-mode: t
  auto-encryption-mode: t
  auto-compression-mode: t
  buffer-read-only: t
  column-number-mode: t
  line-number-mode: t
  transient-mark-mode: t

Recent messages:
error in process fietcr: gdbmi-bnf-stream-record: Stack overflow in regexp
matcher
error in process fietcr: Stack overflow in regexp matcher
Mark set
Debug on Error enabled globally
debug-on-error enabled.
Entering debugger...
debugger-frame-number: This line is not a function call
command-execute: Buffer is read-only: #<buffer *Backtrace*> [2 times]
debugger-frame-number: This line is not a function call
Quit

Memory information:
((conses 16 2563016 1021331)
 (symbols 48 64059 16)
 (miscs 40 12883 3188)
 (strings 32 349590 287677)
 (string-bytes 1 17342091)
 (vectors 16 152172)
 (vector-slots 8 4020213 1448882)
 (floats 8 15298 10001)
 (intervals 56 28898 15957)
 (buffers 960 44)
 (heap 1024 184239 72761))

--001a1140bfd8f54b870526ad6239
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div>From: Rhymer Yang &lt;<a href=3D"mailto:rhymer123@gma=
il.com">rhymer123@HIDDEN</a>&gt;</div><div>To: <a href=3D"mailto:bug-gnu=
-emacs@HIDDEN">bug-gnu-emacs@HIDDEN</a></div><div>Subject: 24.4; gdb stac=
k overflow in regexp matcher</div><div>--text follows this line--</div><div=
><br></div><div>Hello,</div><div><br></div><div>I am using Emacs GDB Graphi=
cal Interface to debug a large C++ project.</div><div>When I stop at certai=
n functions, it breaks the GDB interface with the</div><div>error message &=
quot;Stack overflow in regexp matcher&quot;.</div><div><br></div><div>I did=
 some google search and found that quite a few people also have</div><div>t=
his problem. However, it&#39;s not clear how to solve the problem. Any</div=
><div>suggestions? Thanks!</div><div><br></div><div>Best,</div><div>Rhymer<=
/div><div><br></div><div>Here are the output from backtrace:</div><div><br>=
</div><div>Debugger entered--Lisp error: (error &quot;Stack overflow in reg=
exp matcher&quot;)</div><div>=C2=A0 string-match(&quot;\\([~@&amp;]\\)\\(\&=
quot;\\(?:[^\\\&quot;]\\|\\\\.\\)*\&quot;\\)\n&quot; &quot;~\&quot;5 =C2=A0=
 =C2=A0 =C2=A0 breakpoint =C2=A0 =C2=A0 keep y =C2=A0 0x00002aaac4d594fa in=
 SIMULATION_VP::ETC_VP_Frontend::chanDecodeComputing(boost::shared_ptr&lt;S=
IMULATION_VP::ETC_V1_DEC_CON&gt;, std::vector&lt;std::vector&lt;std::vector=
&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt;=
 &gt;, std::allocator&lt;std::vector&lt;finite::complexx, std::allocator&lt=
;finite::complexx&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std:=
:vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;, s=
td::allocator&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite:=
:complexx&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;st=
d::vector&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::com=
plexx&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexx, std::all=
ocator&lt;finite::complexx&gt; &gt; &gt; &gt;, std::allocator&lt;std::vecto=
r&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt=
; &gt;, std::allocator&lt;std::vector&lt;finite::complexx, std::allocator&l=
t;finite::complexx&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;*, std::vector&lt;=
std::vector&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::c=
omplexx&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexx, std::a=
llocator&lt;finite::complexx&gt; &gt; &gt; &gt;, std::allocator&lt;std::vec=
tor&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&=
gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexx, std::allocator=
&lt;finite::complexx&gt; &gt; &gt; &gt; &gt; &gt; const&amp;, std::vector&l=
t;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;fi=
nite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::comp=
lexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std:=
:allocator&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::all=
ocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;=
finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt=
; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;std::vector&lt;finite:=
:complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allo=
cator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::co=
mplexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vecto=
r&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt=
;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&l=
t;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;s=
td::vector&lt;std::vector&lt;std::vector&lt;finite::Finite, std::allocator&=
lt;finite::Finite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite=
, std::allocator&lt;finite::Finite&gt; &gt; &gt; &gt;, std::allocator&lt;st=
d::vector&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finit=
e&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite, std::allocator=
&lt;finite::Finite&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vec=
tor&lt;std::vector&lt;std::vector&lt;finite::Finite, std::allocator&lt;fini=
te::Finite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite, std::=
allocator&lt;finite::Finite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vect=
or&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &=
gt;, std::allocator&lt;std::vector&lt;finite::Finite, std::allocator&lt;fin=
ite::Finite&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;fin=
ite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;&amp;, =
std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;fini=
te::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::comple=
xFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;&amp;, s=
td::vector&lt;unsigned int, std::allocator&lt;unsigned int&gt; &gt;, std::v=
ector&lt;std::vector&lt;std::vector&lt;int, std::allocator&lt;int&gt; &gt;,=
 std::allocator&lt;std::vector&lt;int, std::allocator&lt;int&gt; &gt; &gt; =
&gt;, std::allocator&lt;std::vector&lt;std::vector&lt;int, std::allocator&l=
t;int&gt; &gt;, std::allocator&lt;std::vector&lt;int, std::allocator&lt;int=
&gt; &gt; &gt; &gt; &gt; &gt;, std::vector&lt;std::vector&lt;std::vector&lt=
;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFin=
ite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::=
allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;st=
d::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite=
::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexF=
inite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;=
, std::allocator&lt;std::vector&lt;std::vector&lt;std::vector&lt;finite::co=
mplexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocat=
or&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::compl=
exFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&l=
t;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, =
std::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;f=
inite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vect=
or&lt;std::vector&lt;std::vector&lt;std::vector&lt;finite::complexFinite, s=
td::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vec=
tor&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &=
gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite::comp=
lexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator=
&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complex=
Finite&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::=
vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::c=
omplexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFini=
te, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::alloca=
tor&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&=
lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite:=
:complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; =
&gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;std::vector&lt;std:=
:vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&g=
t; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::alloc=
ator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::ve=
ctor&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::com=
plexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite=
, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;, std=
::allocator&lt;std::vector&lt;std::vector&lt;std::vector&lt;finite::complex=
Finite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt=
;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFin=
ite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;fin=
ite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::=
allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite=
::complexFinite&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt=
;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;fin=
ite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::compl=
exFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::=
allocator&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allo=
cator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;f=
inite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt;=
 &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;std::vector&lt;finite::=
complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::alloc=
ator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::com=
plexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector=
&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;=
, std::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt=
;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;st=
d::vector&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allo=
cator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;f=
inite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt;=
 &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite::complexFinit=
e, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std:=
:vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&g=
t; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&l=
t;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFi=
nite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std:=
:allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;s=
td::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finit=
e::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complex=
Finite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt=
; &gt; &gt; const&amp;, std::vector&lt;std::vector&lt;bool, std::allocator&=
lt;bool&gt; &gt;, std::allocator&lt;std::vector&lt;bool, std::allocator&lt;=
bool&gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;std::vector&lt;=
finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, st=
d::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;fin=
ite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std=
::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&=
gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::allo=
cator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vect=
or&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&l=
t;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::=
complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, =
std::allocator&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std:=
:allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector=
&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;=
 &gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;std::vector&lt;fin=
ite::Finite, std::allocator&lt;finite::Finite&gt; &gt;, std::allocator&lt;s=
td::vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &gt; &gt=
; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite::Finite, std=
::allocator&lt;finite::Finite&gt; &gt;, std::allocator&lt;std::vector&lt;fi=
nite::Finite, std::allocator&lt;finite::Finite&gt; &gt; &gt; &gt; &gt; &gt;=
&amp;, std::vector&lt;std::vector&lt;std::vector&lt;finite::Finite, std::al=
locator&lt;finite::Finite&gt; &gt;, std::allocator&lt;std::vector&lt;finite=
::Finite, std::allocator&lt;finite::Finite&gt; &gt; &gt; &gt;, std::allocat=
or&lt;std::vector&lt;std::vector&lt;finite::Finite, std::allocator&lt;finit=
e::Finite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite, std::a=
llocator&lt;finite::Finite&gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&l=
t;std::vector&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::=
allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&=
lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; =
&gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite::complexF=
inite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;=
std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFini=
te&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vect=
or&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::compl=
exFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, =
std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&=
lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;f=
inite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::com=
plexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt;=
 &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;std::vector&lt;finite::=
complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::alloc=
ator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::com=
plexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector=
&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;=
, std::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt=
;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;st=
d::vector&lt;std::vector&lt;std::vector&lt;BlockCEParameter_class, std::all=
ocator&lt;BlockCEParameter_class&gt; &gt;, std::allocator&lt;std::vector&lt=
;BlockCEParameter_class, std::allocator&lt;BlockCEParameter_class&gt; &gt; =
&gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;BlockCEParameter=
_class, std::allocator&lt;BlockCEParameter_class&gt; &gt;, std::allocator&l=
t;std::vector&lt;BlockCEParameter_class, std::allocator&lt;BlockCEParameter=
_class&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::=
vector&lt;std::vector&lt;BlockCEParameter_class, std::allocator&lt;BlockCEP=
arameter_class&gt; &gt;, std::allocator&lt;std::vector&lt;BlockCEParameter_=
class, std::allocator&lt;BlockCEParameter_class&gt; &gt; &gt; &gt;, std::al=
locator&lt;std::vector&lt;std::vector&lt;BlockCEParameter_class, std::alloc=
ator&lt;BlockCEParameter_class&gt; &gt;, std::allocator&lt;std::vector&lt;B=
lockCEParameter_class, std::allocator&lt;BlockCEParameter_class&gt; &gt; &g=
t; &gt; &gt; &gt; &gt; &gt;*, std::vector&lt;std::vector&lt;finite::complex=
Finite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt=
;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFin=
ite&gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;std::vector&lt;s=
td::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finit=
e::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complex=
Finite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::al=
locator&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::alloca=
tor&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;fin=
ite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &=
gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;std::vector&=
lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;,=
 std::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;=
finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;=
std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFini=
te&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::a=
llocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;, s=
td::allocator&lt;std::vector&lt;std::vector&lt;std::vector&lt;std::vector&l=
t;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, =
std::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;f=
inite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;s=
td::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinit=
e&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::al=
locator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;, std::allocat=
or&lt;std::vector&lt;std::vector&lt;std::vector&lt;finite::complexFinite, s=
td::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vec=
tor&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &=
gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite::comp=
lexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator=
&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complex=
Finite&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&l=
t;std::vector&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::F=
inite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite, std::alloc=
ator&lt;finite::Finite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt=
;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &gt;, =
std::allocator&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::=
Finite&gt; &gt; &gt; &gt; &gt; &gt;, std::vector&lt;finite::Finite, std::al=
locator&lt;finite::Finite&gt; &gt;, unsigned int, bool, std::vector&lt;int,=
 std::allocator&lt;int&gt; &gt;, std::vector&lt;std::vector&lt;int, std::al=
locator&lt;int&gt; &gt;, std::allocator&lt;std::vector&lt;int, std::allocat=
or&lt;int&gt; &gt; &gt; &gt;, std::vector&lt;int, std::allocator&lt;int&gt;=
 &gt;, std::vector&lt;unsigned int, std::allocator&lt;unsigned int&gt; &gt;=
 const&amp;, std::vector&lt;unsigned int, std::allocator&lt;unsigned int&gt=
; &gt; const&amp;, std::vector&lt;std::vector&lt;std::vector&lt;std::vector=
&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;=
, std::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt=
;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt=
;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFin=
ite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::=
allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;, std::alloc=
ator&lt;std::vector&lt;std::vector&lt;std::vector&lt;finite::complexFinite,=
 std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::v=
ector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt;=
 &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite::co=
mplexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocat=
or&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::compl=
exFinite&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt; const&amp;, std::vector&lt;=
std::vector&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::al=
locator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt=
;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &g=
t; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite::complexFin=
ite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;st=
d::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite=
&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector=
&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complex=
Finite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, st=
d::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt=
;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;fin=
ite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::compl=
exFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &=
gt; &gt; &gt; const&amp;, std::vector&lt;std::vector&lt;bool, std::allocato=
r&lt;bool&gt; &gt;, std::allocator&lt;std::vector&lt;bool, std::allocator&l=
t;bool&gt; &gt; &gt; &gt;, finite::Finite, std::vector&lt;bool, std::alloca=
tor&lt;bool&gt; &gt;, unsigned int, unsigned int, bool, bool, std::vector&l=
t;bool, std::allocator&lt;bool&gt; &gt; const*, std::vector&lt;std::vector&=
lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;,=
 std::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;=
finite::complexFinite&gt; &gt; &gt; &gt; const*, unsigned int, bool, std::v=
ector&lt;std::vector&lt;std::vector&lt;unsigned int, std::allocator&lt;unsi=
gned int&gt; &gt;, std::allocator&lt;std::vector&lt;unsigned int, std::allo=
cator&lt;unsigned int&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;=
std::vector&lt;unsigned int, std::allocator&lt;unsigned int&gt; &gt;, std::=
allocator&lt;std::vector&lt;unsigned int, std::allocator&lt;unsigned int&gt=
; &gt; &gt; &gt; &gt; &gt; const*, std::vector&lt;std::vector&lt;std::vecto=
r&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;, std::al=
locator&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::compl=
exx&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;fin=
ite::complexx, std::allocator&lt;finite::complexx&gt; &gt;, std::allocator&=
lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; =
&gt; &gt; &gt; &gt; &gt; const*) at points/apple/rx_hw/VP/ETC_VP_Frontend.c=
pp:4520\\n\&quot;\n^done\n(gdb) \n146^done,frame=3D{level=3D\&quot;0\&quot;=
,addr=3D\&quot;0x00002aaabc5d80ff\&quot;,func=3D\&quot;ETC_EU::EU_PSD::sche=
duleAllDecode\&quot;,file=3D\&quot;points/apple/psd/eu_psd.cpp\&quot;,fulln=
ame=3D\&quot;/prj/qct/etc-sys/apple/users/usery/Simu/sim_apple/points/apple=
/psd/eu_psd.cpp\&quot;,line=3D\&quot;13346\&quot;}\n(gdb) \n147^done,thread=
s=3D[{id=3D\&quot;1\&quot;,target-id=3D\&quot;Thread 0x2aaad0e72a20 (LWP 59=
0)\&quot;,name=3D\&quot;sim_apple.LGD.\&quot;,frame=3D{level=3D\&quot;0\&qu=
ot;,addr=3D\&quot;0x00002aaabc5d80ff\&quot;,func=3D\&quot;ETC_EU::EU_PSD::s=
cheduleAllDecode\&quot;,args=3D[{name=3D\&quot;this\&quot;,value=3D\&quot;0=
x55560d500e40\&quot;}],file=3D\&quot;points/apple/psd/eu_psd.cpp\&quot;,ful=
lname=3D\&quot;/prj/qct/etc-sys/apple/users/usery/Simu/sim_apple/points/app=
le/psd/eu_psd.cpp\&quot;,line=3D\&quot;13346\&quot;},state=3D\&quot;stopped=
\&quot;,core=3D\&quot;7\&quot;}],current-thread-id=3D\&quot;1\&quot;\n(gdb)=
 \n148^done,BreakpointTable=3D{nr_rows=3D\&quot;1\&quot;,nr_cols=3D\&quot;6=
\&quot;,hdr=3D[{width=3D\&quot;7\&quot;,alignment=3D\&quot;-1\&quot;,col_na=
me=3D\&quot;number\&quot;,colhdr=3D\&quot;Num\&quot;},{width=3D\&quot;14\&q=
uot;,alignment=3D\&quot;-1\&quot;,col_name=3D\&quot;type\&quot;,colhdr=3D\&=
quot;Type\&quot;},{width=3D\&quot;4\&quot;,alignment=3D\&quot;-1\&quot;,col=
_name=3D\&quot;disp\&quot;,colhdr=3D\&quot;Disp\&quot;},{width=3D\&quot;3\&=
quot;,alignment=3D\&quot;-1\&quot;,col_name=3D\&quot;enabled\&quot;,colhdr=
=3D\&quot;Enb\&quot;},{width=3D\&quot;18\&quot;,alignment=3D\&quot;-1\&quot=
;,col_name=3D\&quot;addr\&quot;,colhdr=3D\&quot;Address\&quot;},{width=3D\&=
quot;40\&quot;,alignment=3D\&quot;2\&quot;,col_name=3D\&quot;what\&quot;,co=
lhdr=3D\&quot;What\&quot;}],body=3D[bkpt=3D{number=3D\&quot;5\&quot;,type=
=3D\&quot;breakpoint\&quot;,disp=3D\&quot;keep\&quot;,enabled=3D\&quot;y\&q=
uot;,addr=3D\&quot;0x00002aaac4d594fa\&quot;,func=3D\&quot;SIMULATION_VP::E=
TC_VP_Frontend::chanDecodeComputing(boost::shared_ptr&lt;SIMULATION_VP::ETC=
_V1_DEC_CON&gt;, std::vector&lt;std::vector&lt;std::vector&lt;std::vector&l=
t;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;, std::alloc=
ator&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::complexx=
&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite=
::complexx, std::allocator&lt;finite::complexx&gt; &gt;, std::allocator&lt;=
std::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt=
; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;std:=
:vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;, s=
td::allocator&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite:=
:complexx&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&=
lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;, std::allo=
cator&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::complex=
x&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;*, std::vector&lt;std::vector&lt;st=
d::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;,=
 std::allocator&lt;std::vector&lt;finite::complexx, std::allocator&lt;finit=
e::complexx&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vecto=
r&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;, std::al=
locator&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::compl=
exx&gt; &gt; &gt; &gt; &gt; &gt; const&amp;, std::vector&lt;std::vector&lt;=
std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFini=
te&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::a=
llocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std=
::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite:=
:complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFi=
nite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;&=
amp;, std::vector&lt;std::vector&lt;std::vector&lt;finite::complexFinite, s=
td::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vec=
tor&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &=
gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite::comp=
lexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator=
&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complex=
Finite&gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;std=
::vector&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finite=
&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite, std::allocator&=
lt;finite::Finite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std:=
:vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &gt;, std::=
allocator&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finit=
e&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vecto=
r&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &g=
t;, std::allocator&lt;std::vector&lt;finite::Finite, std::allocator&lt;fini=
te::Finite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector=
&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &gt;, std::allocat=
or&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &=
gt; &gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;finite::complexFinit=
e, std::allocator&lt;finite::complexFinite&gt; &gt;&amp;, std::vector&lt;st=
d::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite=
&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::all=
ocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;&amp;, std::vector&lt;uns=
igned int, std::allocator&lt;unsigned int&gt; &gt;, std::vector&lt;std::vec=
tor&lt;std::vector&lt;int, std::allocator&lt;int&gt; &gt;, std::allocator&l=
t;std::vector&lt;int, std::allocator&lt;int&gt; &gt; &gt; &gt;, std::alloca=
tor&lt;std::vector&lt;std::vector&lt;int, std::allocator&lt;int&gt; &gt;, s=
td::allocator&lt;std::vector&lt;int, std::allocator&lt;int&gt; &gt; &gt; &g=
t; &gt; &gt;, std::vector&lt;std::vector&lt;std::vector&lt;std::vector&lt;f=
inite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std=
::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;fini=
te::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std:=
:vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&g=
t; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::alloc=
ator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&=
lt;std::vector&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std:=
:allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector=
&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;=
 &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite::complex=
Finite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt=
;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFin=
ite&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector=
&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;=
finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::co=
mplexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, st=
d::allocator&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::a=
llocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&l=
t;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &=
gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;std::ve=
ctor&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; =
&gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::allocato=
r&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vecto=
r&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::comple=
xFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, s=
td::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt; &gt; &g=
t;&amp;, std::vector&lt;std::vector&lt;std::vector&lt;std::vector&lt;finite=
::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::all=
ocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::c=
omplexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vect=
or&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &g=
t;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&=
lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;st=
d::vector&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allo=
cator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;f=
inite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt;=
 &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite::complexFinit=
e, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std:=
:vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&g=
t; &gt; &gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;s=
td::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinit=
e&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::al=
locator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std:=
:vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::=
complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFin=
ite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;&a=
mp;, std::vector&lt;std::vector&lt;std::vector&lt;finite::complexFinite, st=
d::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vect=
or&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &g=
t; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite::compl=
exFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&=
lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexF=
inite&gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;std:=
:vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::=
complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFin=
ite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::alloc=
ator&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator=
&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite=
::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;=
 &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;std::vector&lt;=
finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, st=
d::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;fin=
ite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std=
::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&=
gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::allo=
cator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt; const=
&amp;, std::vector&lt;std::vector&lt;bool, std::allocator&lt;bool&gt; &gt;,=
 std::allocator&lt;std::vector&lt;bool, std::allocator&lt;bool&gt; &gt; &gt=
; &gt;&amp;, std::vector&lt;std::vector&lt;std::vector&lt;finite::complexFi=
nite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;s=
td::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinit=
e&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finit=
e::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::al=
locator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::=
complexFinite&gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector=
&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complex=
Finite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, st=
d::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt=
;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;fin=
ite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::compl=
exFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &=
gt;&amp;, std::vector&lt;std::vector&lt;std::vector&lt;finite::Finite, std:=
:allocator&lt;finite::Finite&gt; &gt;, std::allocator&lt;std::vector&lt;fin=
ite::Finite, std::allocator&lt;finite::Finite&gt; &gt; &gt; &gt;, std::allo=
cator&lt;std::vector&lt;std::vector&lt;finite::Finite, std::allocator&lt;fi=
nite::Finite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite, std=
::allocator&lt;finite::Finite&gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vecto=
r&lt;std::vector&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite=
::Finite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite, std::al=
locator&lt;finite::Finite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector=
&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &gt=
;, std::allocator&lt;std::vector&lt;finite::Finite, std::allocator&lt;finit=
e::Finite&gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;=
std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;fini=
te::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::comple=
xFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::a=
llocator&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::alloc=
ator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;fi=
nite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; =
&gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;std::vector=
&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;=
, std::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt=
;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt=
;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFin=
ite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::=
allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;&a=
mp;, std::vector&lt;std::vector&lt;std::vector&lt;finite::complexFinite, st=
d::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vect=
or&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &g=
t; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite::compl=
exFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&=
lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexF=
inite&gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;std:=
:vector&lt;std::vector&lt;BlockCEParameter_class, std::allocator&lt;BlockCE=
Parameter_class&gt; &gt;, std::allocator&lt;std::vector&lt;BlockCEParameter=
_class, std::allocator&lt;BlockCEParameter_class&gt; &gt; &gt; &gt;, std::a=
llocator&lt;std::vector&lt;std::vector&lt;BlockCEParameter_class, std::allo=
cator&lt;BlockCEParameter_class&gt; &gt;, std::allocator&lt;std::vector&lt;=
BlockCEParameter_class, std::allocator&lt;BlockCEParameter_class&gt; &gt; &=
gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;std::ve=
ctor&lt;BlockCEParameter_class, std::allocator&lt;BlockCEParameter_class&gt=
; &gt;, std::allocator&lt;std::vector&lt;BlockCEParameter_class, std::alloc=
ator&lt;BlockCEParameter_class&gt; &gt; &gt; &gt;, std::allocator&lt;std::v=
ector&lt;std::vector&lt;BlockCEParameter_class, std::allocator&lt;BlockCEPa=
rameter_class&gt; &gt;, std::allocator&lt;std::vector&lt;BlockCEParameter_c=
lass, std::allocator&lt;BlockCEParameter_class&gt; &gt; &gt; &gt; &gt; &gt;=
 &gt; &gt;*, std::vector&lt;std::vector&lt;finite::complexFinite, std::allo=
cator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;f=
inite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt;=
 &gt;&amp;, std::vector&lt;std::vector&lt;std::vector&lt;std::vector&lt;std=
::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&=
gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::allo=
cator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::v=
ector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::co=
mplexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinit=
e, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;, st=
d::allocator&lt;std::vector&lt;std::vector&lt;std::vector&lt;finite::comple=
xFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&l=
t;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFi=
nite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;fi=
nite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std:=
:allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finit=
e::complexFinite&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;=
std::vector&lt;std::vector&lt;std::vector&lt;std::vector&lt;finite::complex=
Finite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt=
;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFin=
ite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;fin=
ite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::=
allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite=
::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vector=
&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;=
finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::co=
mplexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, st=
d::allocator&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::a=
llocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&l=
t;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &=
gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;=
std::vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &gt;, s=
td::allocator&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::F=
inite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;f=
inite::Finite, std::allocator&lt;finite::Finite&gt; &gt;, std::allocator&lt=
;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &gt; &=
gt; &gt; &gt; &gt;, std::vector&lt;finite::Finite, std::allocator&lt;finite=
::Finite&gt; &gt;, unsigned int, bool, std::vector&lt;int, std::allocator&l=
t;int&gt; &gt;, std::vector&lt;std::vector&lt;int, std::allocator&lt;int&gt=
; &gt;, std::allocator&lt;std::vector&lt;int, std::allocator&lt;int&gt; &gt=
; &gt; &gt;, std::vector&lt;int, std::allocator&lt;int&gt; &gt;, std::vecto=
r&lt;unsigned int, std::allocator&lt;unsigned int&gt; &gt; const&amp;, std:=
:vector&lt;unsigned int, std::allocator&lt;unsigned int&gt; &gt; const&amp;=
, std::vector&lt;std::vector&lt;std::vector&lt;std::vector&lt;finite::compl=
exFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&=
lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexF=
inite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;f=
inite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std=
::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;fini=
te::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vect=
or&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&l=
t;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::=
complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, =
std::allocator&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std:=
:allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector=
&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;=
 &gt; &gt; &gt; &gt; &gt; &gt; const&amp;, std::vector&lt;std::vector&lt;st=
d::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite=
::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexF=
inite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::all=
ocator&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocat=
or&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;fini=
te::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &g=
t; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;std::vector&l=
t;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, =
std::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;f=
inite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;s=
td::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinit=
e&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::al=
locator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt; con=
st&amp;, std::vector&lt;std::vector&lt;bool, std::allocator&lt;bool&gt; &gt=
;, std::allocator&lt;std::vector&lt;bool, std::allocator&lt;bool&gt; &gt; &=
gt; &gt;, finite::Finite, std::vector&lt;bool, std::allocator&lt;bool&gt; &=
gt;, unsigned int, unsigned int, bool, bool, std::vector&lt;bool, std::allo=
cator&lt;bool&gt; &gt; const*, std::vector&lt;std::vector&lt;finite::comple=
xFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&l=
t;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFi=
nite&gt; &gt; &gt; &gt; const*, unsigned int, bool, std::vector&lt;std::vec=
tor&lt;std::vector&lt;unsigned int, std::allocator&lt;unsigned int&gt; &gt;=
, std::allocator&lt;std::vector&lt;unsigned int, std::allocator&lt;unsigned=
 int&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;un=
signed int, std::allocator&lt;unsigned int&gt; &gt;, std::allocator&lt;std:=
:vector&lt;unsigned int, std::allocator&lt;unsigned int&gt; &gt; &gt; &gt; =
&gt; &gt; const*, std::vector&lt;std::vector&lt;std::vector&lt;finite::comp=
lexx, std::allocator&lt;finite::complexx&gt; &gt;, std::allocator&lt;std::v=
ector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt; &gt;=
 &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite::complexx, st=
d::allocator&lt;finite::complexx&gt; &gt;, std::allocator&lt;std::vector&lt=
;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt; &gt; &gt; &g=
t; &gt; const*)\&quot;,file=3D\&quot;points/apple/rx_hw/VP/ETC_VP_Frontend.=
cpp\&quot;,fullname=3D\&quot;/prj/qct/etc-sys/apple/users/usery/Simu/sim_ap=
ple/points/apple/rx_hw/VP/ETC_VP_Frontend.cpp\&quot;,line=3D\&quot;4520\&qu=
ot;,times=3D\&quot;0\&quot;,original-location=3D\&quot;ETC_VP_Frontend.cpp:=
4520\&quot;}]}\n(gdb) \n149^done,locals=3D[{name=3D\&quot;pucch_reporting_t=
ype\&quot;,type=3D\&quot;std::vector&lt;unsigned int, std::allocator&lt;uns=
igned int&gt; &gt;\&quot;},{name=3D\&quot;rnnBias_DualDecode\&quot;,type=3D=
\&quot;double\&quot;,value=3D\&quot;6.9533558070642619e-310\&quot;},{name=
=3D\&quot;subframeNumMod\&quot;,type=3D\&quot;const int\&quot;,value=3D\&qu=
ot;10922\&quot;},{name=3D\&quot;CSF_CON_printed\&quot;,type=3D\&quot;bool\&=
quot;,value=3D\&quot;true\&quot;},{name=3D\&quot;CSF_report_exist\&quot;,ty=
pe=3D\&quot;std::vector&lt;bool, std::allocator&lt;bool&gt; &gt;\&quot;},{n=
ame=3D\&quot;useCSF_L0\&quot;,type=3D\&quot;const bool\&quot;,value=3D\&quo=
t;true\&quot;},{name=3D\&quot;enforceTM10Schedule\&quot;,type=3D\&quot;bool=
\&quot;,value=3D\&quot;false\&quot;},{name=3D\&quot;NumSymbPerSlot\&quot;,t=
ype=3D\&quot;uint\&quot;,value=3D\&quot;32767\&quot;},{name=3D\&quot;__PRET=
TY_FUNCTION__\&quot;,type=3D\&quot;const char [40]\&quot;},{name=3D\&quot;c=
han_type\&quot;,type=3D\&quot;std::vector&lt;unsigned int, std::allocator&l=
t;unsigned int&gt; &gt;\&quot;},{name=3D\&quot;doCSF_Proc_DualDecode\&quot;=
,type=3D\&quot;bool\&quot;,value=3D\&quot;false\&quot;},{name=3D\&quot;sche=
duledCSF\&quot;,type=3D\&quot;std::vector&lt;std::vector&lt;std::vector&lt;=
bool, std::allocator&lt;bool&gt; &gt;, std::allocator&lt;std::vector&lt;boo=
l, std::allocator&lt;bool&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector=
&lt;std::vector&lt;bool, std::allocator&lt;bool&gt; &gt;, std::allocator&lt=
;std::vector&lt;bool, std::allocator&lt;bool&gt; &gt; &gt; &gt; &gt; &gt;\&=
quot;},{name=3D\&quot;isDLSubframe\&quot;,type=3D\&quot;bool\&quot;,value=
=3D\&quot;208\&quot;},{name=3D\&quot;total_subframe_num\&quot;,type=3D\&quo=
t;std::vector&lt;unsigned long long, std::allocator&lt;unsigned long long&g=
t; &gt;\&quot;},{name=3D\&quot;bwp_index\&quot;,type=3D\&quot;std::vector&l=
t;std::vector&lt;unsigned int, std::allocator&lt;unsigned int&gt; &gt;, std=
::allocator&lt;std::vector&lt;unsigned int, std::allocator&lt;unsigned int&=
gt; &gt; &gt; &gt;\&quot;},{name=3D\&quot;sched_pusch_csf\&quot;,type=3D\&q=
uot;std::vector&lt;bool, std::allocator&lt;bool&gt; &gt;\&quot;},{name=3D\&=
quot;issue_SCHED_MSG\&quot;,type=3D\&quot;std::vector&lt;bool, std::allocat=
or&lt;bool&gt; &gt;\&quot;},{name=3D\&quot;interfBias_DualDecode\&quot;,typ=
e=3D\&quot;std::vector&lt;double, std::allocator&lt;double&gt; &gt;\&quot;}=
,{name=3D\&quot;pmchEnabledThisSF\&quot;,type=3D\&quot;bool\&quot;,value=3D=
\&quot;181\&quot;},{name=3D\&quot;lastSyminSF\&quot;,type=3D\&quot;bool\&qu=
ot;,value=3D\&quot;110\&quot;}]\n(gdb) \n150^done,stack=3D[frame=3D{level=
=3D\&quot;0\&quot;,addr=3D\&quot;0x00002aaabc5d80ff\&quot;,func=3D\&quot;ET=
C_EU::EU_PSD::scheduleAllDecode\&quot;,file=3D\&quot;points/apple/psd/eu_ps=
d.cpp\&quot;,fullname=3D\&quot;/prj/qct/etc-sys/apple/users/usery/Simu/sim_=
apple/points/apple/psd/eu_psd.cpp\&quot;,line=3D\&quot;13346\&quot;},frame=
=3D{level=3D\&quot;1\&quot;,addr=3D\&quot;0x00002aaabc59696f\&quot;,func=3D=
\&quot;ETC_EU::EU_PSD::Update\&quot;,file=3D\&quot;points/apple/psd/eu_psd.=
cpp\&quot;,fullname=3D\&quot;/prj/qct/etc-sys/apple/users/usery/Simu/sim_ap=
ple/points/apple/psd/eu_psd.cpp\&quot;,line=3D\&quot;5530\&quot;},frame=3D{=
level=3D\&quot;2\&quot;,addr=3D\&quot;0x00002aaac7b3ea55\&quot;,func=3D\&qu=
ot;ETC_EU::EU::RxxRUpdate\&quot;,file=3D\&quot;points/apple/top/ue.cpp\&quo=
t;,fullname=3D\&quot;/apple/users/usery/Simu/sim_apple/points/apple/top/ue.=
cpp\&quot;,line=3D\&quot;1273\&quot;},frame=3D{level=3D\&quot;3\&quot;,addr=
=3D\&quot;0x00002aaac7b3ce40\&quot;,func=3D\&quot;ETC_EU::EU::Update\&quot;=
,file=3D\&quot;points/apple/top/ue.cpp\&quot;,fullname=3D\&quot;/abc/def/et=
c-sys/apple/users/usery/Simu/sim_apple/points/apple/top/ue.cpp\&quot;,line=
=3D\&quot;1036\&quot;},frame=3D{level=3D\&quot;4\&quot;,addr=3D\&quot;0x000=
02aaacf258e96\&quot;,func=3D\&quot;wiltsim::WiltSimTop_class::AdvanceSim\&q=
uot;,file=3D\&quot;wiltsim/sim/top/WiltSimTop.cpp\&quot;,fullname=3D\&quot;=
/abc/def/etc-sys/apple/users/usery/Simu/sim_apple/wiltsim/sim/top/WiltSimTo=
p.cpp\&quot;,line=3D\&quot;168\&quot;},frame=3D{level=3D\&quot;5\&quot;,add=
r=3D\&quot;0x00002aaacf97834e\&quot;,func=3D\&quot;main\&quot;,file=3D\&quo=
t;wiltsim/sim/main/main.cpp\&quot;,fullname=3D\&quot;/abc/def/etc-sys/apple=
/users/usery/Simu/sim_apple/wiltsim/sim/main/main.cpp\&quot;,line=3D\&quot;=
45\&quot;},frame=3D{level=3D\&quot;6\&quot;,addr=3D\&quot;0x00002aaad07fdc3=
6\&quot;,func=3D\&quot;__libc_start_main\&quot;,from=3D\&quot;/lib64/libc.s=
o.6\&quot;},frame=3D{level=3D\&quot;7\&quot;,addr=3D\&quot;0x000055555556b2=
e9\&quot;,func=3D\&quot;_start\&quot;,file=3D\&quot;../sysdeps/x86_64/elf/s=
tart.S\&quot;,line=3D\&quot;103\&quot;}]\n(gdb) \n^running\n*running,thread=
-id=3D\&quot;1\&quot;\n(gdb) \n*stopped,reason=3D\&quot;end-stepping-range\=
&quot;,frame=3D{addr=3D\&quot;0x00002aaabc5d8121\&quot;,func=3D\&quot;ETC_E=
U::EU_PSD::scheduleAllDecode\&quot;,args=3D[{name=3D\&quot;this\&quot;,valu=
e=3D\&quot;0x55560d500e40\&quot;}],file=3D\&quot;points/apple/psd/eu_psd.cp=
p\&quot;,fullname=3D\&quot;/abc/def/etc-sys/apple/users/usery/Simu/sim_appl=
e/points/apple/psd/eu_psd.cpp\&quot;,line=3D\&quot;13348\&quot;},thread-id=
=3D\&quot;1\&quot;,stopped-threads=3D[\&quot;1\&quot;],core=3D\&quot;5\&quo=
t;\n~\&quot;Continuing.\\n\&quot;\n^running\n*running,thread-id=3D\&quot;1\=
&quot;\n(gdb) \n=3Dbreakpoint-modified,bkpt=3D{number=3D\&quot;5\&quot;,typ=
e=3D\&quot;breakpoint\&quot;,disp=3D\&quot;keep\&quot;,enabled=3D\&quot;y\&=
quot;,addr=3D\&quot;0x00002aaac4d594fa\&quot;,func=3D\&quot;SIMULATION_VP::=
ETC_VP_Frontend::chanDecodeComputing(boost::shared_ptr&lt;SIMULATION_VP::ET=
C_V1_DEC_CON&gt;, std::vector&lt;std::vector&lt;std::vector&lt;std::vector&=
lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;, std::allo=
cator&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::complex=
x&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finit=
e::complexx, std::allocator&lt;finite::complexx&gt; &gt;, std::allocator&lt=
;std::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &g=
t; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;std=
::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;, =
std::allocator&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite=
::complexx&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector=
&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;, std::all=
ocator&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::comple=
xx&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;*, std::vector&lt;std::vector&lt;s=
td::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;=
, std::allocator&lt;std::vector&lt;finite::complexx, std::allocator&lt;fini=
te::complexx&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vect=
or&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;, std::a=
llocator&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::comp=
lexx&gt; &gt; &gt; &gt; &gt; &gt; const&amp;, std::vector&lt;std::vector&lt=
;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFin=
ite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::=
allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;st=
d::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite=
::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexF=
inite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;=
&amp;, std::vector&lt;std::vector&lt;std::vector&lt;finite::complexFinite, =
std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::ve=
ctor&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; =
&gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite::com=
plexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocato=
r&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::comple=
xFinite&gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;st=
d::vector&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finit=
e&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite, std::allocator=
&lt;finite::Finite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std=
::vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &gt;, std:=
:allocator&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Fini=
te&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vect=
or&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &=
gt;, std::allocator&lt;std::vector&lt;finite::Finite, std::allocator&lt;fin=
ite::Finite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vecto=
r&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &gt;, std::alloca=
tor&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; =
&gt; &gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;finite::complexFini=
te, std::allocator&lt;finite::complexFinite&gt; &gt;&amp;, std::vector&lt;s=
td::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinit=
e&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::al=
locator&lt;finite::complexFinite&gt; &gt; &gt; &gt;&amp;, std::vector&lt;un=
signed int, std::allocator&lt;unsigned int&gt; &gt;, std::vector&lt;std::ve=
ctor&lt;std::vector&lt;int, std::allocator&lt;int&gt; &gt;, std::allocator&=
lt;std::vector&lt;int, std::allocator&lt;int&gt; &gt; &gt; &gt;, std::alloc=
ator&lt;std::vector&lt;std::vector&lt;int, std::allocator&lt;int&gt; &gt;, =
std::allocator&lt;std::vector&lt;int, std::allocator&lt;int&gt; &gt; &gt; &=
gt; &gt; &gt;, std::vector&lt;std::vector&lt;std::vector&lt;std::vector&lt;=
finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, st=
d::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;fin=
ite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std=
::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&=
gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::allo=
cator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator=
&lt;std::vector&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std=
::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::ve&qu=
ot; 0)</div><div>=C2=A0 gdbmi-bnf-stream-record()</div><div>=C2=A0 gdbmi-bn=
f-out-of-band-record()</div><div>=C2=A0 gdbmi-bnf-output()</div><div>=C2=A0=
 #[0 &quot;<span class=3D"" style=3D"white-space:pre">	</span>\300W\205  \n=
 \205  \202 =C2=A0\207&quot; [42969 gdbmi-bnf-offset gdbmi-bnf-state] 2 &qu=
ot;\n\n(fn)&quot;]()</div><div>=C2=A0 funcall(#[0 &quot;<span class=3D"" st=
yle=3D"white-space:pre">	</span>\300W\205  \n \205  \202 =C2=A0\207&quot; [=
42969 gdbmi-bnf-offset gdbmi-bnf-state] 2 &quot;\n\n(fn)&quot;])</div><div>=
=C2=A0 gud-gdbmi-marker-fietcr(&quot;=3Dbreakpoint-modified,bkpt=3D{number=
=3D\&quot;5\&quot;,type=3D\&quot;breakpoint\&quot;,disp=3D\&quot;keep\&quot=
;,enabled=3D\&quot;y\&quot;,addr=3D\&quot;0x00002aaac4d594fa\&quot;,func=3D=
\&quot;SIMULATION_VP::ETC_VP_Frontend::chanDecodeComputing(boost::shared_pt=
r&lt;SIMULATION_VP::ETC_V1_DEC_CON&gt;, std::vector&lt;std::vector&lt;std::=
vector&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::comple=
xx&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexx, std::alloca=
tor&lt;finite::complexx&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&l=
t;std::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &=
gt;, std::allocator&lt;std::vector&lt;finite::complexx, std::allocator&lt;f=
inite::complexx&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vector=
&lt;std::vector&lt;std::vector&lt;finite::complexx, std::allocator&lt;finit=
e::complexx&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexx, st=
d::allocator&lt;finite::complexx&gt; &gt; &gt; &gt;, std::allocator&lt;std:=
:vector&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::compl=
exx&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexx, std::alloc=
ator&lt;finite::complexx&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;*, std::vect=
or&lt;std::vector&lt;std::vector&lt;finite::complexx, std::allocator&lt;fin=
ite::complexx&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexx, =
std::allocator&lt;finite::complexx&gt; &gt; &gt; &gt;, std::allocator&lt;st=
d::vector&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::com=
plexx&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexx, std::all=
ocator&lt;finite::complexx&gt; &gt; &gt; &gt; &gt; &gt; const&amp;, std::ve=
ctor&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator=
&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite=
::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;=
, std::allocator&lt;std::vector&lt;std::vector&lt;finite::complexFinite, st=
d::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vect=
or&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &g=
t; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;std::vector&lt;f=
inite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std=
::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;fini=
te::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std:=
:vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&g=
t; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::alloc=
ator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vecto=
r&lt;std::vector&lt;std::vector&lt;std::vector&lt;finite::Finite, std::allo=
cator&lt;finite::Finite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::=
Finite, std::allocator&lt;finite::Finite&gt; &gt; &gt; &gt;, std::allocator=
&lt;std::vector&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite:=
:Finite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite, std::all=
ocator&lt;finite::Finite&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;st=
d::vector&lt;std::vector&lt;std::vector&lt;finite::Finite, std::allocator&l=
t;finite::Finite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite,=
 std::allocator&lt;finite::Finite&gt; &gt; &gt; &gt;, std::allocator&lt;std=
::vector&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finite=
&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite, std::allocator&=
lt;finite::Finite&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&=
lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;&=
amp;, std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&l=
t;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::=
complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;&a=
mp;, std::vector&lt;unsigned int, std::allocator&lt;unsigned int&gt; &gt;, =
std::vector&lt;std::vector&lt;std::vector&lt;int, std::allocator&lt;int&gt;=
 &gt;, std::allocator&lt;std::vector&lt;int, std::allocator&lt;int&gt; &gt;=
 &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;int, std::alloc=
ator&lt;int&gt; &gt;, std::allocator&lt;std::vector&lt;int, std::allocator&=
lt;int&gt; &gt; &gt; &gt; &gt; &gt;, std::vector&lt;std::vector&lt;std::vec=
tor&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::comp=
lexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite,=
 std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator=
&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;=
finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::co=
mplexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt=
; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;std::vector&lt;fini=
te::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::a=
llocator&lt;std::ve&quot;)</div><div>=C2=A0 apply(gud-gdbmi-marker-fietcr &=
quot;=3Dbreakpoint-modified,bkpt=3D{number=3D\&quot;5\&quot;,type=3D\&quot;=
breakpoint\&quot;,disp=3D\&quot;keep\&quot;,enabled=3D\&quot;y\&quot;,addr=
=3D\&quot;0x00002aaac4d594fa\&quot;,func=3D\&quot;SIMULATION_VP::ETC_VP_Fro=
ntend::chanDecodeComputing(boost::shared_ptr&lt;SIMULATION_VP::ETC_V1_DEC_C=
ON&gt;, std::vector&lt;std::vector&lt;std::vector&lt;std::vector&lt;finite:=
:complexx, std::allocator&lt;finite::complexx&gt; &gt;, std::allocator&lt;s=
td::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;=
 &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite::complex=
x, std::allocator&lt;finite::complexx&gt; &gt;, std::allocator&lt;std::vect=
or&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt; &gt; &g=
t; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;std::vector&l=
t;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;, std::alloc=
ator&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::complexx=
&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite=
::complexx, std::allocator&lt;finite::complexx&gt; &gt;, std::allocator&lt;=
std::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt=
; &gt; &gt; &gt; &gt; &gt; &gt;*, std::vector&lt;std::vector&lt;std::vector=
&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;, std::all=
ocator&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::comple=
xx&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;fini=
te::complexx, std::allocator&lt;finite::complexx&gt; &gt;, std::allocator&l=
t;std::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &=
gt; &gt; &gt; &gt; &gt; const&amp;, std::vector&lt;std::vector&lt;std::vect=
or&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &g=
t;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&=
lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&=
lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexF=
inite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std=
::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;&amp;, std=
::vector&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::alloc=
ator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;fi=
nite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; =
&gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finite::complexFinite=
, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::=
vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt=
; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;std::vector&=
lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &gt;=
, std::allocator&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite=
::Finite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&l=
t;finite::Finite, std::allocator&lt;finite::Finite&gt; &gt;, std::allocator=
&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &gt=
; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;std:=
:vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &gt;, std::=
allocator&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finit=
e&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;finit=
e::Finite, std::allocator&lt;finite::Finite&gt; &gt;, std::allocator&lt;std=
::vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &gt; &gt; =
&gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;finite::complexFinite, std::a=
llocator&lt;finite::complexFinite&gt; &gt;&amp;, std::vector&lt;std::vector=
&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;=
, std::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt=
;finite::complexFinite&gt; &gt; &gt; &gt;&amp;, std::vector&lt;unsigned int=
, std::allocator&lt;unsigned int&gt; &gt;, std::vector&lt;std::vector&lt;st=
d::vector&lt;int, std::allocator&lt;int&gt; &gt;, std::allocator&lt;std::ve=
ctor&lt;int, std::allocator&lt;int&gt; &gt; &gt; &gt;, std::allocator&lt;st=
d::vector&lt;std::vector&lt;int, std::allocator&lt;int&gt; &gt;, std::alloc=
ator&lt;std::vector&lt;int, std::allocator&lt;int&gt; &gt; &gt; &gt; &gt; &=
gt;, std::vector&lt;std::vector&lt;std::vector&lt;std::vector&lt;finite::co=
mplexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocat=
or&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::compl=
exFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&l=
t;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, =
std::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;f=
inite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;std::v=
ector&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocato=
r&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::ve&quot;)</div>=
<div>=C2=A0 gud-marker-fietcr(&quot;=3Dbreakpoint-modified,bkpt=3D{number=
=3D\&quot;5\&quot;,type=3D\&quot;breakpoint\&quot;,disp=3D\&quot;keep\&quot=
;,enabled=3D\&quot;y\&quot;,addr=3D\&quot;0x00002aaac4d594fa\&quot;,func=3D=
\&quot;SIMULATION_VP::ETC_VP_Frontend::chanDecodeComputing(boost::shared_pt=
r&lt;SIMULATION_VP::ETC_V1_DEC_CON&gt;, std::vector&lt;std::vector&lt;std::=
vector&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::comple=
xx&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexx, std::alloca=
tor&lt;finite::complexx&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&l=
t;std::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &=
gt;, std::allocator&lt;std::vector&lt;finite::complexx, std::allocator&lt;f=
inite::complexx&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vector=
&lt;std::vector&lt;std::vector&lt;finite::complexx, std::allocator&lt;finit=
e::complexx&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexx, st=
d::allocator&lt;finite::complexx&gt; &gt; &gt; &gt;, std::allocator&lt;std:=
:vector&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::compl=
exx&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexx, std::alloc=
ator&lt;finite::complexx&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;*, std::vect=
or&lt;std::vector&lt;std::vector&lt;finite::complexx, std::allocator&lt;fin=
ite::complexx&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexx, =
std::allocator&lt;finite::complexx&gt; &gt; &gt; &gt;, std::allocator&lt;st=
d::vector&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::com=
plexx&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexx, std::all=
ocator&lt;finite::complexx&gt; &gt; &gt; &gt; &gt; &gt; const&amp;, std::ve=
ctor&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator=
&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite=
::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;=
, std::allocator&lt;std::vector&lt;std::vector&lt;finite::complexFinite, st=
d::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vect=
or&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &g=
t; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vector&lt;std::vector&lt;f=
inite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std=
::allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;fini=
te::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std:=
:vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&g=
t; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::alloc=
ator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vecto=
r&lt;std::vector&lt;std::vector&lt;std::vector&lt;finite::Finite, std::allo=
cator&lt;finite::Finite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::=
Finite, std::allocator&lt;finite::Finite&gt; &gt; &gt; &gt;, std::allocator=
&lt;std::vector&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite:=
:Finite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite, std::all=
ocator&lt;finite::Finite&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;st=
d::vector&lt;std::vector&lt;std::vector&lt;finite::Finite, std::allocator&l=
t;finite::Finite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite,=
 std::allocator&lt;finite::Finite&gt; &gt; &gt; &gt;, std::allocator&lt;std=
::vector&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finite=
&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite, std::allocator&=
lt;finite::Finite&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&=
lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;&=
amp;, std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&l=
t;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::=
complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;&a=
mp;, std::vector&lt;unsigned int, std::allocator&lt;unsigned int&gt; &gt;, =
std::vector&lt;std::vector&lt;std::vector&lt;int, std::allocator&lt;int&gt;=
 &gt;, std::allocator&lt;std::vector&lt;int, std::allocator&lt;int&gt; &gt;=
 &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;int, std::alloc=
ator&lt;int&gt; &gt;, std::allocator&lt;std::vector&lt;int, std::allocator&=
lt;int&gt; &gt; &gt; &gt; &gt; &gt;, std::vector&lt;std::vector&lt;std::vec=
tor&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::comp=
lexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite,=
 std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator=
&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;=
finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::co=
mplexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt=
; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;std::vector&lt;fini=
te::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::a=
llocator&lt;std::ve&quot;)</div><div>=C2=A0 gud-fietcr(#&lt;process gud-sim=
_apple.LGD.bin&gt; &quot;=3Dbreakpoint-modified,bkpt=3D{number=3D\&quot;5\&=
quot;,type=3D\&quot;breakpoint\&quot;,disp=3D\&quot;keep\&quot;,enabled=3D\=
&quot;y\&quot;,addr=3D\&quot;0x00002aaac4d594fa\&quot;,func=3D\&quot;SIMULA=
TION_VP::ETC_VP_Frontend::chanDecodeComputing(boost::shared_ptr&lt;SIMULATI=
ON_VP::ETC_V1_DEC_CON&gt;, std::vector&lt;std::vector&lt;std::vector&lt;std=
::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;, =
std::allocator&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite=
::complexx&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector=
&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;, std::all=
ocator&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::comple=
xx&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vect=
or&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&g=
t; &gt;, std::allocator&lt;std::vector&lt;finite::complexx, std::allocator&=
lt;finite::complexx&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;st=
d::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt;,=
 std::allocator&lt;std::vector&lt;finite::complexx, std::allocator&lt;finit=
e::complexx&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;*, std::vector&lt;std::ve=
ctor&lt;std::vector&lt;finite::complexx, std::allocator&lt;finite::complexx=
&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexx, std::allocato=
r&lt;finite::complexx&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;=
std::vector&lt;finite::complexx, std::allocator&lt;finite::complexx&gt; &gt=
;, std::allocator&lt;std::vector&lt;finite::complexx, std::allocator&lt;fin=
ite::complexx&gt; &gt; &gt; &gt; &gt; &gt; const&amp;, std::vector&lt;std::=
vector&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::c=
omplexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFini=
te, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::alloca=
tor&lt;std::vector&lt;std::vector&lt;finite::complexFinite, std::allocator&=
lt;finite::complexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite:=
:complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; =
&gt; &gt;&amp;, std::vector&lt;std::vector&lt;std::vector&lt;finite::comple=
xFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&l=
t;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::complexFi=
nite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;std::vector&lt;fi=
nite::complexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;, std:=
:allocator&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finit=
e::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;std::vec=
tor&lt;std::vector&lt;std::vector&lt;finite::Finite, std::allocator&lt;fini=
te::Finite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite, std::=
allocator&lt;finite::Finite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vect=
or&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &=
gt;, std::allocator&lt;std::vector&lt;finite::Finite, std::allocator&lt;fin=
ite::Finite&gt; &gt; &gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;=
std::vector&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Fin=
ite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::Finite, std::allocat=
or&lt;finite::Finite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vector&lt;s=
td::vector&lt;finite::Finite, std::allocator&lt;finite::Finite&gt; &gt;, st=
d::allocator&lt;std::vector&lt;finite::Finite, std::allocator&lt;finite::Fi=
nite&gt; &gt; &gt; &gt; &gt; &gt; &gt; &gt;&amp;, std::vector&lt;finite::co=
mplexFinite, std::allocator&lt;finite::complexFinite&gt; &gt;&amp;, std::ve=
ctor&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::com=
plexFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite=
, std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt;&amp;, std::vec=
tor&lt;unsigned int, std::allocator&lt;unsigned int&gt; &gt;, std::vector&l=
t;std::vector&lt;std::vector&lt;int, std::allocator&lt;int&gt; &gt;, std::a=
llocator&lt;std::vector&lt;int, std::allocator&lt;int&gt; &gt; &gt; &gt;, s=
td::allocator&lt;std::vector&lt;std::vector&lt;int, std::allocator&lt;int&g=
t; &gt;, std::allocator&lt;std::vector&lt;int, std::allocator&lt;int&gt; &g=
t; &gt; &gt; &gt; &gt;, std::vector&lt;std::vector&lt;std::vector&lt;std::v=
ector&lt;finite::complexFinite, std::allocator&lt;finite::complexFinite&gt;=
 &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, std::allocat=
or&lt;finite::complexFinite&gt; &gt; &gt; &gt;, std::allocator&lt;std::vect=
or&lt;std::vector&lt;finite::complexFinite, std::allocator&lt;finite::compl=
exFinite&gt; &gt;, std::allocator&lt;std::vector&lt;finite::complexFinite, =
std::allocator&lt;finite::complexFinite&gt; &gt; &gt; &gt; &gt; &gt;, std::=
allocator&lt;std::vector&lt;std::vector&lt;std::vector&lt;finite::complexFi=
nite, std::allocator&lt;finite::complexFinite&gt; &gt;, std::allocator&lt;s=
td::ve&quot;)</div><div><br></div><div><br></div><div><br></div><div><br></=
div><div>In GNU Emacs 24.4.1 (x86_64-unknown-linux-gnu, GTK+ Version 2.18.9=
)</div><div>=C2=A0of 2014-11-15 on vl-nbharadw-gridsdca</div><div>Windowing=
 system distributor `The X.Org Foundation&#39;, version 11.0.11202000</div>=
<div>System Description:<span class=3D"" style=3D"white-space:pre">	</span>=
SUSE Linux Enterprise Server 11 (x86_64)</div><div><br></div><div>Configure=
d using:</div><div>=C2=A0`configure --prefix=3D/pkg/software/emacs/24.4/sle=
s11 --without-rsvg&#39;</div><div><br></div><div>Important settings:</div><=
div>=C2=A0 value of $LANG: en_US.UTF-8</div><div>=C2=A0 value of $XMODIFIER=
S: @im=3Dlocal</div><div>=C2=A0 locale-coding-system: utf-8-unix</div><div>=
<br></div><div>Major mode: Debugger</div><div><br></div><div>Minor modes in=
 effect:</div><div>=C2=A0 global-semanticdb-minor-mode: t</div><div>=C2=A0 =
global-semantic-idle-scheduler-mode: t</div><div>=C2=A0 global-semantic-idl=
e-summary-mode: t</div><div>=C2=A0 global-semantic-stickyfunc-mode: t</div>=
<div>=C2=A0 semantic-mode: t</div><div>=C2=A0 clean-aindent-mode: t</div><d=
iv>=C2=A0 show-smartparens-global-mode: t</div><div>=C2=A0 yas-global-mode:=
 t</div><div>=C2=A0 yas-minor-mode: t</div><div>=C2=A0 gdb-many-windows: t<=
/div><div>=C2=A0 projectile-global-mode: t</div><div>=C2=A0 projectile-mode=
: t</div><div>=C2=A0 helm-descbinds-mode: t</div><div>=C2=A0 helm-mode: t</=
div><div>=C2=A0 shell-dirtrack-mode: t</div><div>=C2=A0 recentf-mode: t</di=
v><div>=C2=A0 winner-mode: t</div><div>=C2=A0 window-numbering-mode: t</div=
><div>=C2=A0 volatile-highlights-mode: t</div><div>=C2=A0 global-vi-tilde-f=
ringe-mode: t</div><div>=C2=A0 vi-tilde-fringe-mode: t</div><div>=C2=A0 glo=
bal-undo-tree-mode: t</div><div>=C2=A0 undo-tree-mode: t</div><div>=C2=A0 s=
avehist-mode: t</div><div>=C2=A0 popwin-mode: t</div><div>=C2=A0 global-pag=
e-break-lines-mode: t</div><div>=C2=A0 Info-breadcrumbs-in-mode-line-mode: =
t</div><div>=C2=A0 ido-vertical-mode: t</div><div>=C2=A0 flx-ido-mode: t</d=
iv><div>=C2=A0 eyebrowse-mode: t</div><div>=C2=A0 global-evil-surround-mode=
: t</div><div>=C2=A0 evil-surround-mode: t</div><div>=C2=A0 global-evil-sea=
rch-highlight-persist: t</div><div>=C2=A0 evil-search-highlight-persist: t<=
/div><div>=C2=A0 evil-jumper-mode: t</div><div>=C2=A0 evil-escape-mode: t</=
div><div>=C2=A0 global-anzu-mode: t</div><div>=C2=A0 anzu-mode: t</div><div=
>=C2=A0 eval-sexp-fu-flash-mode: t</div><div>=C2=A0 global-diff-hl-mode: t<=
/div><div>=C2=A0 diff-auto-refine-mode: t</div><div>=C2=A0 global-hl-line-m=
ode: t</div><div>=C2=A0 xterm-mouse-mode: t</div><div>=C2=A0 global-auto-re=
vert-mode: t</div><div>=C2=A0 evil-leader-mode: t</div><div>=C2=A0 evil-mod=
e: t</div><div>=C2=A0 evil-local-mode: t</div><div>=C2=A0 which-key-mode: t=
</div><div>=C2=A0 override-global-mode: t</div><div>=C2=A0 spacemacs-additi=
onal-leader-mode: t</div><div>=C2=A0 electric-indent-mode: t</div><div>=C2=
=A0 mouse-wheel-mode: t</div><div>=C2=A0 file-name-shadow-mode: t</div><div=
>=C2=A0 global-font-lock-mode: t</div><div>=C2=A0 font-lock-mode: t</div><d=
iv>=C2=A0 auto-composition-mode: t</div><div>=C2=A0 auto-encryption-mode: t=
</div><div>=C2=A0 auto-compression-mode: t</div><div>=C2=A0 buffer-read-onl=
y: t</div><div>=C2=A0 column-number-mode: t</div><div>=C2=A0 line-number-mo=
de: t</div><div>=C2=A0 transient-mark-mode: t</div><div><br></div><div>Rece=
nt messages:</div><div>error in process fietcr: gdbmi-bnf-stream-record: St=
ack overflow in regexp matcher</div><div>error in process fietcr: Stack ove=
rflow in regexp matcher</div><div>Mark set</div><div>Debug on Error enabled=
 globally</div><div>debug-on-error enabled.</div><div>Entering debugger...<=
/div><div>debugger-frame-number: This line is not a function call</div><div=
>command-execute: Buffer is read-only: #&lt;buffer *Backtrace*&gt; [2 times=
]</div><div>debugger-frame-number: This line is not a function call</div><d=
iv>Quit</div><div><br></div><div>Memory information:</div><div>((conses 16 =
2563016 1021331)</div><div>=C2=A0(symbols 48 64059 16)</div><div>=C2=A0(mis=
cs 40 12883 3188)</div><div>=C2=A0(strings 32 349590 287677)</div><div>=C2=
=A0(string-bytes 1 17342091)</div><div>=C2=A0(vectors 16 152172)</div><div>=
=C2=A0(vector-slots 8 4020213 1448882)</div><div>=C2=A0(floats 8 15298 1000=
1)</div><div>=C2=A0(intervals 56 28898 15957)</div><div>=C2=A0(buffers 960 =
44)</div><div>=C2=A0(heap 1024 184239 72761))</div><div><br></div></div>

--001a1140bfd8f54b870526ad6239--




Acknowledgement sent to Cheng-An Yang <rhymer123@HIDDEN>:
New bug report received and forwarded. Copy sent to bug-gnu-emacs@HIDDEN. Full text available.
Report forwarded to bug-gnu-emacs@HIDDEN:
bug#22149; Package emacs. Full text available.
Please note: This is a static page, with minimal formatting, updated once a day.
Click here to see this page with the latest information and nicer formatting.
Last modified: Fri, 1 Jul 2016 03:30:02 UTC

GNU bug tracking system
Copyright (C) 1999 Darren O. Benham, 1997 nCipher Corporation Ltd, 1994-97 Ian Jackson.